syntaur 0.1.13 → 0.2.0

package/platforms/claude-code/commands/track-session/track-session.md

@@ -3,20 +3,20 @@ name: track-session
 description: Register this Claude Code session as an agent session in the Syntaur dashboard
 arguments:
   - name: args
-    description: "Optional flags: --description, --mission, --assignment"
+    description: "Optional flags: --description, --project, --assignment"
     required: false
 ---
 
 # /track-session
 
-Register the current Claude Code session as an agent session in the Syntaur dashboard. Works standalone or linked to a mission/assignment.
+Register the current Claude Code session as an agent session in the Syntaur dashboard. Works standalone or linked to a project/assignment.
 
 ## Usage
 
 - `/track-session` — register a standalone session
 - `/track-session --description "exploring auth patterns"` — with a description
-- `/track-session --mission <slug> --assignment <slug>` — linked to a mission
-- `/track-session --description "auth work" --mission <slug> --assignment <slug>` — both
+- `/track-session --project <slug> --assignment <slug>` — linked to a project
+- `/track-session --description "auth work" --project <slug> --assignment <slug>` — both
 
 ## Instructions
 
@@ -26,7 +26,7 @@ When the user runs this command:
 
 Extract optional flags from the argument string:
 - `--description "<text>"` or `--description <text>` — session description
-- `--mission <slug>` — mission to link to
+- `--project <slug>` — project to link to
 - `--assignment <slug>` — assignment to link to
 
 ### Step 2: Run the CLI command
@@ -34,14 +34,14 @@ Extract optional flags from the argument string:
 Run the track-session CLI command via Bash (use `dangerouslyDisableSandbox: true` since it writes to `~/.syntaur/`):
 
 ```bash
-syntaur track-session --agent claude --path $(pwd) [--description "<text>"] [--mission <slug>] [--assignment <slug>]
+syntaur track-session --agent claude --path $(pwd) [--description "<text>"] [--project <slug>] [--assignment <slug>]
 ```
 
 ### Step 3: Parse the session ID
 
 The CLI output will be one of:
 - `Registered standalone agent session <sessionId>.`
-- `Registered agent session <sessionId> for <assignment> in <mission>.`
+- `Registered agent session <sessionId> for <assignment> in <project>.`
 
 Extract the session ID from the output.
 
@@ -62,4 +62,4 @@ Write the session ID to `.syntaur/context.json` so the SessionEnd hook can mark
 Tell the user:
 - The session was registered (include the short session ID)
 - It will be auto-stopped when this conversation ends
-- If linked to a mission, mention which mission/assignment
+- If linked to a project, mention which project/assignment

package/platforms/claude-code/hooks/enforce-boundaries.sh

@@ -64,7 +64,7 @@ fi
 
 # --- Step 8: Read context ---
 ASSIGNMENT_DIR=$(jq -r '.assignmentDir // empty' "$CONTEXT_FILE" 2>/dev/null)
-MISSION_DIR=$(jq -r '.missionDir // empty' "$CONTEXT_FILE" 2>/dev/null)
+MISSION_DIR=$(jq -r '.projectDir // empty' "$CONTEXT_FILE" 2>/dev/null)
 WORKSPACE_ROOT=$(jq -r '.workspaceRoot // empty' "$CONTEXT_FILE" 2>/dev/null)
 
 if [ -z "$ASSIGNMENT_DIR" ] || [ -z "$MISSION_DIR" ]; then
