syntaur 0.69.0 → 0.71.0

package/skills/clear-assignment/SKILL.md

@@ -14,7 +14,7 @@ metadata:
 
 # Clear Assignment
 
-Drop the active assignment binding from the current workspace. The assignment itself is left untouched in `~/.syntaur/projects/.../assignments/` — only the local `.syntaur/context.json` pointer is cleared so the session is no longer scoped to it.
+Drop the active assignment binding from the current session. The assignment itself is left untouched in `~/.syntaur/projects/.../assignments/` — only the session's open engagement (the binding that makes it the active assignment) is closed so the session is no longer scoped to it. `.syntaur/context.json` is a workspace marker and is not the binding — it does not hold the active assignment.
 
 This is the inverse of `grab-assignment`. Unlike `complete-assignment`, it does **not** transition lifecycle state, write a handoff, or close out the work. Use it when:
 
@@ -28,17 +28,15 @@ If the assignment is actually done, use `complete-assignment` instead so a hando
 
 Optional flags from the user:
 
-- `--keep-session` — preserve `sessionId` / `transcriptPath` fields in `context.json` (just strip the assignment fields). Default: full delete.
-- `--unassign` — also run `syntaur unassign <slug> --project <project>` so the assignment is no longer claimed by this agent. Default: leave the claim in place (only the local context is cleared).
+- `--unassign` — also run `syntaur unassign <slug> --project <project>` so the assignment is no longer claimed by this agent. Default: leave the claim in place (only the session's engagement is closed).
 
 ## Step 1: Load Context
 
-Read `.syntaur/context.json` from the current working directory.
+The active assignment is resolved from the session's open engagement. Run `syntaur session resume --json` to read it.
 
-- If the file does not exist, tell the user: "No active assignment context to clear." and stop.
-- If the file exists but contains only session fields (`sessionId`, `transcriptPath`) and no `projectSlug` / `assignmentSlug`, tell the user: "No active assignment is bound — only a platform session record exists. Nothing to clear." and stop (unless they explicitly ask to wipe the session record too).
+- If there is no open engagement, tell the user: "No active assignment is bound to this session — nothing to clear." and stop. (`.syntaur/context.json` is only a workspace marker; its presence does not mean an assignment is bound.)
 
-Otherwise extract: `projectSlug`, `assignmentSlug`, `assignmentDir`, `title`.
+From the resolved engagement, note: `projectSlug`, `assignmentSlug`, `assignmentDir`, `title`.
 
 ## Step 2: Confirm with the User
 
@@ -68,29 +66,15 @@ For standalone assignments use the UUID (the folder name) in place of the slug,
 
 `syntaur unassign` clears the assignee on the assignment frontmatter (the inverse of `assign`) and bumps `updated`.
 
-## Step 4: Clear the Context File
+## Step 4: Close the Engagement
 
-Default behavior — delete the file entirely:
+Closing the session's open engagement is what drops the active-assignment binding — that is the operation that "clears" the assignment. The dashboard status PATCH in Step 5 (to `cleared`) closes the open engagement for a live session.
 
-```bash
-rm .syntaur/context.json
-```
-
-If the user passed `--keep-session`, preserve session fields and strip everything else instead:
-
-```bash
-jq '{sessionId, transcriptPath} | with_entries(select(.value != null))' \
-  .syntaur/context.json > .syntaur/context.json.tmp \
-  && mv .syntaur/context.json.tmp .syntaur/context.json
-```
-
-If the resulting file would be empty (`{}`), delete it instead of leaving an empty stub.
-
-Do not delete the `.syntaur/` directory itself — other tooling may use it.
+Do NOT delete or rewrite `.syntaur/context.json` to clear the assignment — it is a workspace marker and no longer carries the active assignment. Leave its repository/branch/worktree, session, and lease fields intact so other tooling keeps recognizing the workspace. Do not delete the `.syntaur/` directory.
 
 ## Step 5: Close Session (optional)
 
-If the Syntaur dashboard is running, mark this session as cleared so the dashboard does not keep showing it as active. Resolve `<session-id>` from *your* running process — prefer `$CLAUDE_CODE_SESSION_ID` (or the peer `OPENCODE_SESSION_ID` / `PI_SESSION_ID`), otherwise run `syntaur session resolve-id`. Only if neither yields an id, fall back to the `sessionId` you captured from the original `context.json` in Step 1 (before deletion) — that scalar is a shared, legacy hint a co-tenant can clobber, so don't treat it as authoritative:
+If the Syntaur dashboard is running, mark this session as cleared so the dashboard does not keep showing it as active (this also closes the session's open engagement). Resolve `<session-id>` from *your* running process — prefer `$CLAUDE_CODE_SESSION_ID` (or the peer `OPENCODE_SESSION_ID` / `PI_SESSION_ID`), otherwise run `syntaur session resolve-id`. Only if neither yields an id, fall back to the legacy `sessionId` scalar in `.syntaur/context.json` — that scalar is a shared, legacy hint a co-tenant can clobber, so don't treat it as authoritative:
 
 ```bash
 curl -s -X PATCH "http://localhost:$(cat ~/.syntaur/dashboard-port 2>/dev/null || echo 4800)/api/agent-sessions/<session-id>/status" \
@@ -100,8 +84,6 @@ curl -s -X PATCH "http://localhost:$(cat ~/.syntaur/dashboard-port 2>/dev/null |
 
 If this fails (e.g., dashboard not running, endpoint not present in the installed version), it is non-critical — silently continue.
 
-Skip this step entirely when `--keep-session` is set.
-
 ## Step 6: Report to User
 
 Summarize:

package/skills/complete-assignment/SKILL.md

@@ -19,11 +19,11 @@ Optional: the user may pass `--complete` to transition directly to `completed` i
 
 ## Step 1: Load Context
 
-Read `.syntaur/context.json` from the current working directory.
+The active assignment is resolved from the session's open engagement. Run `syntaur session resume --json` to read it.
 
-If the file does not exist, tell the user: "No active assignment found. Run `grab-assignment` first."
+If there is no open engagement (no active assignment), tell the user: "No active assignment for this session — grab one first." `.syntaur/context.json` is only a workspace marker; do not read the assignment from it.
 
-Extract: `projectSlug`, `assignmentSlug`, `assignmentDir`, `projectDir`.
+From the resolved engagement, note: `projectSlug`, `assignmentSlug`, `assignmentDir`, `projectDir`.
 
 ## Step 2: Load Playbooks
 

package/skills/create-assignment/SKILL.md

@@ -30,9 +30,9 @@ Expects arguments from the user:
 
 If no title was provided, ask the user what the assignment should be called.
 
-If neither `--project` nor `--one-off` was provided, check `.syntaur/context.json` for an active assignment. If present, default `--project` to that context's `projectSlug` and confirm with the user: "Add this assignment to project `<projectSlug>`?"
+If neither `--project` nor `--one-off` was provided, check for an active assignment via the session's open engagement (`syntaur session resume --json`). If there is one, default `--project` to its `projectSlug` and confirm with the user: "Add this assignment to project `<projectSlug>`?"
 
-If no active context and no project flag, ask the user which project to add it to, or whether it should be a one-off.
+If there is no open engagement 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
 

package/skills/extend-resource/SKILL.md

@@ -25,9 +25,9 @@ Examples:
 
 Extract `<lease_id>` (first positional) and `--ttl <duration>` (required). If either is missing, abort with a usage message and a hint to call `/list-resources` to see active leases.
 
-### Step 2: Pre-check assignment context
+### Step 2: Pre-check workspace context
 
-Read `.syntaur/context.json` from the current working directory. If the file is missing, OR has neither `sessionId` nor any of `projectSlug`/`assignmentSlug`/`assignmentDir`, abort with:
+Read `.syntaur/context.json` (a workspace marker) from the current working directory. If the file is missing, OR carries no workspace markers (`repository`/`branch`/`worktreePath`/`workspaceRoot`) and no `sessionId`, abort with:
 
 > "No active Syntaur context in this workspace. Grab an assignment first (`/grab-assignment <project> <slug>`) or restart the session so the SessionStart hook can populate `.syntaur/context.json`."
 

package/skills/grab-assignment/SKILL.md

@@ -23,10 +23,16 @@ Expects up to two arguments from the user:
 
 ## Pre-flight Check
 
-Check if `.syntaur/context.json` already exists in the current working directory.
+`.syntaur/context.json` is a WORKSPACE MARKER (repository/branch/worktree/workspaceRoot plus legacy session and bundle fields) — it is NOT the active-assignment source of truth. The active assignment binds via the session's open engagement (established by `track-session` in Step 6).
 
-- If it exists AND contains BOTH `projectSlug` and `assignmentSlug`, it represents an active assignment. Warn the user: "You already have an active assignment: `<assignmentSlug>` in project `<projectSlug>`. Grabbing a new one will replace this context. Proceed?" — stop if the user says no.
-- If it exists but only has session fields (`sessionId`, `transcriptPath`) and no project/assignment, it was populated by the platform's SessionStart hook (Claude Code, etc.) and does NOT represent an active assignment. Proceed silently and merge assignment fields on top in Step 5.
+Check whether this session already has an open engagement — i.e., a different assignment is already active:
+
+```bash
+syntaur session resume --json 2>/dev/null
+```
+
+- If it reports an active assignment, warn the user: "You already have an active assignment: `<assignmentSlug>` in project `<projectSlug>`. Grabbing a new one will rebind this session. Proceed?" — stop if the user says no.
+- If there is no open engagement (no active assignment), proceed. A `.syntaur/context.json` that holds only workspace-marker / session fields is expected — it does not represent an active assignment.
 
 ## Step 1: Discover the Project (project-nested path)
 
@@ -75,25 +81,24 @@ From the assignment frontmatter extract: `title`, `workspace.repository`, `works
 
 If `workspace.repository` and `workspace.worktreePath` are both null, set them to the current working directory. Write boundaries use this path, so it must never be null while an agent is writing code.
 
-## Step 5: Create or Merge Context File
+## Step 5: Create or Merge the Workspace Marker
 
-Merge assignment context into `.syntaur/context.json`. Never overwrite — if the file already exists (e.g., platform SessionStart hook populated `sessionId` / `transcriptPath`), preserve those fields.
+`.syntaur/context.json` is a WORKSPACE MARKER — it records the repository/branch/worktree so tooling can recognize this directory as a Syntaur workspace. It is NOT the active-assignment source of truth: the assignment binds via the session's open engagement (Step 6, `track-session`). Do NOT write `projectSlug` / `assignmentSlug` / `assignmentDir` / `projectDir` / `title` — those scalars are non-authoritative.
+
+Merge workspace markers into `.syntaur/context.json`. Never overwrite — if the file already exists (e.g., platform SessionStart hook populated `sessionId` / `transcriptPath`, or a worktree skill wrote bundle/lease fields), preserve those fields.
 
 ```bash
 mkdir -p .syntaur
 ```
 
-Prepare the assignment payload:
+Prepare the workspace-marker payload:
 
 ```json
 {
-  "projectSlug": "<project-slug or null for standalone>",
-  "assignmentSlug": "<assignment-slug>",
-  "projectDir": "/absolute/path/to/project or null",
-  "assignmentDir": "/absolute/path/to/assignment",
-  "workspaceRoot": "<workspace path or current working directory>",
-  "title": "<assignment title>",
+  "repository": "<workspace.repository or null>",
   "branch": "<workspace.branch or null>",
+  "worktreePath": "<workspace.worktreePath or null>",
+  "workspaceRoot": "<workspace path or current working directory>",
   "grabbedAt": "<ISO 8601 timestamp>"
 }
 ```

package/skills/grab-bundle/SKILL.md

@@ -34,16 +34,20 @@ the user to pick.
 
 ## Pre-flight check
 
-Read `.syntaur/context.json` in the current working directory.
+First check whether this session already has an active assignment via its open
+engagement (`syntaur session resume --json`):
+
+- If it reports an active assignment, warn the user: "You already have an active
+  assignment. Grabbing a bundle will rebind this session. Proceed?" — stop if no.
+
+Then read `.syntaur/context.json` (a workspace marker) in the current working
+directory for bundle bookkeeping:
 
-- If it already contains assignment fields (`projectSlug`/`assignmentSlug`/
-  `assignmentDir`), warn the user: "You already have an active assignment.
-  Grabbing a bundle will replace this context. Proceed?" — stop if no.
 - If it already contains different bundle fields (`bundleId` set to a
   different id), warn: "Context is bound to bundle b:<old>. Switch to b:<new>?"
   — stop if no.
-- If it has only `sessionId` (platform SessionStart hook seeded it), proceed
-  and merge bundle fields on top.
+- A context.json holding only workspace-marker / `sessionId` fields is expected;
+  proceed and merge bundle fields on top.
 
 ## Step 1: Load the bundle
 

package/skills/log-progress/SKILL.md

@@ -39,9 +39,11 @@ records current in real-time, especially after every meaningful action.
 
 ## Step 1: Verify there is an active assignment
 
-Read `.syntaur/context.json` from the current working directory. Extract
-`assignmentDir`. If missing, abort with: "No active assignment. Run
-`grab-assignment` first."
+The active assignment is resolved from the session's open engagement — `syntaur
+progress log` (Step 3) targets it automatically. `.syntaur/context.json` is only
+a workspace marker; do not read the assignment from it. If there is no open
+engagement (no active assignment), the CLI aborts with "No active assignment for
+this session — grab one first." Run `grab-assignment` first.
 
 ## Step 2: Compose the entry
 
@@ -69,7 +71,7 @@ Run:
 syntaur progress log "<your composed entry body>"
 ```
 
-The command resolves the active assignment from `.syntaur/context.json`
+The command resolves the active assignment from the session's open engagement
 (or pass `--assignment <slug> [--project <slug>]` to target one explicitly),
 then atomically:
 

package/skills/plan-assignment/SKILL.md

@@ -20,14 +20,14 @@ Optional: the user may provide focus areas or notes to guide the plan.
 
 ## 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` first to claim an assignment."
+The active assignment is resolved from the session's open engagement. Run `syntaur session resume --json` to read it. If there is no open engagement (no active assignment), tell the user: "No active assignment for this session — grab one first." and stop. `.syntaur/context.json` is only a workspace marker; do not read the assignment from it.
 
-Extract:
+From the resolved engagement, note:
 - `projectSlug` — the project slug (`null` for standalone assignments)
 - `assignmentSlug` — the assignment slug
 - `assignmentDir` — absolute path to the assignment folder
 - `projectDir` — absolute path to the project folder (may be null for standalone)
-- `workspaceRoot` — absolute path to the workspace (may be null)
+- `workspaceRoot` — absolute path to the workspace (a workspace marker; may be null)
 
 ## Step 2: Load Playbooks
 

package/skills/plan-bundle/SKILL.md

@@ -19,9 +19,10 @@ the bundle's own to track, only the member todos.
 
 ## Step 1: Load context
 
-Read `.syntaur/context.json` from the current working directory. It must
-contain `bundleId` (a bundle context). If it instead has assignment fields,
-stop and tell the user: "Active context is an assignment, not a bundle.
+Read `.syntaur/context.json` (a workspace marker) from the current working
+directory. It must contain `bundleId` (a bundle context). If there is no
+`bundleId` but the session has an open engagement (an active assignment), stop
+and tell the user: "This session is bound to an assignment, not a bundle.
 Use `/plan-assignment` instead, or `/grab-bundle <id>` to switch."
 
 Extract `bundleId`, `bundleScope`, `bundleScopeId`, `todoIds`, `planDir`.

package/skills/replan/SKILL.md

@@ -38,12 +38,15 @@ todos are never deleted.**
 
 ## Step 1: Verify there is an active assignment
 
-Read `.syntaur/context.json` from the current working directory. Extract
-`assignmentSlug`, `projectSlug` (may be null for standalone), and
-`assignmentDir`.
-
-If the file is missing or has no `assignmentSlug`, abort with: "No active
-Syntaur assignment. Run `grab-assignment` first." Do not invent values.
+The active assignment is resolved from the session's open engagement. Run
+`syntaur session resume --json` to read the bound `assignmentSlug`,
+`projectSlug` (may be null for standalone), and `assignmentDir`.
+`.syntaur/context.json` is only a workspace marker — do not read the assignment
+from it.
+
+If there is no open engagement (no active assignment), abort with: "No active
+assignment for this session — grab one first." Run `grab-assignment` first. Do
+not invent values.
 
 ## Step 2: Confirm the prior plan was implemented
 

package/skills/resume-session/SKILL.md

@@ -2,8 +2,9 @@
 name: resume-session
 description: >-
   Re-orient a fresh Syntaur session on the active assignment without
-  re-reading the full transcript. Loads the latest saved session summary,
-  `.syntaur/context.json`, and any open handoff. Use when the user says
+  re-reading the full transcript. Resolves the active assignment from the
+  session's open engagement and loads the latest saved session summary and any
+  open handoff. Use when the user says
   "resume", "pick up where we left off", "continue this assignment", or after
   a compact / new session start. Symmetric counterpart to
   `/save-session-summary`.
@@ -28,15 +29,20 @@ freely; nothing on disk changes.
 - Saving the current session's progress — that's `/save-session-summary` (the
   symmetric write side).
 
-## Step 1: Verify there is an active context
+## Step 1: Verify there is an active assignment
 
 Run `syntaur session resume`. The CLI:
 
-1. Reads `.syntaur/context.json` from the current working directory.
-2. Aborts (exit 1) with a clear message if missing or if no `assignmentDir`
-   is set — telling the user to run `grab-assignment` first.
-3. Otherwise scans `<assignmentDir>/sessions/<sid>/summary.md` and picks the
-   most recently modified.
+1. Resolves the active assignment from the session's OPEN engagement (the
+   assignment this session is currently bound to). `.syntaur/context.json` is
+   only a workspace marker — it identifies the repository/branch/worktree, not
+   the active assignment.
+2. Aborts (exit 1) with a clear message when there is no open engagement —
+   "No active assignment for this session — grab one first" — telling the user
+   to run `grab-assignment`.
+3. Otherwise resolves the assignment dir from the engagement and scans
+   `<assignmentDir>/sessions/<sid>/summary.md`, picking the most recently
+   modified.
 4. Reads `<assignmentDir>/handoff.md` (the canonical single-file handoff per
    assignment, managed by `complete-assignment`) and reports it if its body
    has been written beyond the scaffolded placeholder.

package/skills/save-session-summary/SKILL.md

@@ -26,11 +26,11 @@ mid-assignment continuity** — distinct from `handoff.md`, which is the
 
 ## Step 1: Load Context
 
-Read `.syntaur/context.json` from the current working directory.
+The active assignment is resolved from the session's open engagement. Run `syntaur session resume --json` to read it.
 
-If the file does not exist, tell the user: "No active assignment found. Run `grab-assignment` first." and stop.
+If there is no open engagement (no active assignment), tell the user: "No active assignment for this session — grab one first." and stop. `.syntaur/context.json` is only a workspace marker; do not read the assignment from it.
 
-Extract:
+From the resolved engagement, note:
 - `assignmentDir` (absolute path) — required.
 
 **Do not read the session id from `context.json` for identity.** That scalar is
@@ -86,7 +86,7 @@ printf '%s' "$BODY" | syntaur session save
 # Pass --session-id <id> only to override (e.g. you already have $CLAUDE_CODE_SESSION_ID).
 ```
 
-Resolves the active assignment from `.syntaur/context.json` (or pass
+Resolves the active assignment from the session's open engagement (or pass
 `--assignment <slug> [--project <slug>]`). `--session-id` now defaults to the
 **resolved** session (env → process tree → transcript), falling back to the
 `context.json` hint only as a last resort — so a co-tenant that clobbered the

package/skills/set-workspace/SKILL.md

@@ -35,11 +35,14 @@ implementation code until workspace fields are set.
 
 ## Step 1: Resolve the assignment file
 
-Read `.syntaur/context.json` from the current working directory. Extract
-`assignmentDir`. The target file is `<assignmentDir>/assignment.md`.
+The active assignment is resolved from the session's open engagement — `syntaur
+workspace set` (Step 3) targets it automatically. `.syntaur/context.json` is
+only a workspace marker; do not read the assignment from it.
 
-If no context, abort with: "No active assignment. Run `grab-assignment`
-first."
+If there is no open engagement (no active assignment), the CLI aborts with "No
+active assignment for this session — grab one first." Run `grab-assignment`
+first, or pass `--assignment <slug> [--project <slug>]` to target one
+explicitly.
 
 ## Step 2: Gather inputs
 
@@ -68,8 +71,8 @@ syntaur workspace set \
   --parent-branch <parent>
 ```
 
-Targets the active assignment from `.syntaur/context.json` by default; pass
-`--assignment <slug> [--project <slug>]` to target one explicitly. The command
+Targets the active assignment from the session's open engagement by default;
+pass `--assignment <slug> [--project <slug>]` to target one explicitly. The command
 does the whole safe write in one atomic step:
 
 - **Pre-write validation** — runs the same checks as `syntaur doctor

package/skills/syntaur-protocol/SKILL.md

@@ -32,7 +32,7 @@ Respect file ownership boundaries. The Claude Code and Codex plugins enforce the
    - `~/.syntaur/projects/<project>/resources/<slug>.md`
    - `~/.syntaur/projects/<project>/memories/<slug>.md`
 3. **Workspace files** inside the assignment's configured `workspace.worktreePath` / `workspace.repository`.
-4. **Context file:** `.syntaur/context.json` in the current working directory.
+4. **Workspace marker:** `.syntaur/context.json` in the current working directory (repository/branch/worktree markers plus legacy session/lease bookkeeping — not the active-assignment source of truth).
 
 ### Files written only via CLI (never edit directly)
 
@@ -51,16 +51,18 @@ Per-project `agent.md` / `claude.md` do NOT exist in protocol v2.0. Agent-level
 
 ## Current Assignment Context
 
-If `.syntaur/context.json` exists in the current working directory, read it before making changes. Fields you will see:
+The **active assignment** is resolved from the session's OPEN engagement — the assignment this session is currently bound to (established by `syntaur track-session`). It is NOT read from `.syntaur/context.json`. To learn the active assignment, run `syntaur session resume` (or `--json`); to bind a different one, `grab-assignment` (which calls `track-session`).
 
-- `projectSlug` — containing project slug (`null` for standalone assignments)
-- `assignmentSlug` — assignment slug (for standalone, the UUID is the folder name; slug is display-only)
-- `projectDir` — absolute path to the project folder (`null` for standalone)
-- `assignmentDir` — absolute path to the assignment folder
+`.syntaur/context.json` is a WORKSPACE MARKER file — it identifies the workspace directory and carries legacy session and resource-lease bookkeeping. It is NOT authoritative for the active assignment. Read it for workspace markers and leases; do NOT treat `projectSlug` / `assignmentSlug` / `assignmentDir` as the active-assignment source of truth (any such scalars are non-authoritative legacy hints). Fields you may see:
+
+- `repository` — workspace repository (path or remote URL)
+- `branch` — workspace branch, if known
+- `worktreePath` — absolute path to the worktree, if this workspace is a worktree
 - `workspaceRoot` — absolute path to the code workspace
-- `sessionId` — real agent-runtime session id (never a synthesized UUID)
+- `sessionId` — real agent-runtime session id (legacy hint; never a synthesized UUID, and a co-tenant can clobber it — not authoritative for identity)
 - `transcriptPath` — absolute path to the agent's rollout/transcript file, if known
 - `leases` — array of active resource-lease records (managed by `/claim-resource` and `/release-resource`). Entry shape: `{ lease_id, inventory_slug, member_id, expires_at, metadata, claimed_at }`. Leases are NOT auto-released on session end or assignment completion in v1 — call `/release-resource` explicitly (or let the TTL expire).
+- `bundleId` and related bundle fields — present when this workspace is bound to a todo bundle (managed by the bundle skills).
 
 ## Required Reading Order
 

package/skills/syntaur-protocol/references/file-ownership.md

@@ -64,4 +64,4 @@ When working on code (not protocol files), you may write to files within the wor
 
 - `workspace.worktreePath` or `workspace.repository` defines your code root.
 - You may create and edit source files within that workspace.
-- The `.syntaur/context.json` context file in your working directory is also writable (merge, don't overwrite — the platform SessionStart hook may have populated `sessionId` and `transcriptPath`).
+- The `.syntaur/context.json` workspace-marker file in your working directory is also writable (merge, don't overwrite — the platform SessionStart hook may have populated `sessionId` and `transcriptPath`). It marks the workspace (repository/branch/worktree); it is not the active-assignment source of truth — the active assignment resolves from the session's open engagement.

package/skills/syntaur-worktree/SKILL.md

@@ -23,8 +23,9 @@ operations:
    transactionally — rolls back the worktree on write failure).
 3. `syntaur assign` + `syntaur start` — claim the assignment for this agent
    and transition to `in_progress`.
-4. Write `.syntaur/context.json` inside the new worktree so the session is
-   bound there.
+4. Write `.syntaur/context.json` (a workspace marker) inside the new worktree,
+   then `syntaur track-session` to bind the session's engagement to the
+   assignment.
 
 ## When NOT to use this skill
 
@@ -82,12 +83,15 @@ syntaur start <assignment> --project <project-slug>   # only if status was pendi
 Skip `start` for any non-`pending` status — never rewind a `review`,
 `completed`, or `failed` assignment.
 
-## Step 5: Bind the new worktree to your session
+## Step 5: Write the workspace marker
 
-`cd` into the new worktree path. Write
-`<worktreePath>/.syntaur/context.json` mirroring the format produced by
-`/grab-assignment` (projectSlug, assignmentSlug, projectDir, assignmentDir,
-workspaceRoot, title, branch, sessionId, transcriptPath, grabbedAt).
+`cd` into the new worktree path. Write `<worktreePath>/.syntaur/context.json`
+mirroring the WORKSPACE-MARKER format produced by `/grab-assignment`:
+`repository`, `branch`, `worktreePath`, `workspaceRoot`, `grabbedAt`, plus
+`sessionId` / `transcriptPath` when known. Do NOT write `projectSlug` /
+`assignmentSlug` / `assignmentDir` / `projectDir` / `title` — context.json is a
+workspace marker, not the active-assignment source. The assignment binds in the
+next step via the session's engagement (`track-session`).
 
 If the runtime exposes a real session id (e.g. Claude Code's
 `~/.claude/sessions/`), include it. Otherwise omit `sessionId` entirely; the

package/dashboard/dist/assets/channel-fypxffzQ.js

@@ -1 +0,0 @@
-import{ap as o,aq as n}from"./mermaid.core-UtwFYLNj.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dashboard/dist/assets/classDiagram-VBA2DB6C-1KnjQvtL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DH_jEAwg.js";import{_ as i}from"./mermaid.core-UtwFYLNj.js";import"./index-Cxqr3rQB.js";import"./chunk-FMBD7UC4-DllxJhUp.js";import"./chunk-JSJVCQXG-jjMM8O5F.js";import"./chunk-55IACEB6-CGdtbsjw.js";import"./chunk-KX2RTZJC-B_6BPltQ.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dashboard/dist/assets/classDiagram-v2-RAHNMMFH-1KnjQvtL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DH_jEAwg.js";import{_ as i}from"./mermaid.core-UtwFYLNj.js";import"./index-Cxqr3rQB.js";import"./chunk-FMBD7UC4-DllxJhUp.js";import"./chunk-JSJVCQXG-jjMM8O5F.js";import"./chunk-55IACEB6-CGdtbsjw.js";import"./chunk-KX2RTZJC-B_6BPltQ.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dashboard/dist/assets/clone-CKMabBhS.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-DM-f7DWz.js";var e=4;function a(o){return r(o,e)}export{a as c};

package/dashboard/dist/assets/stateDiagram-v2-FVOUBMTO-DxWQhjNO.js

@@ -1 +0,0 @@
-import{s as e,b as r,a,S as s}from"./chunk-NQ4KR5QH-D0hJiXHp.js";import{_ as i}from"./mermaid.core-UtwFYLNj.js";import"./index-Cxqr3rQB.js";import"./chunk-55IACEB6-CGdtbsjw.js";import"./chunk-KX2RTZJC-B_6BPltQ.js";var p={parser:a,get db(){return new s(2)},renderer:r,styles:e,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{p as diagram};