syntaur 0.1.0

package/plugin/hooks/session-cleanup.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# Syntaur SessionEnd Hook
+# Logs and marks agent sessions as "stopped" when a Claude Code session exits.
+# If the session was never registered but has an active assignment, registers it first.
+# Reads JSON from stdin, always exits 0.
+
+# --- Safety: never fail ---
+set -o pipefail 2>/dev/null || true
+
+# --- Step 1: Check for jq ---
+if ! command -v jq &>/dev/null; then
+  exit 0
+fi
+
+# --- Step 2: Read stdin ---
+INPUT=$(cat)
+if [ -z "$INPUT" ]; then
+  exit 0
+fi
+
+# --- Step 3: Find context file ---
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null)
+if [ -z "$CWD" ]; then
+  exit 0
+fi
+
+CONTEXT_FILE="$CWD/.syntaur/context.json"
+if [ ! -f "$CONTEXT_FILE" ]; then
+  exit 0
+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)
+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) ---
+if [ -z "$SESSION_ID" ]; then
+  # Can only auto-register if we have mission and assignment context
+  if [ -z "$MISSION_SLUG" ] || [ -z "$ASSIGNMENT_SLUG" ]; then
+    exit 0
+  fi
+
+  # Generate a session ID for the log entry
+  SESSION_ID=$(uuidgen 2>/dev/null || cat /proc/sys/kernel/random/uuid 2>/dev/null || echo "ses-$(date +%s)")
+  # Lowercase the UUID (uuidgen on macOS outputs uppercase)
+  SESSION_ID=$(echo "$SESSION_ID" | tr '[:upper:]' '[:lower:]')
+
+  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}\"}" \
+    2>/dev/null) || true
+
+  # If registration succeeded, update the context file with the session ID
+  if [ -n "$RESPONSE" ]; then
+    jq --arg sid "$SESSION_ID" '. + {sessionId: $sid}' "$CONTEXT_FILE" > "${CONTEXT_FILE}.tmp" 2>/dev/null \
+      && mv "${CONTEXT_FILE}.tmp" "$CONTEXT_FILE" 2>/dev/null || true
+  fi
+fi
+
+# --- Step 6: Mark session as stopped via dashboard API ---
+BODY="{\"status\": \"stopped\"}"
+if [ -n "$MISSION_SLUG" ]; then
+  BODY="{\"status\": \"stopped\", \"missionSlug\": \"${MISSION_SLUG}\"}"
+fi
+
+curl -sf -X PATCH "http://localhost:${PORT}/api/agent-sessions/${SESSION_ID}/status" \
+  -H "Content-Type: application/json" \
+  -d "$BODY" \
+  -o /dev/null 2>/dev/null || true
+
+exit 0

package/plugin/references/file-ownership.md

@@ -0,0 +1,51 @@
+# File Ownership Rules
+
+## Human-Authored (READ-ONLY for agents)
+
+Agents must NEVER modify these files:
+
+| File | Location |
+|------|----------|
+| `mission.md` | `<mission>/mission.md` |
+| `agent.md` | `<mission>/agent.md` |
+| `claude.md` | `<mission>/claude.md` |
+
+## Agent-Writable (YOUR assignment folder ONLY)
+
+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 |
+| `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>/`
+
+## Shared-Writable (any agent or human)
+
+| Location | Purpose |
+|----------|---------|
+| `<mission>/resources/<slug>.md` | Reference material |
+| `<mission>/memories/<slug>.md` | Learnings and patterns |
+
+## Derived (NEVER edit)
+
+All files prefixed with `_` are derived and rebuilt by tooling:
+- `manifest.md`
+- `_index-assignments.md`
+- `_index-plans.md`
+- `_index-decisions.md`
+- `_status.md`
+- `resources/_index.md`
+- `memories/_index.md`
+
+## Workspace Files
+
+When working on code (not protocol files), you may write to files within
+the workspace defined in your assignment frontmatter:
+- `workspace.worktreePath` or `workspace.repository` defines your project root
+- You may create and edit source code files within that workspace
+- The `.syntaur/context.json` context file in your working directory is also writable

