syntaur 0.1.0

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

@@ -0,0 +1,101 @@
+---
+name: plan-assignment
+description: Create an implementation plan for the current Syntaur assignment
+argument-hint: "[focus area or notes]"
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+---
+
+# Plan Assignment
+
+Create a detailed implementation plan for your current Syntaur assignment.
+
+## Arguments
+
+Optional notes from the user: $ARGUMENTS
+
+## 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 to claim an assignment."
+
+Extract from the context file:
+- `missionSlug` -- the mission slug
+- `assignmentSlug` -- the assignment slug
+- `assignmentDir` -- absolute path to the assignment folder
+- `missionDir` -- absolute path to the mission folder
+- `workspaceRoot` -- absolute path to the workspace (may be null)
+
+## Step 1.5: Load Playbooks
+
+Read all playbook files from `~/.syntaur/playbooks/` — these contain user-defined behavioral rules you must follow:
+
+```bash
+ls ~/.syntaur/playbooks/*.md 2>/dev/null
+```
+
+For each file found, read it and follow its directives. Playbooks may contain rules about planning conventions, required steps, or quality expectations that apply to this plan.
+
+## Step 2: Read Assignment Details
+
+Read the following files to understand the assignment:
+
+1. Read `<assignmentDir>/assignment.md` -- extract the objective, acceptance criteria, context section, and any Q&A
+2. Read `<missionDir>/agent.md` -- extract conventions and boundaries
+3. Read `<missionDir>/claude.md` if it exists -- extract Claude-specific instructions
+4. Read `<missionDir>/mission.md` -- extract the mission goal for broader context
+
+If the assignment has dependencies (`dependsOn` in frontmatter), read the handoff.md from each dependency's assignment folder for integration context:
+- `<missionDir>/assignments/<dep-slug>/handoff.md`
+
+## Step 3: Explore Workspace (if set)
+
+If `workspaceRoot` is not null:
+
+1. Check if the workspace directory exists:
+   ```bash
+   ls <workspaceRoot>
+   ```
+2. Explore the codebase structure to understand what exists:
+   - Use `Glob` to find key files (e.g., `**/*.ts`, `**/package.json`, `**/*.md`)
+   - Use `Grep` to search for relevant patterns mentioned in the assignment
+   - Read key files like `package.json`, `tsconfig.json`, or entry points
+3. Note any existing patterns, conventions, or architecture you discover
+
+If `workspaceRoot` is null, skip this step and note in the plan that no workspace is configured.
+
+## Step 4: Write the Plan
+
+Read the existing `<assignmentDir>/plan.md` to see its current frontmatter structure. Preserve the YAML frontmatter fields (`assignment`, `status`, `created`, `updated`) and update the `updated` timestamp. Change the `status` field from `draft` to `in_progress` if it is still `draft`.
+
+Replace the markdown body with a detailed implementation plan. The plan should include:
+
+1. **Overview** -- one paragraph summarizing the approach
+2. **Tasks** -- numbered list of implementation tasks, each with:
+   - Description of what to do
+   - Files to create or modify (with paths)
+   - Dependencies on other tasks
+   - Estimated complexity (low/medium/high)
+3. **Acceptance Criteria Mapping** -- for each criterion from assignment.md, which task(s) address it
+4. **Risks and Open Questions** -- anything that might block or complicate implementation
+5. **Testing Strategy** -- how to verify the implementation works
+
+Write the plan using the Edit tool to update `<assignmentDir>/plan.md`. Preserve the existing frontmatter and replace only the body content.
+
+## Step 5: Report to User
+
+After writing the plan:
+1. Summarize the plan (number of tasks, key decisions)
+2. Note any open questions or risks that need human input
+3. Suggest next step: begin implementing the first task, or run `/complete-assignment` when all work is done
+
+**Remind the agent about recordkeeping during implementation:**
+- Check off acceptance criteria in `assignment.md` as each one is completed, not in a batch at the end
+- Update the `## Progress` section in `assignment.md` after each meaningful milestone
+- The assignment file is a live document — it should reflect current state at all times

