syntaur 0.3.3 → 0.4.0

package/platforms/claude-code/hooks/statusline.sh

@@ -1,110 +0,0 @@
-#!/usr/bin/env bash
-# Syntaur Claude Code statusLine.
-#
-# Renders a single line with:
-#   <branch> · <worktree-basename> · <assignment> · <sessionId-suffix>
-#
-# Reads JSON from stdin per Claude Code statusLine contract:
-#   { "session_id": "...", "cwd": "...", "workspace": { "current_dir": "..." }, ... }
-#
-# Empty segments are omitted. Never fails the terminal — always exits 0.
-
-set -o pipefail 2>/dev/null || true
-
-INPUT=$(cat)
-
-# Degrade cleanly if jq is unavailable.
-if ! command -v jq >/dev/null 2>&1; then
-  printf '%s' '(syntaur: jq missing)'
-  exit 0
-fi
-
-SESSION_ID=""
-CWD=""
-
-if [ -n "$INPUT" ]; then
-  SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null)
-  CWD=$(printf '%s' "$INPUT" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
-fi
-
-# Fall back to the shell's CWD if the payload omits it.
-[ -z "$CWD" ] && CWD="$PWD"
-
-# --- Segment 1: branch ---
-BRANCH=""
-if [ -n "$CWD" ] && [ -d "$CWD" ]; then
-  BRANCH=$(git -C "$CWD" rev-parse --abbrev-ref HEAD 2>/dev/null)
-  if [ "$BRANCH" = "HEAD" ] || [ -z "$BRANCH" ]; then
-    SHORT=$(git -C "$CWD" rev-parse --short HEAD 2>/dev/null)
-    if [ -n "$SHORT" ]; then
-      BRANCH="detached@$SHORT"
-    else
-      BRANCH=""
-    fi
-  fi
-fi
-
-# --- Segment 2: worktree basename ---
-WORKTREE=""
-if [ -n "$CWD" ] && [ -d "$CWD" ]; then
-  WT_PATH=$(git -C "$CWD" rev-parse --show-toplevel 2>/dev/null)
-  if [ -n "$WT_PATH" ]; then
-    WORKTREE=$(basename "$WT_PATH")
-  fi
-fi
-
-# --- Segment 3: active syntaur assignment ---
-ASSIGNMENT=""
-CONTEXT_FILE="$CWD/.syntaur/context.json"
-if [ -f "$CONTEXT_FILE" ]; then
-  PROJECT_SLUG=$(jq -r '.projectSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
-  ASSIGNMENT_SLUG=$(jq -r '.assignmentSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
-  ASSIGNMENT_DIR=$(jq -r '.assignmentDir // empty' "$CONTEXT_FILE" 2>/dev/null)
-
-  TITLE=""
-  if [ -n "$ASSIGNMENT_DIR" ] && [ -f "$ASSIGNMENT_DIR/assignment.md" ]; then
-    TITLE=$(awk '/^title:/{sub(/^title:[[:space:]]*"?/,""); sub(/"?[[:space:]]*$/,""); print; exit}' "$ASSIGNMENT_DIR/assignment.md" 2>/dev/null)
-  fi
-
-  LABEL=""
-  if [ -n "$PROJECT_SLUG" ] && [ -n "$ASSIGNMENT_SLUG" ]; then
-    LABEL="$PROJECT_SLUG/$ASSIGNMENT_SLUG"
-  elif [ -n "$ASSIGNMENT_SLUG" ]; then
-    # Standalone assignment — assignmentSlug is the UUID folder name. Take the
-    # first 8 chars for terseness.
-    UUID_PREFIX="${ASSIGNMENT_SLUG:0:8}"
-    LABEL="standalone/$UUID_PREFIX"
-  fi
-
-  if [ -n "$LABEL" ] && [ -n "$TITLE" ]; then
-    ASSIGNMENT="$LABEL — $TITLE"
-  elif [ -n "$LABEL" ]; then
-    ASSIGNMENT="$LABEL"
-  fi
-fi
-
-# --- Segment 4: session id suffix ---
-SESSION_SUFFIX=""
-if [ -n "$SESSION_ID" ]; then
-  LEN=${#SESSION_ID}
-  if [ "$LEN" -gt 8 ]; then
-    SESSION_SUFFIX="…${SESSION_ID: -8}"
-  else
-    SESSION_SUFFIX="$SESSION_ID"
-  fi
-fi
-
-# --- Join segments with ' · ', suppressing empties. ---
-OUT=""
-for seg in "$BRANCH" "$WORKTREE" "$ASSIGNMENT" "$SESSION_SUFFIX"; do
-  if [ -n "$seg" ]; then
-    if [ -z "$OUT" ]; then
-      OUT="$seg"
-    else
-      OUT="$OUT · $seg"
-    fi
-  fi
-done
-
-printf '%s' "$OUT"
-exit 0

package/platforms/claude-code/skills/complete-assignment/SKILL.md

@@ -1,155 +0,0 @@
----
-name: complete-assignment
-description: Write a handoff and transition the current Syntaur assignment to review or completed
-argument-hint: "[--complete]"
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
----
-
-# Complete Assignment
-
-Write a handoff for your current assignment and transition it to review (or completed).
-
-## Arguments
-
-User provided: $ARGUMENTS
-
-If the user passed `--complete`, transition directly to `completed` instead of `review`. However, `--complete` is ONLY allowed if ALL acceptance criteria are met AND every `## Todos` item is either checked or marked superseded. If any criterion or todo is unresolved, always transition to `review` regardless of the `--complete` flag, and inform the user why.
-
-## Step 1: Load Context
-
-Read `.syntaur/context.json` from the current working directory.
-
-If the file does not exist, tell the user: "No active assignment found. Run `/grab-assignment <project-slug>` first."
-
-Extract: `projectSlug`, `assignmentSlug`, `assignmentDir`, `projectDir`.
-
-## Step 1.5: Load Playbooks
-
-Read all playbook files from `~/.syntaur/playbooks/` — verify your work complies with their rules:
-
-```bash
-ls ~/.syntaur/playbooks/*.md 2>/dev/null
-```
-
-For each file found, read it and check that your work follows its directives. If any playbook has completion-related rules (e.g., "run tests before done"), follow them before proceeding.
-
-## Step 2: Verify Acceptance Criteria and Todos
-
-Read `<assignmentDir>/assignment.md` and find the `## Acceptance Criteria` and `## Todos` sections.
-
-Review each acceptance criterion (checkbox item) and each todo. For each:
-- If you believe it is met/done, note why (what was implemented, where)
-- If it is NOT met/done, flag it clearly
-
-Superseded todos (marked `- [x] ~~...~~ (superseded by ...)`) count as resolved — they do not need to be done again.
-
-If any acceptance criteria are unmet OR any todo is still `- [ ]` and not superseded, warn the user: "The following are not yet done: [list]. Do you want to proceed with the handoff anyway?"
-
-If the user says no, stop.
-
-## Step 2.5: Append a Final Progress Entry
-
-Before writing the handoff, append a final entry to `<assignmentDir>/progress.md` summarizing what was completed. The entry goes at the **top** of the body (reverse-chron order) under a new `## <RFC 3339 timestamp>` heading:
-
-```markdown
-## <ISO 8601 timestamp>
-
-<One paragraph summarizing the final state of work: what was implemented, what verifications passed, and any deliberate scope exclusions.>
-```
-
-Update `progress.md`'s frontmatter: bump `entryCount` and set `updated` to the current timestamp.
-
-Do NOT add a `## Progress` section to `assignment.md` — progress entries live exclusively in `progress.md` as of protocol v2.0.
-
-## Step 3: Write Handoff Entry
-
-Read `<assignmentDir>/handoff.md` to see its current content and frontmatter.
-
-Append a new handoff entry to the markdown body. Read the current `handoffCount` from the frontmatter and use `handoffCount + 1` as the entry number. The entry MUST follow the protocol-specified format from `docs/protocol/file-formats.md`:
-
-```markdown
----
-## Handoff <N>: <ISO 8601 timestamp>
-
-**From:** claude
-**To:** human
-**Reason:** <Why this handoff is happening, e.g., "Assignment complete, handing off for review.">
-
-### Summary
-<One paragraph summarizing what was accomplished and what remains>
-
-### Current State
-- <What is working>
-- <What is not working or partially done>
-- <Acceptance criteria status: N of M met>
-
-### Next Steps
-- <Recommended next actions for the reviewer or next agent>
-
-### Important Context
-- <Anything the next agent/human needs that is not in the assignment or plan>
-```
-
-Use the Edit tool to append this entry to handoff.md (do not overwrite existing content).
-
-Also update the handoff.md frontmatter: set `updated` to the current timestamp and increment the `handoffCount` by 1.
-
-## Step 4: Update Checkboxes (Criteria + Todos)
-
-In `<assignmentDir>/assignment.md`, update checkboxes in both the `## Acceptance Criteria` and `## Todos` sections to reflect the current state. Use the Edit tool to check off items that were completed (change `- [ ]` to `- [x]`).
-
-**Note:** Ideally, these should have been checked off incrementally during implementation. If they are already checked, verify they are still accurate. If some were missed, check them off now with a note in the handoff about which were verified at completion time vs. during development.
-
-Do NOT uncheck or rewrite superseded todo lines (those matching `- [x] ~~...~~ (superseded by ...)`) — leave that history intact.
-
-## Step 4.5: Close Session
-
-Read the context file (`.syntaur/context.json`) to get the `sessionId` and `projectSlug`. Then mark the session as completed via the dashboard API:
-
-```bash
-curl -s -X PATCH "http://localhost:$(cat ~/.syntaur/dashboard-port 2>/dev/null || echo 4800)/api/agent-sessions/<session-id>/status" \
-  -H "Content-Type: application/json" \
-  -d '{"status": "completed", "projectSlug": "<project-slug>"}'
-```
-
-If the API call fails (e.g., dashboard not running), this is non-critical — the session will be reconciled automatically on the next dashboard load.
-
-## Step 5: Transition Assignment State
-
-If the user passed `--complete`:
-
-```bash
-syntaur complete <assignment-slug> --project <project-slug>
-```
-
-Otherwise, transition to review:
-
-```bash
-syntaur review <assignment-slug> --project <project-slug>
-```
-
-Use `dangerouslyDisableSandbox: true` since the CLI writes to `~/.syntaur/`.
-
-If the command fails, report the error. Common failures:
-- Assignment is not in `in_progress` status (cannot transition)
-- Project not found
-
-## Step 6: Clean Up Context
-
-Delete the context file:
-
-```bash
-rm .syntaur/context.json
-```
-
-## Step 7: Report to User
-
-Summarize:
-- Assignment slug and title
-- New status (review or completed)
-- Number of acceptance criteria met vs total
-- Remind: if transitioned to `review`, a human reviewer will check the work. If any criteria were unmet, they may send it back to `in_progress` via `syntaur start`.

package/platforms/claude-code/skills/create-assignment/SKILL.md

@@ -1,67 +0,0 @@
----
-name: create-assignment
-description: Create a new Syntaur assignment within a project (or as a one-off)
-argument-hint: <title> --project <slug> [--priority <level>] [--depends-on <slugs>] [--type <type>] [--one-off]
-allowed-tools:
-  - Bash
-  - Read
----
-
-# Create Assignment
-
-Create a new assignment within a Syntaur project from Claude Code.
-
-## Arguments
-
-The user provided: $ARGUMENTS
-
-Parse the arguments:
-- First argument (required): the assignment title (e.g., `"Add login endpoint"`)
-- `--project <slug>` (required unless `--one-off`): the project to add the assignment to
-- `--one-off` (optional): create a **standalone** assignment at `~/.syntaur/assignments/<uuid>/` with `project: null`. Folder is named by UUID; `slug` is display-only. `--depends-on` is not permitted for standalone assignments.
-- `--slug` (optional): override the auto-generated assignment slug
-- `--priority` (optional): `low`, `medium` (default), `high`, or `critical`
-- `--type` (optional): classification such as `feature`, `bug`, `refactor`, `research`, `chore`. Defaults to `feature`. When `~/.syntaur/config.md` defines `types.definitions`, the CLI validates against that list.
-- `--depends-on` (optional, project-nested only): comma-separated list of assignment slugs this depends on
-- `--dir` (optional): override the default project directory
-
-If no title was provided, ask the user what the assignment should be called.
-
-If neither `--project` nor `--one-off` was provided, check if there is an active assignment context in `.syntaur/context.json`. If so, default `--project` to that context's `projectSlug` and confirm with the user: "Add this assignment to project `<projectSlug>`?"
-
-If there is no active context and no project flag, ask the user which project to add it to, or whether it should be a one-off.
-
-## Step 1: Run the CLI
-
-Build the command from the parsed arguments. Use `dangerouslyDisableSandbox: true` since the CLI writes to `~/.syntaur/` which is outside the project sandbox.
-
-```bash
-syntaur create-assignment "<title>" --project <slug> [--slug <slug>] [--priority <level>] [--depends-on <slugs>] [--type <type>] [--dir <path>]
-```
-
-Or for one-off (standalone at `~/.syntaur/assignments/<uuid>/`):
-
-```bash
-syntaur create-assignment "<title>" --one-off [--slug <slug>] [--priority <level>] [--type <type>] [--dir <path>]
-```
-
-If the command fails (e.g., project not found, slug collision), report the error and suggest fixes.
-
-## Step 2: Read the Created Assignment
-
-After successful creation, extract the assignment slug and directory from the CLI output. Read the generated `assignment.md`:
-
-```bash
-cat ~/.syntaur/projects/<project-slug>/assignments/<assignment-slug>/assignment.md
-```
-
-## Step 3: Guide Next Steps
-
-Tell the user:
-- The assignment was created with its slug, priority, type, and location. For standalone assignments, the location is `~/.syntaur/assignments/<uuid>/` — note the UUID (not slug) is the folder name.
-- List the files created: `assignment.md`, `progress.md`, `comments.md`, `scratchpad.md`, `handoff.md`, `decision-record.md`. `plan.md` is NOT scaffolded — plan files are optional and created on demand by `/plan-assignment`.
-- Remind the user: `progress.md` is where timestamped progress entries go (not `assignment.md`), and `comments.md` is written only via `syntaur comment <slug-or-uuid> "body" --type question|note|feedback`.
-- Suggest they edit `assignment.md` to fill in the objective, acceptance criteria, context, and any initial todos. The `## Todos` section accepts simple tasks or markdown links to plan files.
-- Or suggest running `/plan-assignment` after grabbing — it creates a plan file and auto-appends a linked todo to `## Todos`.
-- If dependencies were set, note them. (Standalone assignments cannot declare dependencies.)
-- Suggest running `/grab-assignment <project-slug> <assignment-slug>` (or `/grab-assignment --id <uuid>` for standalone) to claim and start working on it.

package/platforms/claude-code/skills/grab-assignment/SKILL.md

@@ -1,202 +0,0 @@
----
-name: grab-assignment
-description: Load a Syntaur assignment into the current working context
-argument-hint: <project-slug> [assignment-slug]
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Glob
-  - Grep
----
-
-# Grab Assignment
-
-Load a Syntaur assignment into the current working context so you can work on it.
-
-**Grabbing is non-destructive.** It never fails because of status. An assignment in `pending`, `in_progress`, `blocked`, `review`, `completed`, or `failed` can all be grabbed — grabbing just sets up context (`.syntaur/context.json`), registers the session, and reads the assignment. Only a `pending` assignment will additionally be transitioned to `in_progress`; any other status is left untouched.
-
-## Arguments
-
-The user provided: $ARGUMENTS
-
-Parse the arguments:
-- First argument (required): the project slug (e.g., `build-auth-system`)
-- Second argument (optional): a specific assignment slug to grab. If omitted, you will list the project's assignments and pick one (preferring `pending` when multiple exist).
-
-## Pre-flight Check
-
-1. Check if `.syntaur/context.json` already exists in the current working directory.
-   - If it exists AND contains BOTH `projectSlug` and `assignmentSlug`, read it and warn the user: "You already have an active assignment: `<assignmentSlug>` in project `<projectSlug>`. Grabbing a new assignment will replace this context. Proceed?"
-   - If the user says no, stop.
-   - If the file exists but only has session fields (`sessionId`, `transcriptPath`) and no project/assignment, do NOT warn — that context was populated by the SessionStart hook and is not an "active assignment" marker. Proceed silently and merge new assignment fields in Step 5.
-
-## Step 1: Discover the Project
-
-Read the project directory to understand what is available:
-
-```bash
-ls ~/.syntaur/projects/<project-slug>/
-```
-
-Read the project files, starting with the manifest (the protocol-defined entry point):
-- Read `~/.syntaur/projects/<project-slug>/manifest.md` first (root navigation file per protocol spec)
-- Read `~/.syntaur/projects/<project-slug>/project.md` for goal and context
-- Read `~/.syntaur/projects/<project-slug>/agent.md` for agent instructions
-- Read `~/.syntaur/projects/<project-slug>/claude.md` if it exists for Claude-specific instructions
-
-Note the `workspace` field in `project.md` frontmatter if present. This indicates which project/codebase grouping the project belongs to. When writing context to `.syntaur/context.json` (Step 5), include `"workspace": "<value>"` if the project has a workspace.
-
-## Step 2: Find Assignments
-
-List assignment directories:
-
-```bash
-ls ~/.syntaur/projects/<project-slug>/assignments/
-```
-
-If the user specified an assignment slug as the second argument, verify that directory exists. Its status does **not** matter — grab it regardless. If it doesn't exist, report that and stop.
-
-If no specific assignment was requested, read each `assignment.md` frontmatter and present the list with title, priority, and current status. Prefer `pending` assignments when presenting options (they're the most likely default), but show non-terminal assignments too so the user can pick one to resume. Ask the user which to grab unless there is exactly one obvious candidate (single `pending` assignment).
-
-## Step 3: Claim the Assignment
-
-Read the assignment frontmatter first to learn its current `status`:
-
-```bash
-cat ~/.syntaur/projects/<project-slug>/assignments/<assignment-slug>/assignment.md
-```
-
-Then run the Syntaur CLI to set the assignee. This is safe at any status and does not transition state. Use `dangerouslyDisableSandbox: true` for these bash commands since the CLI writes to `~/.syntaur/` which is outside the project sandbox.
-
-```bash
-syntaur assign <assignment-slug> --agent claude --project <project-slug>
-```
-
-**Only if the current status is `pending`**, also run `syntaur start` to transition it to `in_progress`:
-
-```bash
-syntaur start <assignment-slug> --project <project-slug>
-```
-
-For any other status (`in_progress`, `blocked`, `review`, `completed`, `failed`), **skip `syntaur start`** — the assignment has already been advanced past pending and grabbing should not rewind it. Tell the user which status the assignment is in and continue with context setup.
-
-If `syntaur assign` fails (e.g., project not found, invalid slug), report the error and stop. Do not treat a non-pending status as a failure.
-
-## Step 4: Read Assignment Context and Set Workspace
-
-You have already read the assignment file in Step 3. Extract from the frontmatter:
-- `title` -- the assignment title
-- `workspace.repository` -- the code repository path (may be null)
-- `workspace.worktreePath` -- the worktree path (may be null)
-- `workspace.branch` -- the branch name (may be null)
-- `dependsOn` -- list of dependency slugs
-- `priority` -- priority level
-
-Read the objective, acceptance criteria, and the `## Todos` section (if present) from the markdown body. Active (unchecked) todos indicate outstanding work and may link to plan files to execute.
-
-### Auto-load upstream decision records
-
-If `dependsOn` is non-empty, for each dependency slug `<dep>`, read:
-- `<projectDir>/assignments/<dep>/handoff.md` (if it exists) for integration context
-- `<projectDir>/assignments/<dep>/decision-record.md` (if it exists) for upstream decisions
-
-Surface those upstream decisions in the Step 6 report — downstream work should inherit prior decisions without the user having to ask.
-
-### Set workspace if not configured
-
-If `workspace.repository` and `workspace.worktreePath` are both null, set them to the current working directory (`$(pwd)`). This is critical because the write boundary hook uses the workspace path to determine which files the agent is allowed to edit. Without it, all code edits outside the assignment directory will be blocked.
-
-Use the Edit tool to update the assignment.md frontmatter:
-```yaml
-workspace:
-  repository: /absolute/path/to/cwd
-  worktreePath: /absolute/path/to/cwd
-```
-
-## Step 5: Create or Merge Context File
-
-Merge assignment context into `.syntaur/context.json`. Do NOT overwrite: if the file already exists (e.g., the SessionStart hook populated `sessionId` + `transcriptPath`), preserve those fields.
-
-First ensure the directory exists:
-
-```bash
-mkdir -p .syntaur
-```
-
-Prepare the assignment payload:
-
-```json
-{
-  "projectSlug": "<project-slug>",
-  "assignmentSlug": "<assignment-slug>",
-  "projectDir": "/Users/<username>/.syntaur/projects/<project-slug>",
-  "assignmentDir": "/Users/<username>/.syntaur/projects/<project-slug>/assignments/<assignment-slug>",
-  "workspaceRoot": "<workspace.worktreePath if set, else workspace.repository if it is a local path, else current working directory>",
-  "title": "<assignment title>",
-  "branch": "<workspace.branch or null>",
-  "grabbedAt": "<ISO 8601 timestamp>"
-}
-```
-
-Merge it on top of whatever context.json already contains:
-
-```bash
-if [ -f .syntaur/context.json ]; then
-  jq --slurpfile new <(echo "$NEW_CONTEXT_JSON") '. + $new[0]' .syntaur/context.json > .syntaur/context.json.tmp \
-    && mv .syntaur/context.json.tmp .syntaur/context.json
-else
-  echo "$NEW_CONTEXT_JSON" > .syntaur/context.json
-fi
-```
-
-This preserves any `sessionId` / `transcriptPath` the SessionStart hook wrote, while layering assignment fields on top.
-
-Use absolute paths (expand `~` to the actual home directory). Note: `workspace.repository` may be a remote URL (e.g., `https://github.com/...`) -- only use it as `workspaceRoot` if it starts with `/` (local path). If it is a URL, set `workspaceRoot` to the current working directory.
-
-**IMPORTANT:** The `workspaceRoot` must NEVER be null when the agent will be writing code. If no workspace was configured, default to the current working directory.
-
-## Step 5.5: Register Agent Session
-
-After merging context, register this session in the dashboard.
-
-1. **Source the real Claude session_id + transcript_path.** In priority order:
-   1. If `.syntaur/context.json` already has `sessionId` (SessionStart hook populated it), use that ID and read `transcriptPath` from the same file.
-   2. Otherwise, fall back to `~/.claude/sessions/*.json`: `ls -t ~/.claude/sessions/*.json | head -5`, read each, and pick the most recently modified entry whose `cwd` matches `$(pwd)`. Extract `sessionId`. The transcript path for Claude Code lives at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` — construct that path if you need it.
-   3. If neither source yields a real ID, DO NOT synthesize one. Abort with: "Could not resolve a real Claude Code session id. Restart the Claude session so the SessionStart hook can populate `.syntaur/context.json`, or run `/rename <assignment-slug>` and retry."
-
-2. **Merge `sessionId` and `transcriptPath` back into context.json** (safe even if already present — jq merge is idempotent).
-
-3. **Run the track-session CLI** (use `dangerouslyDisableSandbox: true` since it writes to `~/.syntaur/`). Both `--session-id` and real path are required:
-   ```bash
-   syntaur track-session --project <projectSlug> --assignment <assignmentSlug> --agent claude --session-id <real-session-id> --transcript-path <transcript-path> --path $(pwd)
-   ```
-
-3. Update the `.syntaur/context.json` context file to include the session ID. Add `"sessionId": "<claude-session-id>"` to the JSON object you wrote in Step 5.
-
-## Step 5.6: Load Playbooks
-
-Read all playbook files from `~/.syntaur/playbooks/` and treat their content as active behavioral rules for this assignment:
-
-```bash
-ls ~/.syntaur/playbooks/*.md 2>/dev/null
-```
-
-For each `.md` file found, read it and internalize the rules in its body section. These are user-defined behavioral policies that you must follow throughout your work on this assignment. Playbooks take precedence over default conventions when they conflict.
-
-If no playbook files exist, skip this step.
-
-## Step 6: Report to User
-
-Summarize what was done:
-- Which assignment was grabbed
-- Its current status (note if it was already past `pending` — e.g., "already in `review`, status unchanged")
-- The objective (first paragraph from assignment.md body)
-- The acceptance criteria (the checkbox list)
-- Active todos from the `## Todos` section (if any), with links to any referenced plan files
-- The workspace path (if set)
-- Suggest an appropriate next step based on status:
-  - `pending` / `in_progress`: `/plan-assignment` to plan implementation
-  - `blocked`: investigate the blocker recorded in `blockedReason`
-  - `review`: inspect the implementation and help verify acceptance criteria
-  - `completed` / `failed`: read the handoff; grab is probably for reference or reopen