package/plugin/references/protocol-summary.md

@@ -0,0 +1,70 @@
+# Syntaur Protocol Summary
+
+## Directory Structure
+
+```
+~/.syntaur/
+  config.md
+  missions/
+    <mission-slug>/
+      manifest.md            # Derived: root navigation (read-only)
+      mission.md             # Human-authored: mission overview (read-only)
+      _index-assignments.md  # Derived (read-only)
+      _index-plans.md        # Derived (read-only)
+      _index-decisions.md    # Derived (read-only)
+      _status.md             # Derived (read-only)
+      claude.md              # Human-authored: Claude-specific instructions (read-only)
+      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
+          scratchpad.md      # Agent-writable: working notes
+          handoff.md         # Agent-writable: append-only handoff log
+          decision-record.md # Agent-writable: append-only decision log
+      resources/
+        _index.md            # Derived (read-only)
+        <resource-slug>.md   # Shared-writable
+      memories/
+        _index.md            # Derived (read-only)
+        <memory-slug>.md     # Shared-writable
+  playbooks/
+    manifest.md              # Derived: playbook listing (read-only)
+    <slug>.md                # User-authored: behavioral rules for agents
+```
+
+## Assignment Lifecycle
+
+| Status | Meaning |
+|--------|---------|
+| `pending` | Not yet started |
+| `in_progress` | Actively being worked on |
+| `blocked` | Manually blocked (requires `blockedReason`) |
+| `review` | Work complete, awaiting review |
+| `completed` | Done |
+| `failed` | Could not be completed |
+
+## Valid State Transitions
+
+| From | Command | To |
+|------|---------|-----|
+| pending | start | in_progress |
+| pending | block | blocked |
+| in_progress | block | blocked |
+| in_progress | review | review |
+| in_progress | complete | completed |
+| in_progress | fail | failed |
+| blocked | unblock | in_progress |
+| review | start | in_progress |
+| review | complete | completed |
+| review | fail | failed |
+
+## Key Rules
+
+1. **Assignment frontmatter is the single source of truth** for all assignment state.
+2. **One folder per mission**, 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.

package/plugin/skills/complete-assignment/SKILL.md

@@ -0,0 +1,137 @@
+---
+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. If any criteria are unmet, 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."
+
+Extract: `missionSlug`, `assignmentSlug`, `assignmentDir`, `missionDir`.
+
+## 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
+
+Read `<assignmentDir>/assignment.md` and find the `## Acceptance Criteria` section.
+
+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
+
+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?"
+
+If the user says no, stop.
+
+## 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 Acceptance Criteria Checkboxes
+
+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, 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.
+
+## 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:
+
+```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>"}'
+```
+
+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> --mission <mission-slug>
+```
+
+Otherwise, transition to review:
+
+```bash
+syntaur review <assignment-slug> --mission <mission-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
+
+## 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/plugin/skills/create-assignment/SKILL.md

@@ -0,0 +1,64 @@
+---
+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]
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Create Assignment
+
+Create a new assignment within a Syntaur mission from Claude Code.
+
+## Arguments
+
+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
+- `--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
+
+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 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.
+
+## 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>]
+```
+
+Or for one-off:
+
+```bash
+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.
+
+## 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
+```
+
+## 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
+- If dependencies were set, note them
+- Suggest running `/grab-assignment <mission-slug> <assignment-slug>` to claim and start working on it