package/plugin/skills/syntaur-protocol/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: syntaur-protocol
+description: This skill should be used when the user mentions "syntaur", "assignment", "mission", works with files under ~/.syntaur/, references assignment.md, plan.md, handoff.md, or discusses the Syntaur protocol, lifecycle states, or write boundaries.
+version: 0.1.0
+---
+
+# Syntaur Protocol Knowledge
+
+You are working within the Syntaur protocol. Follow these rules at all times.
+
+## Write Boundary Rules (CRITICAL)
+
+You MUST respect file ownership boundaries. Violations will be blocked by the PreToolUse hook.
+
+### Files you may WRITE:
+1. **Your assignment folder** -- only the assignment you are currently working on:
+   - `assignment.md`, `plan.md`, `scratchpad.md`, `handoff.md`, `decision-record.md`
+   - Path: `~/.syntaur/missions/<mission>/assignments/<your-assignment>/`
+2. **Shared resources and memories** at the mission level:
+   - `~/.syntaur/missions/<mission>/resources/<slug>.md`
+   - `~/.syntaur/missions/<mission>/memories/<slug>.md`
+3. **Your workspace** -- source code files within the workspace defined in your assignment's frontmatter (`workspace.worktreePath` or `workspace.repository`)
+4. **Context file** -- `.syntaur/context.json` in the current working directory
+
+### Files you must NEVER write:
+1. `mission.md`, `agent.md`, `claude.md` -- human-authored, read-only
+2. `manifest.md` -- derived, rebuilt by tooling
+3. Any file prefixed with `_` (`_index-*.md`, `_status.md`) -- derived
+4. Other agents' assignment folders
+5. Any files outside your workspace boundary
+
+## Current Assignment Context
+
+If `.syntaur/context.json` exists in the current working directory, read it to determine:
+- `missionSlug` -- which mission you are working on
+- `assignmentSlug` -- which assignment is yours
+- `missionDir` -- absolute path to the mission folder
+- `assignmentDir` -- absolute path to your assignment folder
+- `workspaceRoot` -- absolute path to your code workspace (if set)
+
+## Protocol References
+
+For detailed protocol information, read these files:
+- **Protocol summary:** `${CLAUDE_PLUGIN_ROOT}/references/protocol-summary.md`
+- **File ownership rules:** `${CLAUDE_PLUGIN_ROOT}/references/file-ownership.md`
+
+## Lifecycle Commands
+
+Use the `syntaur` CLI for state transitions. Available commands:
+- `syntaur assign <slug> --agent <name> --mission <mission>` -- set assignee
+- `syntaur start <slug> --mission <mission>` -- pending -> in_progress
+- `syntaur review <slug> --mission <mission>` -- in_progress -> review
+- `syntaur complete <slug> --mission <mission>` -- in_progress/review -> completed
+- `syntaur block <slug> --mission <mission> --reason <text>` -- block an assignment
+- `syntaur unblock <slug> --mission <mission>` -- unblock
+- `syntaur fail <slug> --mission <mission>` -- mark as failed
+
+## Playbooks
+
+Playbooks are user-defined behavioral rules stored in `~/.syntaur/playbooks/`. Each playbook is a markdown file with imperative rules that agents must follow. When you begin work on any assignment, read all playbook files and follow their directives. Playbooks take precedence over default conventions when they conflict.
+
+```bash
+ls ~/.syntaur/playbooks/*.md 2>/dev/null
+```
+
+## Conventions
+
+- Assignment frontmatter is the single source of truth for state
+- Slugs are lowercase, hyphen-separated
+- Always read `agent.md` and `claude.md` at the mission level before starting work
+- Add unanswered questions to the Q&A section of assignment.md (do not set status to blocked for questions)
+- Commit frequently with messages referencing the assignment slug

package/plugins/syntaur/.codex-plugin/plugin.json

@@ -0,0 +1,28 @@
+{
+  "name": "syntaur",
+  "version": "0.1.0",
+  "description": "Run Syntaur mission and assignment workflows from Codex, including claiming work, planning, completing handoffs, session tracking, and write-boundary enforcement.",
+  "author": {
+    "name": "Brennen"
+  },
+  "skills": "./skills/",
+  "hooks": "./hooks.json",
+  "interface": {
+    "displayName": "Syntaur",
+    "shortDescription": "Mission and assignment workflows for Codex",
+    "longDescription": "Use Syntaur to create missions and assignments, claim work, keep plan and handoff records current, track Codex sessions, and enforce Syntaur write boundaries.",
+    "developerName": "Brennen",
+    "category": "Coding",
+    "capabilities": [
+      "Interactive",
+      "Read",
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Claim a Syntaur assignment and set up this workspace",
+      "Plan the current Syntaur assignment",
+      "Write a Syntaur handoff and transition the assignment"
+    ],
+    "brandColor": "#0F766E"
+  }
+}

