/speckit-converge

name: "speckit-converge"
description: "Assess the current codebase against the feature's spec, plan, and tasks, then append any remaining unbuilt work as new tasks to tasks.md so implement can complete it."
compatibility: "Requires spec-kit project structure with .specify/ directory"
metadata:
  author: "github-spec-kit"
  source: "templates/commands/converge.md"
user-invocable: true
disable-model-invocation: false

User Input

$ARGUMENTS

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

Pre-Execution Checks

**Check for extension hooks (before convergence)**:

• Check if `.specify/extensions.yml` exists in the project root.
• If it exists, read it and look for entries under the `hooks.before_converge` key
• If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
• Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
• For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
• If the hook has no `condition` field, or it is null/empty, treat the hook as executable
• If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
• When constructing command invocations from hook command names, replace dots (`.`) with hyphens (`-`). For example, `speckit.git.commit` → `/speckit-git-commit`.
• For each executable hook, output the following based on its `optional` flag:
• **Optional hook** (`optional: true`):

    ## Extension Hooks

    **Optional Pre-Hook**: {extension}
    Command: `/{command}`
    Description: {description}

    Prompt: {prompt}
    To execute: `/{command}`

• **Mandatory hook** (`optional: false`):

    ## Extension Hooks

    **Automatic Pre-Hook**: {extension}
    Executing: `/{command}`
    EXECUTE_COMMAND: {command}

    Wait for the result of the hook command before proceeding to the Goal.

After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.

• If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently

Goal

Close the gap between what a feature's specification, plan, and tasks call for and what the codebase currently implements. Read `spec.md`, `plan.md`, and `tasks.md` as the **sole source of intent** (with the constitution as governing constraints), assess the current state of the code, determine which requirements, acceptance criteria, plan decisions, and existing tasks are unmet, incomplete, or only partially satisfied, and **append each piece of remaining work as a new, traceable task** at the bottom of `tasks.md` so that `/speckit-implement` can complete it. This command MUST run only after `/speckit-implement` has run on the current `tasks.md`, and after `/speckit-tasks` has produced a complete `tasks.md`.

This is **not** a diff tool and does **not** track changes. It assesses the present state of the code relative to the feature's artifacts — no git, no branch comparison, no history.

Operating Constraints

**APPEND-ONLY, NEVER REWRITE**: The command's **only** write is appending a new `## Phase N: Convergence` section to `tasks.md`. It MUST NOT:

• modify `spec.md` or `plan.md` in any way;
• rewrite, renumber, reorder, or delete any existing task (including tasks from a prior

Convergence phase);

• modify, create, or delete any application code — completing the appended tasks is the

job of `/speckit-implement`.

When the codebase already satisfies everything, the command MUST leave `tasks.md` **byte-for-byte unchanged** (no empty Convergence header) and report a clean result.

**Constitution Authority**: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable**. Code that violates a MUST principle is the highest-severity finding and produces a corresponding remediation task. If the constitution is an unfilled template, skip constitution checks gracefully rather than failing.

Execution Steps

1. Initialize Convergence Context

Run `.specify/scripts/bash/check-prerequisites.sh --json --require-spec --require-tasks --include-tasks` once from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS. Derive absolute paths:

• SPEC = FEATURE_DIR/spec.md
• PLAN = FEATURE_DIR/plan.md
• TASKS = FEATURE_DIR/tasks.md
• CONSTITUTION = `.specify/memory/constitution.md` (if present)

If `spec.md`, `plan.md`, or `tasks.md` is missing, STOP with a clear, actionable message naming the prerequisite command to run (`/speckit-specify` for a missing spec, `/speckit-plan` for a missing plan, `/speckit-tasks` for missing tasks). Do not produce partial output. 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. Load Artifacts (Progressive Disclosure)

Load only the minimal necessary context from each artifact:

**From spec.md:**

• Functional Requirements (FR-###)
• Success Criteria (SC-###) — include only items requiring buildable work; exclude

post-launch outcome metrics and business KPIs

• User Stories and their Acceptance Scenarios
• Edge Cases (if present)

**From plan.md:**

• Architecture/stack choices and technical decisions
• Data Model references
• Phases and named touch-points (files/components the plan says will be created or edited)
• Technical constraints

**From tasks.md:**

• Task IDs (to comput