@@ -88,7 +88,7 @@ if [[ "$FILE_PATH" == "$ASSIGNMENT_DIR"/* ]]; then
   allow_and_exit
 fi
 
-# Allow: files in mission resources/ directory (but NOT derived _index.md)
+# Allow: files in project resources/ directory (but NOT derived _index.md)
 if [[ "$FILE_PATH" == "$MISSION_DIR/resources/"* ]]; then
   BASENAME=$(basename "$FILE_PATH")
   if [[ "$BASENAME" == _* ]]; then
@@ -99,7 +99,7 @@ if [[ "$FILE_PATH" == "$MISSION_DIR/resources/"* ]]; then
   fi
 fi
 
-# Allow: files in mission memories/ directory (but NOT derived _index.md)
+# Allow: files in project memories/ directory (but NOT derived _index.md)
 if [[ "$FILE_PATH" == "$MISSION_DIR/memories/"* ]]; then
   BASENAME=$(basename "$FILE_PATH")
   if [[ "$BASENAME" == _* ]]; then
@@ -122,7 +122,7 @@ if [ -n "$WORKSPACE_ROOT" ] && [[ "$FILE_PATH" == "$WORKSPACE_ROOT"/* ]]; then
 fi
 
 # --- Step 11: Block the write ---
-REASON="Syntaur write boundary violation: Cannot write to '$FILE_PATH'. Allowed paths: assignment dir ($ASSIGNMENT_DIR), mission resources/memories, workspace ($WORKSPACE_ROOT)."
+REASON="Syntaur write boundary violation: Cannot write to '$FILE_PATH'. Allowed paths: assignment dir ($ASSIGNMENT_DIR), project resources/memories, workspace ($WORKSPACE_ROOT)."
 
 # Escape for JSON
 REASON_ESCAPED=$(echo "$REASON" | jq -Rs '.' 2>/dev/null)

package/platforms/claude-code/hooks/hooks.json

@@ -7,7 +7,7 @@
         "hooks": [
           {
             "type": "prompt",
-            "prompt": "You just exited plan mode. If there is an active Syntaur assignment (check for a workspace field in assignment.md), update the assignment's plan.md with the plan you just created and update assignment.md to reflect that planning is complete."
+            "prompt": "You just exited plan mode. If there is an active Syntaur assignment (check for a workspace field in assignment.md), pick the next unused `plan-v<N>.md` filename (or `plan.md` if no plan*.md exists yet) under the assignment dir, write the plan you just created there, and append a `- [ ] Execute [plan](./plan.md)` (or versioned equivalent, e.g. `- [ ] Execute [plan v2](./plan-v2.md)`) entry to the `## Todos` section of assignment.md — marking any prior active plan todo as superseded (`- [x] ~~...~~ (superseded by plan-v<N>)`). Never delete superseded todos."
           }
         ]
       }

package/platforms/claude-code/hooks/session-cleanup.sh

@@ -31,14 +31,14 @@ fi
 
 # --- Step 4: Extract context info ---
 SESSION_ID=$(jq -r '.sessionId // empty' "$CONTEXT_FILE" 2>/dev/null)
-MISSION_SLUG=$(jq -r '.missionSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
+MISSION_SLUG=$(jq -r '.projectSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
 ASSIGNMENT_SLUG=$(jq -r '.assignmentSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
 
 PORT=$(cat "$HOME/.syntaur/dashboard-port" 2>/dev/null || echo "4800")
 
-# --- Step 5: If no session was registered, try to auto-register (requires mission+assignment) ---
+# --- Step 5: If no session was registered, try to auto-register (requires project+assignment) ---
 if [ -z "$SESSION_ID" ]; then
-  # Can only auto-register if we have mission and assignment context
+  # Can only auto-register if we have project and assignment context
   if [ -z "$MISSION_SLUG" ] || [ -z "$ASSIGNMENT_SLUG" ]; then
     exit 0
   fi
@@ -50,7 +50,7 @@ if [ -z "$SESSION_ID" ]; then
 
   RESPONSE=$(curl -sf -X POST "http://localhost:${PORT}/api/agent-sessions" \
     -H "Content-Type: application/json" \
-    -d "{\"missionSlug\": \"${MISSION_SLUG}\", \"assignmentSlug\": \"${ASSIGNMENT_SLUG}\", \"agent\": \"claude\", \"sessionId\": \"${SESSION_ID}\", \"path\": \"${CWD}\"}" \
+    -d "{\"projectSlug\": \"${MISSION_SLUG}\", \"assignmentSlug\": \"${ASSIGNMENT_SLUG}\", \"agent\": \"claude\", \"sessionId\": \"${SESSION_ID}\", \"path\": \"${CWD}\"}" \
     2>/dev/null) || true
 
   # If registration succeeded, update the context file with the session ID
@@ -63,7 +63,7 @@ fi
 # --- Step 6: Mark session as stopped via dashboard API ---
 BODY="{\"status\": \"stopped\"}"
 if [ -n "$MISSION_SLUG" ]; then
-  BODY="{\"status\": \"stopped\", \"missionSlug\": \"${MISSION_SLUG}\"}"
+  BODY="{\"status\": \"stopped\", \"projectSlug\": \"${MISSION_SLUG}\"}"
 fi
 
 curl -sf -X PATCH "http://localhost:${PORT}/api/agent-sessions/${SESSION_ID}/status" \

package/platforms/claude-code/references/file-ownership.md

@@ -6,9 +6,9 @@ Agents must NEVER modify these files:
 
 | File | Location |
 |------|----------|
-| `mission.md` | `<mission>/mission.md` |
-| `agent.md` | `<mission>/agent.md` |
-| `claude.md` | `<mission>/claude.md` |
+| `project.md` | `<project>/project.md` |
+| `agent.md` | `<project>/agent.md` |
+| `claude.md` | `<project>/claude.md` |
 
 ## Agent-Writable (YOUR assignment folder ONLY)
 
@@ -16,20 +16,20 @@ You may ONLY write to files inside your assigned assignment folder:
 
 | File | Purpose |
 |------|---------|
-| `assignment.md` | Assignment record, source of truth for state |
-| `plan.md` | Your implementation plan |
+| `assignment.md` | Assignment record, source of truth for state (includes `## Todos` checklist) |
+| `plan*.md` | Versioned implementation plans (optional, 0 or more: `plan.md`, `plan-v2.md`, ...) — each linked from a todo in `assignment.md` |
 | `scratchpad.md` | Working notes |
 | `handoff.md` | Append-only handoff log |
 | `decision-record.md` | Append-only decision log |
 
-Path pattern: `~/.syntaur/missions/<mission>/assignments/<your-assignment>/`
+Path pattern: `~/.syntaur/projects/<project>/assignments/<your-assignment>/`
 
 ## Shared-Writable (any agent or human)
 
 | Location | Purpose |
 |----------|---------|
-| `<mission>/resources/<slug>.md` | Reference material |
-| `<mission>/memories/<slug>.md` | Learnings and patterns |
+| `<project>/resources/<slug>.md` | Reference material |
+| `<project>/memories/<slug>.md` | Learnings and patterns |
 
 ## Derived (NEVER edit)
 

package/platforms/claude-code/references/protocol-summary.md

@@ -5,10 +5,10 @@
 ```
 ~/.syntaur/
   config.md
-  missions/
-    <mission-slug>/
+  projects/
+    <project-slug>/
       manifest.md            # Derived: root navigation (read-only)
-      mission.md             # Human-authored: mission overview (read-only)
+      project.md             # Human-authored: project overview (read-only)
       _index-assignments.md  # Derived (read-only)
       _index-plans.md        # Derived (read-only)
       _index-decisions.md    # Derived (read-only)
@@ -17,8 +17,8 @@
       agent.md               # Human-authored: universal agent instructions (read-only)
       assignments/
         <assignment-slug>/
-          assignment.md      # Agent-writable: source of truth for state
-          plan.md            # Agent-writable: implementation plan
+          assignment.md      # Agent-writable: source of truth for state (includes ## Todos checklist)
+          plan*.md           # Agent-writable: versioned implementation plans (optional, 0 or more: plan.md, plan-v2.md, ...)
           scratchpad.md      # Agent-writable: working notes
           handoff.md         # Agent-writable: append-only handoff log
           decision-record.md # Agent-writable: append-only decision log
@@ -62,9 +62,10 @@
 ## Key Rules
 
 1. **Assignment frontmatter is the single source of truth** for all assignment state.
-2. **One folder per mission**, one subfolder per assignment.
+2. **One folder per project**, one subfolder per assignment.
 3. **Derived files** (underscore-prefixed) are never edited manually.
 4. **Slugs** are lowercase, hyphen-separated.
 5. **Dependencies** are declared via `dependsOn` in assignment frontmatter.
 6. An assignment cannot transition from `pending` to `in_progress` while any dependency is not `completed`.
 7. **Playbooks** in `~/.syntaur/playbooks/` define behavioral rules agents must follow. Read `manifest.md` for a summary, then read each referenced playbook before starting work.
+8. **Todos** in the `## Todos` section of `assignment.md` are an informal markdown checklist. Items may be simple tasks or link to plan files. When a plan is superseded, mark the old todo: `- [x] ~~Execute [plan](./plan.md)~~ (superseded by plan-v2)` — never delete it.

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

@@ -17,15 +17,15 @@ Write a handoff for your current assignment and transition it to review (or comp
 
 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. If any criteria are unmet, always transition to `review` regardless of the `--complete` flag, and inform the user why.
+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 <mission-slug>` first."
+If the file does not exist, tell the user: "No active assignment found. Run `/grab-assignment <project-slug>` first."
 
-Extract: `missionSlug`, `assignmentSlug`, `assignmentDir`, `missionDir`.
+Extract: `projectSlug`, `assignmentSlug`, `assignmentDir`, `projectDir`.
 
 ## Step 1.5: Load Playbooks
 
@@ -37,15 +37,17 @@ 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
+## Step 2: Verify Acceptance Criteria and Todos
 
-Read `<assignmentDir>/assignment.md` and find the `## Acceptance Criteria` section.
+Read `<assignmentDir>/assignment.md` and find the `## Acceptance Criteria` and `## Todos` sections.
 
-Review each criterion (checkbox item). For each:
-- If you believe it is met, note why (what was implemented, where)
-- If it is NOT met, flag it clearly
+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
 
-If any criteria are not met, warn the user: "The following acceptance criteria are not yet met: [list]. Do you want to proceed with the handoff anyway?"
+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.
 
@@ -82,20 +84,22 @@ Use the Edit tool to append this entry to handoff.md (do not overwrite existing
 
 Also update the handoff.md frontmatter: set `updated` to the current timestamp and increment the `handoffCount` by 1.
 
-## Step 4: Update Acceptance Criteria Checkboxes
+## 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]`).
 
-In `<assignmentDir>/assignment.md`, update the acceptance criteria checkboxes to reflect the current state. Use the Edit tool to check off criteria that were met (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.
 
-**Note:** Ideally, criteria 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 `missionSlug`. Then mark the session as completed via the dashboard API:
+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", "missionSlug": "<mission-slug>"}'
+  -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.
@@ -105,20 +109,20 @@ If the API call fails (e.g., dashboard not running), this is non-critical — th
 If the user passed `--complete`:
 
 ```bash
-syntaur complete <assignment-slug> --mission <mission-slug>
+syntaur complete <assignment-slug> --project <project-slug>
 ```
 
 Otherwise, transition to review:
 
 ```bash
-syntaur review <assignment-slug> --mission <mission-slug>
+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)
-- Mission not found
+- Project not found
 
 ## Step 6: Clean Up Context
 

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

@@ -1,7 +1,7 @@
 ---
 name: create-assignment
-description: Create a new Syntaur assignment within a mission (or as a one-off)
-argument-hint: <title> --mission <slug> [--priority <level>] [--depends-on <slugs>] [--one-off]
+description: Create a new Syntaur assignment within a project (or as a one-off)
+argument-hint: <title> --project <slug> [--priority <level>] [--depends-on <slugs>] [--one-off]
 allowed-tools:
   - Bash
   - Read
@@ -9,7 +9,7 @@ allowed-tools:
 
 # Create Assignment
 
-Create a new assignment within a Syntaur mission from Claude Code.
+Create a new assignment within a Syntaur project from Claude Code.
 
 ## Arguments
 
@@ -17,25 +17,25 @@ The user provided: $ARGUMENTS
 
 Parse the arguments:
 - First argument (required): the assignment title (e.g., `"Add login endpoint"`)
-- `--mission <slug>` (required unless `--one-off`): the mission to add the assignment to
-- `--one-off` (optional): create a standalone mission+assignment in one step
+- `--project <slug>` (required unless `--one-off`): the project to add the assignment to
+- `--one-off` (optional): create a standalone project+assignment in one step
 - `--slug` (optional): override the auto-generated assignment slug
 - `--priority` (optional): `low`, `medium` (default), `high`, or `critical`
 - `--depends-on` (optional): comma-separated list of assignment slugs this depends on
-- `--dir` (optional): override the default mission directory
+- `--dir` (optional): override the default project directory
 
 If no title was provided, ask the user what the assignment should be called.
 
-If neither `--mission` nor `--one-off` was provided, check if there is an active assignment context in `.syntaur/context.json`. If so, default `--mission` to that context's `missionSlug` and confirm with the user: "Add this assignment to mission `<missionSlug>`?"
+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 mission flag, ask the user which mission to add it to, or whether it should be a one-off.
+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>" --mission <slug> [--slug <slug>] [--priority <level>] [--depends-on <slugs>] [--dir <path>]
+syntaur create-assignment "<title>" --project <slug> [--slug <slug>] [--priority <level>] [--depends-on <slugs>] [--dir <path>]
 ```
 
 Or for one-off:
@@ -44,21 +44,22 @@ Or for one-off:
 syntaur create-assignment "<title>" --one-off [--slug <slug>] [--priority <level>] [--dir <path>]
 ```
 
-If the command fails (e.g., mission not found, slug collision), report the error and suggest fixes.
+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/missions/<mission-slug>/assignments/<assignment-slug>/assignment.md
+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, and location
-- List the files created (assignment.md, plan.md, scratchpad.md, handoff.md, decision-record.md)
-- Suggest they edit `assignment.md` to fill in the objective, acceptance criteria, and context
+- List the files created (assignment.md, scratchpad.md, handoff.md, decision-record.md). Note that `plan.md` is NOT scaffolded — plan files are optional and created on demand by `/plan-assignment`.
+- 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
-- Suggest running `/grab-assignment <mission-slug> <assignment-slug>` to claim and start working on it
+- Suggest running `/grab-assignment <project-slug> <assignment-slug>` to claim and start working on it

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

@@ -1,7 +1,7 @@
 ---
 name: grab-assignment
-description: Discover and claim a pending Syntaur assignment from a mission
-argument-hint: <mission-slug> [assignment-slug]
+description: Load a Syntaur assignment into the current working context
+argument-hint: <project-slug> [assignment-slug]
 allowed-tools:
   - Bash
   - Read
@@ -12,86 +12,79 @@ allowed-tools:
 
 # Grab Assignment
 
-Claim a pending assignment from a Syntaur mission and set up your working context.
+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 mission slug (e.g., `build-auth-system`)
-- Second argument (optional): a specific assignment slug to grab. If omitted, you will list pending assignments and pick one.
+- 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, read it and warn the user: "You already have an active assignment: `<assignmentSlug>` in mission `<missionSlug>`. Grabbing a new assignment will replace this context. Proceed?"
+   - If it exists, 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.
 
-## Step 1: Discover the Mission
+## Step 1: Discover the Project
 
-Read the mission directory to understand what is available:
+Read the project directory to understand what is available:
 
 ```bash
-ls ~/.syntaur/missions/<mission-slug>/
+ls ~/.syntaur/projects/<project-slug>/
 ```
 
-Read the mission files, starting with the manifest (the protocol-defined entry point):
-- Read `~/.syntaur/missions/<mission-slug>/manifest.md` first (root navigation file per protocol spec)
-- Read `~/.syntaur/missions/<mission-slug>/mission.md` for goal and context
-- Read `~/.syntaur/missions/<mission-slug>/agent.md` for agent instructions
-- Read `~/.syntaur/missions/<mission-slug>/claude.md` if it exists for Claude-specific instructions
-
-Note the `workspace` field in `mission.md` frontmatter if present. This indicates which project/codebase grouping the mission belongs to. When writing context to `.syntaur/context.json` (Step 5), include `"workspace": "<value>"` if the mission has a workspace.
+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
 
-## Step 2: Find Pending Assignments
+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.
 
-List assignment directories and check their status:
-
-```bash
-ls ~/.syntaur/missions/<mission-slug>/assignments/
-```
+## Step 2: Find Assignments
 
-For each assignment directory, read the `assignment.md` frontmatter and look for `status: pending`. You can use grep:
+List assignment directories:
 
 ```bash
-grep -l "status: pending" ~/.syntaur/missions/<mission-slug>/assignments/*/assignment.md
+ls ~/.syntaur/projects/<project-slug>/assignments/
 ```
 
-If no pending assignments exist, tell the user and stop.
-
-If the user specified an assignment slug as the second argument, verify it exists and is pending. If it is not pending, report its current status and stop.
+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, present the list of pending assignments with their titles and priorities, and ask the user which one to grab. If there is only one pending assignment, grab it automatically.
+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
 
-Run the Syntaur CLI commands to assign and start the assignment. Use `dangerouslyDisableSandbox: true` for these bash commands since the CLI writes to `~/.syntaur/` which is outside the project sandbox.
+Read the assignment frontmatter first to learn its current `status`:
 
 ```bash
-syntaur assign <assignment-slug> --agent claude --mission <mission-slug>
+cat ~/.syntaur/projects/<project-slug>/assignments/<assignment-slug>/assignment.md
 ```
 
-Then:
+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 start <assignment-slug> --mission <mission-slug>
+syntaur assign <assignment-slug> --agent claude --project <project-slug>
 ```
 
-If either command fails, report the error and stop. Common failures:
-- Assignment has unmet dependencies (cannot start until dependencies are `completed`)
-- Assignment is not in `pending` status
-- Mission not found
-
-## Step 4: Read Assignment Context and Set Workspace
-
-After successfully starting the assignment, read the full assignment details:
+**Only if the current status is `pending`**, also run `syntaur start` to transition it to `in_progress`:
 
 ```bash
-cat ~/.syntaur/missions/<mission-slug>/assignments/<assignment-slug>/assignment.md
+syntaur start <assignment-slug> --project <project-slug>
 ```
 
-Extract from the frontmatter:
+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)
@@ -99,7 +92,15 @@ Extract from the frontmatter:
 - `dependsOn` -- list of dependency slugs
 - `priority` -- priority level
 
-Read the objective and acceptance criteria from the markdown body.
+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
 
@@ -124,10 +125,10 @@ Then write the JSON file with this structure:
 
 ```json
 {
-  "missionSlug": "<mission-slug>",
+  "projectSlug": "<project-slug>",
   "assignmentSlug": "<assignment-slug>",
-  "missionDir": "/Users/<username>/.syntaur/missions/<mission-slug>",
-  "assignmentDir": "/Users/<username>/.syntaur/missions/<mission-slug>/assignments/<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>",
@@ -141,7 +142,7 @@ Use absolute paths (expand `~` to the actual home directory). Note: `workspace.r
 
 ## Step 5.5: Register Agent Session
 
-After creating the context file, register this session in the mission's agent session log so it appears in the dashboard.
+After creating the context file, register this session in the project's agent session log so it appears in the dashboard.
 
 1. Find the current Claude Code session ID by reading from `~/.claude/sessions/`. These are JSON files keyed by PID containing `sessionId`, `cwd`, etc. Find the most recently modified file whose `cwd` matches the current working directory:
 ```bash
@@ -153,7 +154,7 @@ If you cannot find a matching session file (e.g., no file matches the cwd, or th
 
 2. Run the track-session command (use `dangerouslyDisableSandbox: true` since it writes to `~/.syntaur/`):
 ```bash
-syntaur track-session --mission <missionSlug> --assignment <assignmentSlug> --agent claude --session-id <claude-session-id> --path $(pwd)
+syntaur track-session --project <projectSlug> --assignment <assignmentSlug> --agent claude --session-id <claude-session-id> --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.
@@ -174,7 +175,13 @@ If no playbook files exist, skip this step.
 
 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 next step: "Run `/plan-assignment` to create an implementation plan."
+- 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