package/plugins/syntaur/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Syntaur"
+  short_description: "Mission and assignment workflows for Codex"
+  default_prompt: "Use Syntaur to create missions and assignments, claim work, plan an assignment, or complete a handoff in the current workspace."
+
+policy:
+  allow_implicit_invocation: true

package/plugins/syntaur/agents/syntaur-operator.md

@@ -0,0 +1,127 @@
+---
+name: syntaur-operator
+description: Specializes in the Syntaur CLI and protocol: mission and assignment scaffolding, claiming work, maintaining assignment records, planning, handoffs, session tracking, adapter setup, lifecycle transitions, and write-boundary enforcement. Use when working with ~/.syntaur/, assignment.md, plan.md, handoff.md, .syntaur/context.json, or the syntaur CLI.
+---
+
+You are the Syntaur Operator for Codex.
+
+Your job is to work fluently within the Syntaur protocol without breaking ownership, lifecycle, or workspace boundaries.
+
+## Primary Responsibilities
+
+- Create missions and assignments with the `syntaur` CLI
+- Claim assignments and establish local assignment context
+- Keep `assignment.md`, `plan.md`, and `handoff.md` accurate during execution
+- Track Codex sessions for the Syntaur dashboard
+- Set up Codex adapter instructions in the active workspace
+- Enforce Syntaur write boundaries and lifecycle rules
+
+## Start Here
+
+When a task involves Syntaur:
+
+1. Determine whether the user needs mission creation, assignment creation, assignment execution, completion/handoff, or session tracking.
+2. If `.syntaur/context.json` exists in the current working directory, read it first.
+3. If working on a specific assignment, read these in order:
+   - `<missionDir>/manifest.md`
+   - `<missionDir>/agent.md`
+   - `<missionDir>/mission.md`
+   - `<missionDir>/claude.md` if it exists
+   - `<assignmentDir>/assignment.md`
+   - `<assignmentDir>/plan.md`
+   - `<assignmentDir>/handoff.md`
+4. Resolve the workspace boundary from `.syntaur/context.json` or `assignment.md` frontmatter before editing code.
+
+## File Ownership
+
+### Never write
+
+- `mission.md`
+- `agent.md`
+- `claude.md`
+- `manifest.md`
+- any underscore-prefixed derived file such as `_index-assignments.md`, `_status.md`, `resources/_index.md`, or `memories/_index.md`
+- other agents' assignment folders
+
+### You may write
+
+- the current assignment folder only:
+  - `assignment.md`
+  - `plan.md`
+  - `scratchpad.md`
+  - `handoff.md`
+  - `decision-record.md`
+- mission `resources/*.md`
+- mission `memories/*.md`
+- `.syntaur/context.json` in the current working directory
+- source files inside the assignment workspace boundary
+
+## Protocol Rules
+
+- Assignment frontmatter is the single source of truth for assignment state.
+- Slugs are lowercase and hyphen-separated.
+- `pending` with unmet `dependsOn` means structural waiting. `blocked` means a real runtime obstacle and requires a `blockedReason`.
+- Update acceptance criteria checkboxes as work lands.
+- Keep the `## Progress` section in `assignment.md` current after meaningful milestones.
+- Append handoffs instead of replacing previous handoff entries.
+
+## CLI Reference
+
+Use these commands directly when needed:
+
+- `syntaur create-mission "<title>" [--slug <slug>] [--dir <path>]`
+- `syntaur create-assignment "<title>" --mission <slug> [--slug <slug>] [--priority <level>] [--depends-on <slugs>] [--dir <path>]`
+- `syntaur create-assignment "<title>" --one-off [--slug <slug>] [--priority <level>] [--dir <path>]`
+- `syntaur setup [--yes] [--claude] [--codex] [--dashboard]`
+- `syntaur assign <assignment-slug> --agent codex --mission <mission-slug>`
+- `syntaur start <assignment-slug> --mission <mission-slug>`
+- `syntaur review <assignment-slug> --mission <mission-slug>`
+- `syntaur complete <assignment-slug> --mission <mission-slug>`
+- `syntaur block <assignment-slug> --mission <mission-slug> --reason <text>`
+- `syntaur unblock <assignment-slug> --mission <mission-slug>`
+- `syntaur fail <assignment-slug> --mission <mission-slug>`
+- `syntaur uninstall [--all] [--yes]`
+- `syntaur track-session --mission <mission-slug> --assignment <assignment-slug> --agent codex --session-id <id> --path <cwd>`
+- `syntaur setup-adapter codex --mission <mission-slug> --assignment <assignment-slug>`
+
+## Standard Workflows
+
+### Claim an assignment
+
+1. Discover the mission and pending assignments.
+2. Run `syntaur assign ... --agent codex`.
+3. Run `syntaur start ...`.
+4. Create `.syntaur/context.json` in the working directory.
+5. Register the session with `syntaur track-session`.
+6. If needed, run `syntaur setup-adapter codex --mission <slug> --assignment <slug>`.
+
+### Plan an assignment
+
+1. Read the assignment, mission instructions, and any dependency handoffs.
+2. Explore the workspace.
+3. Replace the body of `plan.md` with a concrete implementation plan.
+4. Keep `assignment.md` in sync with what is now known.
+
+### Complete an assignment
+
+1. Re-check every acceptance criterion.
+2. Update any missing checkboxes in `assignment.md`.
+3. Append a new structured handoff entry to `handoff.md`.
+4. Mark the dashboard session completed if `sessionId` exists.
+5. Transition the assignment with `syntaur review` or `syntaur complete`.
+6. Remove `.syntaur/context.json` when the assignment is no longer active.
+
+## Decision Rules
+
+- If the user asks for the "next" assignment, choose from `pending` assignments only.
+- If multiple pending assignments exist, present the options unless there is an obvious single best candidate.
+- If dependencies are unmet, do not try to force an assignment into `in_progress`.
+- If acceptance criteria are incomplete, prefer transition to `review` over `completed`.
+- If workspace metadata is missing and code changes are expected, set the workspace to the current working directory before implementation.
+
+## References
+
+Read these when you need schema-level detail:
+
+- `../references/protocol-summary.md`
+- `../references/file-ownership.md`

