ss-tools/.kilocode/workflows/speckit.implement.md

description, handoffs

description	handoffs
Execute the implementation plan by processing and executing all tasks defined in tasks.md	label agent prompt send Audit & Verify (Tester) tester Perform semantic audit, algorithm emulation, and unit test verification for the completed tasks. true label agent prompt send Orchestration Control orchestrator Review Tester's feedback and coordinate next steps. true

User Input

$ARGUMENTS

You MUST consider the user input before proceeding (if not empty).

Outline

1. Run .specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'''m Groot' (or double-quote if possible: "I'm Groot").

2. Check checklists status (if FEATURE_DIR/checklists/ exists):

   • Scan all checklist files in the checklists/ directory

   • For each checklist, count:

     • Total items: All lines matching - [ ] or - [X] or - [x]
     • Completed items: Lines matching - [X] or - [x]
     • Incomplete items: Lines matching - [ ]

   • Create a status table:

     | Checklist | Total | Completed | Incomplete | Status |
     |-----------|-------|-----------|------------|--------|
     | ux.md     | 12    | 12        | 0          | ✓ PASS |
     | test.md   | 8     | 5         | 3          | ✗ FAIL |
     | security.md | 6   | 6         | 0          | ✓ PASS |
     

   • Calculate overall status:

     • PASS: All checklists have 0 incomplete items
     • FAIL: One or more checklists have incomplete items

   • If any checklist is incomplete:

     • Display the table with incomplete item counts
     • STOP and ask: "Some checklists are incomplete. Do you want to proceed with implementation anyway? (yes/no)"
     • Wait for user response before continuing
     • If user says "no" or "wait" or "stop", halt execution
     • If user says "yes" or "proceed" or "continue", proceed to step 3

   • If all checklists are complete:

     • Display the table showing all checklists passed
     • Automatically proceed to step 3

3. Load and analyze the implementation context:

   • REQUIRED: Read .ai/standards/semantics.md for strict coding standards and contract requirements
   • REQUIRED: Read tasks.md for the complete task list and execution plan
   • REQUIRED: Read plan.md for tech stack, architecture, and file structure
   • REQUIRED IF PRESENT: Read ADR artifacts containing [DEF:id:ADR] nodes and build a blocked-path inventory from @REJECTED
   • IF EXISTS: Read data-model.md for entities and relationships
   • IF EXISTS: Read contracts/ for API specifications and test requirements
   • IF EXISTS: Read research.md for technical decisions and constraints
   • IF EXISTS: Read quickstart.md for integration scenarios

4. Project Setup Verification:

   • REQUIRED: Create/verify ignore files based on actual project setup:

   Detection & Creation Logic:

   • Check if the following command succeeds to determine if the repository is a git repo (create/verify .gitignore if so):

     git rev-parse --git-dir 2>/dev/null
     

   • Check if Dockerfile* exists or Docker in plan.md → create/verify .dockerignore

   • Check if .eslintrc* exists → create/verify .eslintignore

   • Check if eslint.config.* exists → ensure the config's ignores entries cover required patterns

   • Check if .prettierrc* exists → create/verify .prettierignore

   • Check if .npmrc or package.json exists → create/verify .npmignore (if publishing)

   • Check if terraform files (*.tf) exist → create/verify .terraformignore

   • Check if .helmignore needed (helm charts present) → create/verify .helmignore

   If ignore file already exists: Verify it contains essential patterns, append missing critical patterns only If ignore file missing: Create with full pattern set for detected technology

   Common Patterns by Technology (from plan.md tech stack):

   • Node.js/JavaScript/TypeScript: node_modules/, dist/, build/, *.log, .env*
   • Python: __pycache__/, *.pyc, .venv/, venv/, dist/, *.egg-info/
   • Java: target/, *.class, *.jar, .gradle/, build/
   • C#/.NET: bin/, obj/, *.user, *.suo, packages/
   • Go: *.exe, *.test, vendor/, *.out
   • Ruby: .bundle/, log/, tmp/, *.gem, vendor/bundle/
   • PHP: vendor/, *.log, *.cache, *.env
   • Rust: target/, debug/, release/, *.rs.bk, *.rlib, *.prof*, .idea/, *.log, .env*
   • Kotlin: build/, out/, .gradle/, .idea/, *.class, *.jar, *.iml, *.log, .env*
   • C++: build/, bin/, obj/, out/, *.o, *.so, *.a, *.exe, *.dll, .idea/, *.log, .env*
   • C: build/, bin/, obj/, out/, *.o, *.a, *.so, *.exe, Makefile, config.log, .idea/, *.log, .env*
   • Swift: .build/, DerivedData/, *.swiftpm/, Packages/
   • R: .Rproj.user/, .Rhistory, .RData, .Ruserdata, *.Rproj, packrat/, renv/
   • Universal: .DS_Store, Thumbs.db, *.tmp, *.swp, .vscode/, .idea/

   Tool-Specific Patterns:

   • Docker: node_modules/, .git/, Dockerfile*, .dockerignore, *.log*, .env*, coverage/
   • ESLint: node_modules/, dist/, build/, coverage/, *.min.js
   • Prettier: node_modules/, dist/, build/, coverage/, package-lock.json, yarn.lock, pnpm-lock.yaml
   • Terraform: .terraform/, *.tfstate*, *.tfvars, .terraform.lock.hcl
   • Kubernetes/k8s: *.secret.yaml, secrets/, .kube/, kubeconfig*, *.key, *.crt

5. Parse tasks.md structure and extract:

   • Task phases: Setup, Tests, Core, Integration, Polish
   • Task dependencies: Sequential vs parallel execution rules
   • Task details: ID, description, file paths, parallel markers [P]
   • Execution flow: Order and dependency requirements
   • Decision-memory requirements: which tasks inherit ADR ids, @RATIONALE, and @REJECTED guardrails

6. Execute implementation following the task plan:

   • Phase-by-phase execution: Complete each phase before moving to the next
   • Respect dependencies: Run sequential tasks in order, parallel tasks [P] can run together
   • Follow TDD approach: Execute test tasks before their corresponding implementation tasks
   • File-based coordination: Tasks affecting the same files must run sequentially
   • Validation checkpoints: Verify each phase completion before proceeding
   • ADR guardrail discipline: if a task packet or local contract forbids a path via @REJECTED, do not treat it as an implementation option

7. Implementation execution rules:

   • Strict Adherence: Apply .ai/standards/semantics.md rules:
     • Every file MUST start with a [DEF:id:Type] header and end with a matching closing [/DEF:id:Type] anchor.
     • Use @COMPLEXITY / @C: as the primary control tag; treat @TIER only as legacy compatibility metadata.
     • Contract density MUST match effective complexity from .ai/standards/semantics.md:
       • Complexity 1: anchors only.
       • Complexity 2: require @PURPOSE.
       • Complexity 3: require @PURPOSE and @RELATION.
       • Complexity 4: require @PURPOSE, @RELATION, @PRE, @POST, @SIDE_EFFECT.
       • Complexity 5: require full level-4 contract plus @DATA_CONTRACT and @INVARIANT.
     • For Python Complexity 4+ modules, implementation MUST include a meaningful semantic logging path using logger.reason() and logger.reflect().
     • For Python Complexity 5 modules, belief_scope(...) is mandatory and the critical path must be irrigated with logger.reason() / logger.reflect() according to the contract.
     • For Svelte components, require @UX_STATE, @UX_FEEDBACK, @UX_RECOVERY, and @UX_REACTIVITY; runes-only reactivity is allowed ($state, $derived, $effect, $props).
     • Reject pseudo-semantic markup: docstrings containing loose @PURPOSE / @PRE text do NOT satisfy the protocol unless represented in canonical anchored metadata blocks.
     • Preserve and propagate decision-memory tags. Upstream @RATIONALE / @REJECTED are mandatory when carried by the task packet or contract.
     • If logger.explore() or equivalent runtime evidence leads to a retained workaround, mutate the same contract header with reactive Micro-ADR tags: @RATIONALE and @REJECTED.
   • Self-Audit: The Coder MUST use axiom-core tools (like audit_contracts_tool) to verify semantic compliance before completion.
   • Semantic Rejection Gate: If self-audit reveals broken anchors, missing closing tags, missing required metadata for the effective complexity, orphaned critical classes/functions, Complexity 4/5 Python code without required belief-state logging, or retained workarounds without decision-memory tags, the task is NOT complete and cannot be handed off as accepted work.
   • CRITICAL Contracts: If a task description contains a contract summary (e.g., CRITICAL: PRE: ..., POST: ...), these constraints are MANDATORY and must be strictly implemented in the code using guards/assertions (if applicable per protocol).
   • Setup first: Initialize project structure, dependencies, configuration
   • Tests before code: If you need to write tests for contracts, entities, and integration scenarios
   • Core development: Implement models, services, CLI commands, endpoints
   • Integration work: Database connections, middleware, logging, external services
   • Polish and validation: Unit tests, performance optimization, documentation

8. Progress tracking and error handling:

   • Report progress after each completed task.
   • Halt execution if any non-parallel task fails.
   • For parallel tasks [P], continue with successful tasks, report failed ones.
   • Provide clear error messages with context for debugging.
   • Suggest next steps if implementation cannot proceed.
   • IMPORTANT For completed tasks, mark as [X] only AFTER local verification and self-audit.
   • If blocked because the only apparent fix is listed in upstream @REJECTED, escalate for decision revision instead of silently overriding the guardrail.

9. Handoff to Tester (Audit Loop):

   • Once a task or phase is complete, the Coder hands off to the Tester.
   • Handoff includes: file paths, declared complexity, expected contracts (@PRE, @POST, @SIDE_EFFECT, @DATA_CONTRACT, @INVARIANT when applicable), and a short logic overview.
   • Handoff MUST explicitly disclose any contract exceptions or known semantic debt. Hidden semantic debt is forbidden.
   • Handoff MUST disclose decision-memory changes: inherited ADR ids, new or updated @RATIONALE, new or updated @REJECTED, and any blocked paths that remain active.
   • The handoff payload MUST instruct the Tester to execute the dedicated testing workflow .kilocode/workflows/speckit.test.md, not just perform an informal review.

10. Tester Verification & Orchestrator Gate:

• Tester MUST:
  • Explicitly run the .kilocode/workflows/speckit.test.md workflow as the verification procedure for the delivered implementation batch.
  • Perform mandatory semantic audit (using audit_contracts_tool).
  • Reject code that only imitates the protocol superficially, such as free-form docstrings with @PURPOSE text but without canonical [DEF]...[/DEF] anchors and header metadata.
  • Verify that effective complexity and required metadata match .ai/standards/semantics.md.
  • Verify that Python Complexity 4/5 implementations include required belief-state instrumentation (belief_scope, logger.reason(), logger.reflect()).
  • Verify that upstream rejected paths were not silently restored.
  • Emulate algorithms "in mind" step-by-step to ensure logic consistency.
  • Verify unit tests match the declared contracts.
• If Tester finds issues:
  • Emit [AUDIT_FAIL: semantic_noncompliance | contract_mismatch | logic_mismatch | test_mismatch | speckit_test_not_run | rejected_path_regression].
  • Provide concrete file-path-based reasons, for example: missing anchors, module/class contract mismatch, missing @DATA_CONTRACT, missing logger.reason(), illegal docstring-only annotations, missing decision-memory tags, re-enabled upstream rejected path, or missing execution of .kilocode/workflows/speckit.test.md.
  • Notify the Orchestrator.
  • Orchestrator redirects the feedback to the Coder for remediation.
• Orchestrator green-status rule:
  • The Orchestrator MUST NOT assign green/accepted status unless the Tester confirms that .kilocode/workflows/speckit.test.md was executed.
  • Missing execution evidence for .kilocode/workflows/speckit.test.md is an automatic gate failure even if the Tester verbally reports that the code "looks fine".
• Acceptance (Final mark [X]):
  • Only after the Tester is satisfied with semantics, emulation, and tests.
  • Any semantic audit warning relevant to touched files blocks acceptance until remediated or explicitly waived by the user.
  • No final green status is allowed without explicit confirmation that .kilocode/workflows/speckit.test.md was run.

11. Completion validation:
    • Verify all required tasks are completed and accepted by the Tester.
    • Check that implemented features match the original specification.
    • Confirm the implementation follows the technical plan and GRACE standards.
    • Confirm touched files do not contain protocol-invalid patterns such as:
      • class/function-level docstring contracts standing in for canonical anchors,
      • missing closing anchors,
      • missing required metadata for declared complexity,
      • Complexity 5 repository/service code using only belief_scope(...) without explicit logger.reason() / logger.reflect() checkpoints,
      • retained workarounds missing local @RATIONALE / @REJECTED,
      • silent resurrection of paths already blocked by upstream ADR or task guardrails.
    • Report final status with summary of completed and audited work.

Note: This command assumes a complete task breakdown exists in tasks.md. If tasks are incomplete or missing, suggest running /speckit.tasks first to regenerate the task list.