package/plugin/skills/create-mission/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: create-mission
+description: Create a new Syntaur mission with all scaffolding files (manifest, agent instructions, indexes)
+argument-hint: <title> [--slug <slug>] [--dir <path>] [--workspace <workspace>]
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Create Mission
+
+Create a new Syntaur mission from within Claude Code.
+
+## Arguments
+
+The user provided: $ARGUMENTS
+
+Parse the arguments:
+- First argument (required): the mission title (e.g., `"Build Auth System"`)
+- `--slug` (optional): override the auto-generated slug
+- `--dir` (optional): override the default mission directory
+- `--workspace` (optional): workspace grouping label (e.g., `syntaur`, `reeva`)
+
+If no title was provided, ask the user what the mission should be called.
+
+## 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-mission "<title>" [--slug <slug>] [--dir <path>] [--workspace <workspace>]
+```
+
+If the command fails (e.g., slug collision, empty title), report the error and suggest fixes.
+
+## Step 2: Read the Created Mission
+
+After successful creation, extract the mission slug and directory from the CLI output. Read the generated `mission.md` to confirm the structure:
+
+```bash
+cat ~/.syntaur/missions/<slug>/mission.md
+```
+
+## Step 3: Guide Next Steps
+
+Tell the user:
+- The mission was created with its slug and location
+- List the key files created (manifest.md, mission.md, agent.md, claude.md)
+- Suggest they edit `mission.md` to fill in the goal, scope, and context sections
+- Suggest they edit `agent.md` to set conventions and boundaries for agents
+- Suggest running `/create-assignment` to add assignments to this mission

package/plugin/skills/grab-assignment/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: grab-assignment
+description: Discover and claim a pending Syntaur assignment from a mission
+argument-hint: <mission-slug> [assignment-slug]
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Glob
+  - Grep
+---
+
+# Grab Assignment
+
+Claim a pending assignment from a Syntaur mission and set up your working context.
+
+## 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.
+
+## 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 the user says no, stop.
+
+## Step 1: Discover the Mission
+
+Read the mission directory to understand what is available:
+
+```bash
+ls ~/.syntaur/missions/<mission-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.
+
+## Step 2: Find Pending Assignments
+
+List assignment directories and check their status:
+
+```bash
+ls ~/.syntaur/missions/<mission-slug>/assignments/
+```
+
+For each assignment directory, read the `assignment.md` frontmatter and look for `status: pending`. You can use grep:
+
+```bash
+grep -l "status: pending" ~/.syntaur/missions/<mission-slug>/assignments/*/assignment.md
+```
+
+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 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.
+
+## 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.
+
+```bash
+syntaur assign <assignment-slug> --agent claude --mission <mission-slug>
+```
+
+Then:
+
+```bash
+syntaur start <assignment-slug> --mission <mission-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:
+
+```bash
+cat ~/.syntaur/missions/<mission-slug>/assignments/<assignment-slug>/assignment.md
+```
+
+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 and acceptance criteria from the markdown body.
+
+### 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 Context File
+
+Write `.syntaur/context.json` in the current working directory with the assignment context. First ensure the directory exists:
+
+```bash
+mkdir -p .syntaur
+```
+
+Then write the JSON file with this structure:
+
+```json
+{
+  "missionSlug": "<mission-slug>",
+  "assignmentSlug": "<assignment-slug>",
+  "missionDir": "/Users/<username>/.syntaur/missions/<mission-slug>",
+  "assignmentDir": "/Users/<username>/.syntaur/missions/<mission-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>"
+}
+```
+
+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 creating the context file, register this session in the mission'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
+ls -t ~/.claude/sessions/*.json | head -5
+```
+Read the most recent file(s) and find the one whose `cwd` matches `$(pwd)`. Extract the `sessionId` field — this is the real Claude Code session ID that can be used with `claude --resume <sessionId>` to resume this exact conversation.
+
+If you cannot find a matching session file (e.g., no file matches the cwd, or the sessions directory is empty), ask the user to run `/rename <assignment-slug>` to name the current session after the assignment. Then store the assignment slug as the session name in context.json (`"sessionName": "<assignment-slug>"`) instead of `sessionId`. The user can later resume with `claude --resume <assignment-slug>`.
+
+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)
+```
+
+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
+- The objective (first paragraph from assignment.md body)
+- The acceptance criteria (the checkbox list)
+- The workspace path (if set)
+- Suggest next step: "Run `/plan-assignment` to create an implementation plan."