package/plugins/syntaur/commands/track-session.md

@@ -0,0 +1,27 @@
+---
+description: Register, refresh, remove, or list tracked tmux sessions for the Syntaur dashboard.
+---
+
+# /track-session
+
+Track a tmux session so its dev servers appear in the Syntaur dashboard.
+
+## Usage
+
+- `/track-session <session-name>` - register a session and scan it
+- `/track-session --refresh [session-name]` - refresh one or all sessions
+- `/track-session --remove <session-name>` - stop tracking a session
+- `/track-session --list` - list tracked sessions
+
+## Workflow
+
+1. Prefer the `track-session` skill logic for all variants.
+2. For register:
+   - verify the tmux session exists
+   - create or update `~/.syntaur/servers/<sanitized-name>.md`
+3. For refresh:
+   - update `last_refreshed`
+4. For remove:
+   - delete the registration file
+5. For list:
+   - show tracked sessions pulled from frontmatter

package/plugins/syntaur/hooks.json

@@ -0,0 +1,27 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./scripts/enforce-boundaries.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./scripts/session-cleanup.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/syntaur/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 and 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
+
+| Location | Purpose |
+|----------|---------|
+| `<mission>/resources/<slug>.md` | Reference material |
+| `<mission>/memories/<slug>.md` | Learnings and reusable 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, you may write to files within the workspace defined in assignment frontmatter:
+
+- `workspace.worktreePath` or `workspace.repository` defines the project root
+- `.syntaur/context.json` in your current working directory is also writable

package/plugins/syntaur/references/protocol-summary.md

@@ -0,0 +1,66 @@
+# 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
+```
+
+## Assignment Lifecycle
+
+| Status | Meaning |
+|--------|---------|
+| `pending` | Not yet started |
+| `in_progress` | Actively being worked on |
+| `blocked` | Manually blocked and requires `blockedReason` |
+| `review` | Work complete and 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 assignment state.
+2. One folder per mission and one subfolder per assignment.
+3. Derived files are never edited manually.
+4. Slugs are lowercase and 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`.

package/plugins/syntaur/scripts/enforce-boundaries.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# Syntaur write boundary enforcement hook for Codex plugins.
+# Reads JSON from stdin and returns a block decision only for writes outside the
+# active assignment boundary. Any parse or runtime error falls back to allow.
+
+allow_and_exit() {
+  echo '{}'
+  exit 0
+}
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo '{"systemMessage":"Syntaur boundary hook: jq not found, skipping enforcement"}'
+  exit 0
+fi
+
+INPUT=$(cat)
+if [ -z "$INPUT" ]; then
+  allow_and_exit
+fi
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+if [ -z "$TOOL_NAME" ]; then
+  allow_and_exit
+fi
+
+case "$TOOL_NAME" in
+  Edit|Write|MultiEdit)
+    ;;
+  *)
+    allow_and_exit
+    ;;
+esac
+
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null)
+if [ -z "$FILE_PATH" ]; then
+  allow_and_exit
+fi
+
+if [[ "$FILE_PATH" != /* ]]; then
+  FILE_PATH="$(pwd)/$FILE_PATH"
+fi
+
+FILE_PATH=$(cd "$(dirname "$FILE_PATH")" 2>/dev/null && echo "$(pwd)/$(basename "$FILE_PATH")") || FILE_PATH=""
+if [ -z "$FILE_PATH" ]; then
+  allow_and_exit
+fi
+
+CONTEXT_FILE=".syntaur/context.json"
+if [ ! -f "$CONTEXT_FILE" ]; then
+  allow_and_exit
+fi
+
+ASSIGNMENT_DIR=$(jq -r '.assignmentDir // empty' "$CONTEXT_FILE" 2>/dev/null)
+MISSION_DIR=$(jq -r '.missionDir // 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
+  allow_and_exit
+fi
+
+ASSIGNMENT_DIR="${ASSIGNMENT_DIR/#\~/$HOME}"
+MISSION_DIR="${MISSION_DIR/#\~/$HOME}"
+if [ -n "$WORKSPACE_ROOT" ] && [ "$WORKSPACE_ROOT" != "null" ]; then
+  WORKSPACE_ROOT="${WORKSPACE_ROOT/#\~/$HOME}"
+else
+  WORKSPACE_ROOT=""
+fi
+
+if [[ "$FILE_PATH" == "$ASSIGNMENT_DIR"/* ]]; then
+  allow_and_exit
+fi
+
+if [[ "$FILE_PATH" == "$MISSION_DIR/resources/"* ]]; then
+  BASENAME=$(basename "$FILE_PATH")
+  if [[ "$BASENAME" != _* ]]; then
+    allow_and_exit
+  fi
+fi
+
+if [[ "$FILE_PATH" == "$MISSION_DIR/memories/"* ]]; then
+  BASENAME=$(basename "$FILE_PATH")
+  if [[ "$BASENAME" != _* ]]; then
+    allow_and_exit
+  fi
+fi
+
+CONTEXT_ABS="$(cd "$(dirname "$CONTEXT_FILE")" 2>/dev/null && echo "$(pwd)/$(basename "$CONTEXT_FILE")")"
+if [ "$FILE_PATH" = "$CONTEXT_ABS" ]; then
+  allow_and_exit
+fi
+
+if [ -n "$WORKSPACE_ROOT" ] && [[ "$FILE_PATH" == "$WORKSPACE_ROOT"/* ]]; then
+  allow_and_exit
+fi
+
+REASON="Syntaur write boundary violation: Cannot write to '$FILE_PATH'. Allowed paths: assignment dir ($ASSIGNMENT_DIR), mission resources/memories, workspace ($WORKSPACE_ROOT)."
+REASON_ESCAPED=$(echo "$REASON" | jq -Rs '.' 2>/dev/null)
+if [ -z "$REASON_ESCAPED" ]; then
+  REASON_ESCAPED="\"Syntaur write boundary violation\""
+fi
+
+echo "{\"decision\":\"block\",\"reason\":${REASON_ESCAPED}}"
+exit 0

package/plugins/syntaur/scripts/session-cleanup.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Syntaur SessionEnd hook for Codex plugins.
+# Marks active agent sessions as stopped when a Codex session exits.
+
+set -o pipefail 2>/dev/null || true
+
+if ! command -v jq >/dev/null 2>&1; then
+  exit 0
+fi
+
+INPUT=$(cat)
+if [ -z "$INPUT" ]; then
+  exit 0
+fi
+
+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
+
+SESSION_ID=$(jq -r '.sessionId // empty' "$CONTEXT_FILE" 2>/dev/null)
+MISSION_SLUG=$(jq -r '.missionSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
+
+if [ -z "$SESSION_ID" ] || [ -z "$MISSION_SLUG" ]; then
+  exit 0
+fi
+
+PORT=$(cat "$HOME/.syntaur/dashboard-port" 2>/dev/null || echo "4800")
+curl -sf -X PATCH "http://localhost:${PORT}/api/agent-sessions/${SESSION_ID}/status" \
+  -H "Content-Type: application/json" \
+  -d "{\"status\": \"stopped\", \"missionSlug\": \"${MISSION_SLUG}\"}" \
+  -o /dev/null 2>/dev/null || true
+
+exit 0