muse-crew 0.7.0 → 0.7.2

package/API.md

@@ -190,6 +190,27 @@ Two namespaces, not one: the vocabulary above is the **dashboard API** (task sta
 
 Record that a poll tick occurred. Takes no arguments. Used by the dispatcher at the end of each cycle to update the last-polled timestamp.
 
+### `reserve-dispatch`
+
+Create a dispatch reservation for a task after the cron worker launches its workflow. The dispatcher skips reserved tasks on subsequent ticks — without this, a task whose workflow takes longer than the poll interval to self-claim would be re-dispatched every tick.
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `task_id` | string | Required. The task that was dispatched. |
+| `run_id` | string | Required. The workflow run ID returned by `workflow_launch_async`. |
+| `workflow` | string | Required. Which workflow was launched (`standard`, `bugfix`, `chore`). |
+| `ttl_seconds` | integer | Optional. Reservation lifetime, clamped to 60–3600 seconds. Default 900 (15 minutes). |
+
+Upserts: re-reserving the same task replaces the existing reservation. Returns the reservation with `dispatched_at` and `expires_at` timestamps.
+
+### `clear-reservation`
+
+Remove a task's dispatch reservation. Called by the workflow after a successful self-claim. Takes `task_id` (required). Returns `{ ok: true, cleared: <boolean> }` — `cleared` is false if no reservation existed (idempotent).
+
+### `list-reservations`
+
+List all active (unexpired) dispatch reservations, ordered by dispatch time. Takes no arguments. The dispatcher consumes this via `getdispatchstate` (which includes `reservations`) rather than calling it directly.
+
 ---
 
 ## Projects

package/README.md

@@ -58,7 +58,8 @@ workflow_launch with:
   args: {
     crewRepoPath: "<install-path>",
     crewHome: "~/workspace/.jarvis",
-    dashboardSlug: "orchestra-dashboard"
+    dashboardSlug: "orchestra-dashboard",
+    dashboardRepoPath: "<path-to-your-dashboard-clone>"
   }
 ```
 
@@ -66,6 +67,21 @@ For the full reference — optional arguments, what init creates, and how to ver
 
 The dashboard becomes the crew's first project — the crew works on itself.
 
+### CLI-only install (no dashboard)
+
+The dashboard is optional. For a CLI-only install, omit `dashboardSlug` and `dashboardRepoPath` together:
+
+```
+workflow_launch with:
+  scriptPath: "<install-path>/workflows/crew-init.js"
+  args: {
+    crewRepoPath: "<install-path>",
+    crewHome: "~/workspace/.my-crew"
+  }
+```
+
+Init skips project registration; create projects later via the Crew API CLI (`node <install-path>/lib/crew-api.js --crew-home ~/workspace/.my-crew create-project --json '{...}'`). The polling cron is still created, owned by `cli:<crew-home-basename>`. See the Guide for the full CLI workflow.
+
 ## Documentation
 
 - [**Guide**](docs/guide.md) — setup, project registration, task filing, the loop, pause/resume, releases, and current limitations

package/docs/guide.md

@@ -44,18 +44,26 @@ workflow_launch with:
   args: {
     crewRepoPath: "<path to muse-crew package or repo>",
     crewHome: "~/workspace/.jarvis",
-    dashboardSlug: "orchestra-dashboard"
+    dashboardSlug: "orchestra-dashboard",
+    dashboardRepoPath: "<path to your dashboard repo clone>"
   }
 ```
 
 Required arguments:
 - `crewRepoPath` — path to the `muse-crew` source. This can be an npm install (e.g., `node_modules/muse-crew`) or a Git checkout.
 - `crewHome` — directory where the crew's runtime state lives.
+
+Dashboard arguments (optional as a pair — provide both or neither):
 - `dashboardSlug` — slug of the task service artifact (must already exist).
+- `dashboardRepoPath` — path to the dashboard's git repository (your local clone from the Prerequisites). Must be a real git repo inside the workspace. Init registers the dashboard project against this path and the crew's worktree lifecycle works from it — it is never the crew home, and init will never create it for you.
+
+Omit both dashboard arguments for a CLI-only install: init skips project registration (create projects later with `crew-api.js create-project`), and the polling cron is owned by `cli:<crew-home-basename>` instead of `space:<slug>`. The crew never requires a dashboard.
 
 Optional arguments:
 - `dashboardName` — display name for the project registration (default: `"Muse Crew"`).
+- `crewName` — the human's chosen name for the crew. Stored as plain text at `$CREW_HOME/crew-name` and returned in the init summary. The setup conversation should always ask for one; init won't fail without it.
 - `cronIds` — manifest id → live id map for parallel instances on one account (default: `{}`). The manifest's ids are used as-is unless overridden, e.g. `{"crew-poll": "crew-poll-canary"}`.
+- `cronOwner` — explicit owner for the created cron jobs. Defaults to `space:<dashboardSlug>` in dashboard mode, `cli:<crew-home-basename>` in CLI-only mode.
 
 ### What init creates
 
@@ -65,7 +73,7 @@ Init runs four phases, each idempotent — re-running converges anything that dr
 
 2. **Scaffold** — creates `crewHome/.orchestration/` with subdirectories for identities, personas, workflows (documentation, not scripts), and feedback. Copies all `.md` and `.png` files from the repo using `cp -n` (no-clobber), so existing customizations are preserved.
 
-3. **Project registration** — registers the task service as a project in its own database via `createproject`. The dashboard becomes its own first project, so the crew can work on the dashboard itself.
+3. **Project registration** — registers the task service as a project in its own database via `createproject`, with `repo_path` set to the validated `dashboardRepoPath`. The dashboard becomes its own first project, so the crew can work on the dashboard itself. Re-running init is self-healing: a project already registered with the correct path is left alone, while one with a different path (e.g. from an older init) is repaired via `update-project`. Skipped entirely in CLI-only mode (no `dashboardSlug`) — create projects with `crew-api.js create-project` instead.
 
 4. **Crons** — reads the manifest at `seed/crons.json` and makes the scheduler match it: missing jobs are created from the entry (title, enabled, mode, schedule, owner, timeout_secs, and the body built from the entry's template with `crewHome` and the dashboard slug substituted in); existing jobs are viewed and converged — drifted fields are updated, unchanged jobs are left alone. One exception: init never touches `enabled` on an existing job. `enabled` is a creation-time default only — a disabled job is a deliberate human decision, and re-init must not silently resurrect it. Jobs removed from the manifest are left alone; deletion is a human decision.
 
@@ -78,6 +86,7 @@ After init completes, it returns a summary:
   "message": "Muse Crew initialized.",
   "crewHome": "~/workspace/.jarvis",
   "dashboardSlug": "orchestra-dashboard",
+  "dashboardRepoPath": "/home/hatch/workspace/orchestra-dashboard",
   "dashboardName": "Muse Crew",
   "releaseHash": "<git commit hash>",
   "scaffold": { "created": 23, "skipped": 0 },

package/lib/crew-api.js

@@ -371,6 +371,15 @@ commands["get-dispatch-state"] = (db) => {
       total_sessions: sessionCount,
       total_events: eventCount,
     },
+    // Active dispatch reservations: tasks the worker launched but whose
+    // workflow has not yet self-claimed. The dispatcher skips these.
+    reservations: db.prepare(
+      `SELECT task_id, run_id, workflow, dispatched_at, expires_at
+       FROM dispatch_reservations WHERE expires_at > ? ORDER BY dispatched_at`
+    ).all(now()).map((r) => ({
+      task_id: r.task_id, run_id: r.run_id, workflow: r.workflow,
+      dispatched_at: r.dispatched_at, expires_at: r.expires_at,
+    })),
   };
 };
 
@@ -562,6 +571,41 @@ commands["claim-task"] = (db, args) => {
   return { ok: true, claimed: false, reason: "already_claimed", existing_session_id: existing.id };
 };
 
+// Dispatch reservations: the cron worker creates one after launching a
+// workflow for a task; the dispatcher skips reserved tasks on the next tick;
+// the workflow clears it on self-claim. Expired reservations are inert.
+commands["reserve-dispatch"] = (db, args) => {
+  if (!args.task_id) throw usageError("task_id is required.");
+  if (!args.run_id) throw usageError("run_id is required.");
+  if (!args.workflow) throw usageError("workflow is required.");
+  requireTask(db, args.task_id);
+  const ttl = Math.max(60, Math.min(3600, Number(args.ttl_seconds) || 900));
+  const dispatchedAt = now();
+  const expiresAt = new Date(Date.now() + ttl * 1000).toISOString();
+  db.prepare(
+    `INSERT INTO dispatch_reservations (task_id, run_id, workflow, dispatched_at, expires_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(task_id) DO UPDATE SET
+       run_id = excluded.run_id, workflow = excluded.workflow,
+       dispatched_at = excluded.dispatched_at, expires_at = excluded.expires_at`
+  ).run(args.task_id, args.run_id, args.workflow, dispatchedAt, expiresAt);
+  return { ok: true, task_id: args.task_id, run_id: args.run_id, workflow: args.workflow, dispatched_at: dispatchedAt, expires_at: expiresAt };
+};
+
+commands["clear-reservation"] = (db, args) => {
+  if (!args.task_id) throw usageError("task_id is required.");
+  const info = db.prepare("DELETE FROM dispatch_reservations WHERE task_id = ?").run(args.task_id);
+  return { ok: true, cleared: info.changes > 0 };
+};
+
+commands["list-reservations"] = (db) => {
+  const rows = db.prepare(
+    `SELECT task_id, run_id, workflow, dispatched_at, expires_at
+     FROM dispatch_reservations WHERE expires_at > ? ORDER BY dispatched_at`
+  ).all(now());
+  return { ok: true, reservations: rows };
+};
+
 commands["park-task"] = (db, args) => {
   if (!args.task_id) throw usageError("task_id is required.");
   const message = (args.message ?? "").trim();

package/lib/schema.sql

@@ -99,3 +99,20 @@ CREATE INDEX IF NOT EXISTS events_task_id_idx ON events(task_id);
 -- another session holds the claim.
 CREATE UNIQUE INDEX IF NOT EXISTS agent_sessions_one_running_per_task_idx
   ON agent_sessions(task_id) WHERE status = 'running';
+
+-- Dispatch reservations: the dispatcher recommends, the cron worker launches,
+-- and the launched workflow self-claims. The claim can take 15+ minutes for
+-- cron-launched runs (canary 2026-09-13), far longer than the 3-minute poll
+-- interval — without a reservation, every tick re-dispatches the same task.
+-- The worker creates a reservation after launching; the dispatcher skips
+-- reserved tasks; the workflow clears it on self-claim. Expired reservations
+-- are ignored (the workflow died before claiming).
+CREATE TABLE IF NOT EXISTS dispatch_reservations (
+  task_id       TEXT PRIMARY KEY REFERENCES tasks(id) ON DELETE CASCADE,
+  run_id        TEXT NOT NULL,
+  workflow      TEXT NOT NULL,
+  dispatched_at TEXT NOT NULL,
+  expires_at    TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS dispatch_reservations_expires_idx
+  ON dispatch_reservations(expires_at);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,

package/seed/AGENTS.md

@@ -7,3 +7,4 @@ Init source data. Everything `crew-init.js` reads when setting up a new crew ins
 - `posture.md` — PM posture that shapes the user's assistant for crew interaction
 - `feedback/` — feedback feature placeholder
 - `workflows/` — human-readable workflow definitions, copied to `$CREW_HOME/.orchestration/workflows/` during init
+- `sample-project.tar.gz` — the pre-bundled flashcard study app (null-state project). When setup ends with no project in mind and no dashboard, the agent extracts this to a workspace directory, `git init`s it with an initial commit (the worktree lifecycle needs a HEAD), and registers it via `create-project`. Ships inside the npm package via `files: ["seed/"]`.

package/seed/cron-body-template.md

@@ -13,8 +13,10 @@ You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher wor
    Wait for it to complete. It reads the crew's task state, determines eligibility, claims tasks, acknowledges the poll, and returns structured results.
 
 4. **Launch claims autonomously:** Extract the `claims` array from the dispatcher result. For each claim (up to 3 per tick — if more than 3, launch the first 3 and log the rest as deferred):
-   - Call workflow_launch_async with scriptPath={claim.scriptPath} and args={claim.args}.
-   - The launched workflow self-claims the task as its first action. If the task was already claimed or is done, the claim fails closed and the run stands down quietly — this is the mechanical duplicate protection, not an error.
+   - Call workflow_launch_async with scriptPath={claim.scriptPath} and args={claim.args}. Record the returned run_id.
+   - Immediately create a dispatch reservation so the next tick does not re-dispatch before the workflow self-claims (claims can take 15+ minutes for cron-launched runs). Run in shell:
+     `node {crewHome}/lib/crew-api.js --crew-home {crewHome} reserve-dispatch --json '{"task_id": "{claim.task_id}", "run_id": "<run_id>", "workflow": "{claim.workflow}"}'`
+   - The launched workflow self-claims the task and clears the reservation as its first actions. If the task was already claimed or is done, the claim fails closed and the run stands down quietly — this is the mechanical duplicate protection, not an error.
 
    If the dispatcher returned no claims or the claims array is empty, report: NO_DISPATCH
 

package/workflows/AGENTS.md

@@ -5,7 +5,7 @@ Executable Muse workflow scripts (JavaScript). These are what the workflow runti
 - `crew-dispatch.js` — reads the board, recommends eligible tasks, returns structured launch records (the launched workflow self-claims; the dispatcher never writes claims). Skips tasks on quiesced projects and on projects with no repo_path configured.
 
 All four workflow scripts share byte-identical transport helpers (`workRetryKey`, `buildTransportRetryTrailer`, `describeWorkAgentFailure`, `workerMissingArtifactTools` — pinned by `tests/closeout.test.js`). The transport-retry loop treats a worker report naming the missing artifact tool namespace (bug 3472bf36, a per-launch platform flake) as a retryable attempt with a fresh launch rather than accepting a useless report.
-- `crew-init.js` — sets up a new crew instance: Gate 0 validates crewHome is workspace-contained and a valid git repo; bootstraps the release system; scaffolds orchestration folders; creates/converges cron jobs from the declarative manifest. Idempotent. The crew owns its state via the Crew API (lib/crew-api.js); the dashboard is a pure client and is never a dependency.
+- `crew-init.js` — sets up a new crew instance: Gate 0 validates crewHome is workspace-contained and a valid git repo, and (in dashboard mode) validates dashboardRepoPath is workspace-contained and an existing git repo (never auto-created); bootstraps the release system; scaffolds orchestration folders; registers the first project with repo_path set to the validated dashboard repo — skipped in CLI-only mode (no dashboardSlug/dashboardRepoPath), where projects are created later via crew-api.js; creates/converges cron jobs from the declarative manifest (owner `space:<slug>` in dashboard mode, `cli:<crew-home-basename>` in CLI-only mode). Idempotent. The crew owns its state via the Crew API (lib/crew-api.js); the dashboard is an optional client and is never a dependency.
 - `standard.js` — default task workflow: Triage → Capture → Map → Build → Review → Integrate → Publish → QA
 - `bugfix.js` — adds Capture after Triage, then Reproduce
 - `chore.js` — adds Capture after Triage, drops QA (low-risk)

package/workflows/bugfix.js

@@ -1060,6 +1060,7 @@ while (i < STEPS.length) {
       "Claim this task for the " + step.name + " step.\n" +
       "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
       "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
+      "If the claim response has claimed=true, then run in shell and return the stdout verbatim:\n" + crewCmd("clear-reservation", { task_id: taskId }) + "\n" +
       "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
       "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
       {

package/workflows/chore.js

@@ -1017,6 +1017,7 @@ while (i < STEPS.length) {
       "Claim this task for the " + step.name + " step.\n" +
       "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
       "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
+      "If the claim response has claimed=true, then run in shell and return the stdout verbatim:\n" + crewCmd("clear-reservation", { task_id: taskId }) + "\n" +
       "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
       "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
       {

package/workflows/crew-dispatch.js

@@ -237,6 +237,15 @@ const allTasks = boardData.ready_tasks.map(projectTaskRecord).filter(function (t
 const config = boardData.config || {};
 const projects = boardData.projects || [];
 
+// Dispatch reservations: tasks the worker launched on a previous tick whose
+// workflow has not yet self-claimed. The claim can take 15+ minutes for
+// cron-launched runs (canary 2026-09-13) — far longer than the poll interval —
+// so without this filter every tick would re-dispatch the same task.
+const reservedTaskIds = new Set((boardData.reservations || []).map(function (r) { return r.task_id; }));
+if (reservedTaskIds.size > 0) {
+  log("Reservations: skipping " + reservedTaskIds.size + " task(s) with an active dispatch reservation");
+}
+
 // Default project: explicit arg, or first registered project
 const DEFAULT_PROJECT = inputs.defaultProject || (projects.length > 0 ? projects[0].id : "");
 
@@ -383,6 +392,14 @@ for (var t = 0; t < allTasks.length; t++) {
   var task = allTasks[t];
   if (task.blocked) continue;
 
+  // Skip tasks with an active dispatch reservation: the worker launched a
+  // workflow for this task on a previous tick, but the workflow has not yet
+  // self-claimed (claims can take 15+ minutes for cron-launched runs).
+  if (reservedTaskIds.has(task.id)) {
+    log("Skipped \"" + task.title + "\" — active dispatch reservation (workflow launched, claim pending)");
+    continue;
+  }
+
   // Skip tasks from quiesced projects
   var taskProject = task.project || DEFAULT_PROJECT;
   if (quiescedProjects[taskProject]) {

package/workflows/crew-init.js

@@ -1,10 +1,10 @@
 export const meta = {
   name: "crew-init",
-  description: "Initialize Muse Crew: bootstrap release, scaffold orchestration, register dashboard project, set up cron jobs. Idempotent — safe to re-run.",
+  description: "Initialize Muse Crew: bootstrap release, scaffold orchestration, register the first project, set up cron jobs. Idempotent — safe to re-run. The dashboard is optional: omit dashboardSlug/dashboardRepoPath for a CLI-only install. Takes an optional crewName (the human's chosen name for the crew), stored at $CREW_HOME/crew-name.",
   phases: [
     { name: "release", title: "Bootstrap release system" },
     { name: "scaffold", title: "Scaffold orchestration directory" },
-    { name: "project", title: "Register dashboard project" },
+    { name: "project", title: "Register first project" },
     { name: "crons", title: "Create and converge cron jobs" }
   ]
 };
@@ -14,12 +14,18 @@ const inputs = args ?? {};
 const crewRepoPath = inputs.crewRepoPath;
 const crewHome = inputs.crewHome;
 const dashboardSlug = inputs.dashboardSlug;
+const dashboardRepoPath = inputs.dashboardRepoPath;
 const dashboardName = inputs.dashboardName || "Muse Crew";
+const crewName = inputs.crewName || null;
 const cronIds = inputs.cronIds || {};
 
 if (!crewRepoPath) throw new Error("crewRepoPath is required — path to muse-crew (git checkout or npm install)");
 if (!crewHome) throw new Error("crewHome is required — e.g. ~/workspace/.crew (must be inside the workspace)");
-if (!dashboardSlug) throw new Error("dashboardSlug is required — slug of the task service artifact (must already exist)");
+// The dashboard is optional. Provide both dashboardSlug and dashboardRepoPath
+// together for the dashboard flow (the dashboard becomes the crew's first
+// project); omit both for a CLI-only install (no dashboard required —
+// create projects later via crew-api.js). One without the other is an error.
+if (!!dashboardSlug !== !!dashboardRepoPath) throw new Error("dashboardSlug and dashboardRepoPath must be provided together, or neither (omit both for a CLI-only install without a dashboard)");
 
 const orchDir = crewHome + "/.orchestration";
 
@@ -31,10 +37,13 @@ const orchDir = crewHome + "/.orchestration";
 // copies). Fail closed here so no such instance can ever be created.
 // The dashboard repo is validated too: init registers the dashboard
 // project against it, and a non-git path would only fail later at the
-// first Build (the canary's npm-package repo_path defect).
+// first Build (the canary's npm-package repo_path defect, 2026-09-13:
+// init registered the crew home itself as the dashboard repo_path).
+// Unlike the crew home, the dashboard repo is NEVER auto-created — it is
+// the user's own project repository; a non-git path is a user error.
 // Gate 0 decision logic is pure JS — the agent is a sensor, not a judge.
 // It reports raw facts (HOME, expanded paths, the git rev-parse exit
-// code); the launchable/repo_valid verdicts are computed here,
+// codes); the launchable/repo_valid verdicts are computed here,
 // deterministically. An agent asked for a verdict can mis-apply the
 // prefix rule (e.g. the "$ws-evil" trailing-slash trick); code cannot.
 // (Prompt hardening is a smell — this is the mechanical version.)
@@ -44,26 +53,39 @@ function expandTilde(p, home) {
   return p;
 }
 function gate0Decide(facts) {
-  // facts: { home, crewHomeExpanded, gitExitCode }
+  // facts: { home, crewHomeExpanded, gitExitCode, dashboardRepoExpanded, dashboardRepoGitExitCode }
+  // The dashboard fields are null in CLI-only mode (no dashboard) — the
+  // dashboard verdicts are then vacuously true (nothing to validate).
   var workspace = facts.home + "/workspace";
   var launchable = facts.crewHomeExpanded.indexOf(workspace + "/") === 0;
   var repoValid = facts.gitExitCode === 0;
-  return { workspace: workspace, launchable: launchable, repoValid: repoValid };
+  var dashboardRepoLaunchable = facts.dashboardRepoExpanded == null || facts.dashboardRepoExpanded.indexOf(workspace + "/") === 0;
+  var dashboardRepoValid = facts.dashboardRepoGitExitCode == null || facts.dashboardRepoGitExitCode === 0;
+  return { workspace: workspace, launchable: launchable, repoValid: repoValid, dashboardRepoLaunchable: dashboardRepoLaunchable, dashboardRepoValid: dashboardRepoValid };
 }
 var gateFacts;
 try {
   gateFacts = await agent(
-    "Ensure the requested crew home exists as a git repository. Report raw facts.\\n\\n" +
-    "Requested crewHome: " + crewHome + "\\n\\n" +
+    "Validate the requested crew home" + (dashboardRepoPath ? " and dashboard repository" : "") + ". Report raw facts.\\n\\n" +
+    "Requested crewHome: " + crewHome + "\\n" +
+    (dashboardRepoPath ? "Requested dashboardRepoPath: " + dashboardRepoPath + "\\n" : "") + "\\n" +
     "Steps (run in shell):\\n" +
     "1. home=$(echo $HOME)\\n" +
     "2. Expand a leading ~/ in the requested crewHome against $HOME (leave other paths untouched).\\n" +
-    "3. If the expanded path does not exist: mkdir -p <expanded crewHome>\\n" +
+    "3. If the expanded crewHome does not exist: mkdir -p <expanded crewHome>\\n" +
     "4. Run: git -C <expanded crewHome> rev-parse --git-dir; echo EXIT:$?\\n" +
     "5. If EXIT is not 0: run git -C <expanded crewHome> init -b main (or git init if -b not supported)\\n" +
     "6. Re-run: git -C <expanded crewHome> rev-parse --git-dir; echo EXIT:$?\\n" +
-    "7. Return JSON { home, crewHomeExpanded, gitExitCode } where gitExitCode is the FINAL exit code after init.\\n\\n" +
-    "This ensures the crew home is a valid git repository. Do not judge — just ensure and report.",
+    (dashboardRepoPath ?
+      "7. Expand a leading ~/ in the requested dashboardRepoPath against $HOME (leave other paths untouched).\\n" +
+      "8. Run: git -C <expanded dashboardRepoPath> rev-parse --git-dir; echo EXIT:$?\\n" +
+      "   Do NOT create or git-init the dashboard repo — it must already be a git repository.\\n" +
+      "9. Return JSON { home, crewHomeExpanded, gitExitCode, dashboardRepoExpanded, dashboardRepoGitExitCode }\\n" +
+      "   where gitExitCode is the FINAL crew-home exit code after init, and dashboardRepoGitExitCode\\n" +
+      "   is the dashboard repo's exit code (no init attempted).\\n" :
+      "7. Return JSON { home, crewHomeExpanded, gitExitCode, dashboardRepoExpanded: null, dashboardRepoGitExitCode: null }.\\n") +
+    "\\n" +
+    "This ensures the crew home is a valid git repository" + (dashboardRepoPath ? " and the dashboard repo exists as one" : "") + ". Do not judge — just ensure and report.",
     {
       key: "gate-0",
       label: "Validate crew home",
@@ -72,9 +94,11 @@ try {
         properties: {
           home: { type: "string" },
           crewHomeExpanded: { type: "string" },
-          gitExitCode: { type: "number" }
+          gitExitCode: { type: "number" },
+          dashboardRepoExpanded: { type: ["string", "null"] },
+          dashboardRepoGitExitCode: { type: ["number", "null"] }
         },
-        required: ["home", "crewHomeExpanded", "gitExitCode"]
+        required: ["home", "crewHomeExpanded", "gitExitCode", "dashboardRepoExpanded", "dashboardRepoGitExitCode"]
       }
     }
   );
@@ -100,7 +124,51 @@ if (!gateResult.repoValid) {
     }
   };
 }
-log("Gate 0: crewHome " + gateFacts.crewHomeExpanded + " is workspace-contained and a valid git repo");
+if (!gateResult.dashboardRepoLaunchable) {
+  return {
+    __hatchWorkflowControl: "blocked",
+    result: {
+      blocked_reason: "dashboardRepoPath is not workspace-contained",
+      message: "dashboardRepoPath must be inside the workspace (" + gateResult.workspace + ") because the crew works on it via worktrees launched from workspace-contained paths. Requested: " + gateFacts.dashboardRepoExpanded + ". Clone the dashboard repo under the workspace and re-run init."
+    }
+  };
+}
+if (!gateResult.dashboardRepoValid) {
+  return {
+    __hatchWorkflowControl: "blocked",
+    result: {
+      blocked_reason: "dashboardRepoPath is not a git repository",
+      message: "dashboardRepoPath (" + gateFacts.dashboardRepoExpanded + ") is not a git repository (git exit code " + gateFacts.dashboardRepoGitExitCode + "). Init registers the dashboard project against this path and the crew's worktree lifecycle requires a real git repo. Clone the dashboard repository first, then re-run init. Init will never create the dashboard repo for you."
+    }
+  };
+}
+log("Gate 0: crewHome " + gateFacts.crewHomeExpanded + " is workspace-contained and a valid git repo" + (gateFacts.dashboardRepoExpanded ? "; dashboard repo " + gateFacts.dashboardRepoExpanded + " is workspace-contained and a valid git repo" : " (CLI-only mode: no dashboard)"));
+
+// ── Crew name ─────────────────────────────────────────────────────────
+// The human names their crew during setup (SETUP-EXPERIENCE.md). Stored as
+// plain text at $CREW_HOME/crew-name; returned in the init summary.
+// Optional at the mechanical layer — the setup conversation should always
+// ask, but init must not fail when no name was given.
+if (crewName) {
+  try {
+    await agent(
+      "Record the crew's human-chosen name.\n\n" +
+      "Crew home: " + gateFacts.crewHomeExpanded + "\n" +
+      "Crew name: " + crewName + "\n\n" +
+      "Use the Write tool to write the exact name as a single line to " + gateFacts.crewHomeExpanded + "/crew-name (no extra whitespace or newlines beyond the one trailing newline). Do not use shell echo — the name may contain quoting-sensitive characters.\n" +
+      "This is a fire-and-forget write: no return value is needed.",
+      {
+        key: "crew-name-1",
+        label: "Record crew name"
+      }
+    );
+    log("Crew name: " + crewName);
+  } catch (e) {
+    return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Crew name recording failed", message: String(e.message || e) } };
+  }
+} else {
+  log("Crew name: not provided (setup should ask the human for one)");
+}
 
 // ── Phase 1: Release ──────────────────────────────────────────────────
 phase("release");
@@ -184,35 +252,53 @@ var scaffoldSkipped = scaffoldResult.skipped ? scaffoldResult.skipped.length : 0
 log("Scaffold: " + scaffoldCreated + " created, " + scaffoldSkipped + " skipped");
 
 // ── Phase 3: Project registration ─────────────────────────────────────
-// Registers the dashboard as the crew's first project in crew-state.db via
-// the Crew API. The dashboard becomes its own first project, so the crew can
-// work on the dashboard itself. Idempotent: if the project already exists,
-// it is left alone.
+// Registers the first project in crew-state.db via the Crew API. In
+// dashboard mode, the dashboard becomes the crew's first project (so the
+// crew can work on the dashboard itself); the project's repo_path is the
+// validated dashboard git repository from Gate 0 — never the crew home
+// (the 2026-09-13 defect where init registered the crew home itself as
+// the repo_path). Idempotent and self-healing: if the project already
+// exists with the correct repo_path it is left alone; if it exists with
+// a different repo_path (e.g. from a pre-fix init), the path is repaired.
+// In CLI-only mode (no dashboardSlug) this phase is skipped — create
+// projects later via crew-api.js create-project.
 phase("project");
 var projectResult;
+if (!dashboardSlug) {
+  log("Project: skipped (CLI-only mode — no dashboard; create projects via crew-api.js create-project)");
+  projectResult = { action: "skipped", project_id: null };
+} else {
 var safeDashboardName = dashboardName.split('"').join('\\"');
+var safeDashboardRepo = gateFacts.dashboardRepoExpanded.split('"').join('\\"');
 try {
   projectResult = await agent(
     "Register the dashboard as a project in the crew's task database.\n\n" +
     "Crew home: " + crewHome + "\n" +
     "Crew API: " + crewHome + "/current/lib/crew-api.js\n" +
     "Dashboard slug (project id): " + dashboardSlug + "\n" +
-    "Dashboard name (display_name): " + dashboardName + "\n\n" +
+    "Dashboard name (display_name): " + dashboardName + "\n" +
+    "Dashboard repo path (repo_path): " + gateFacts.dashboardRepoExpanded + "\n\n" +
     "Steps:\n" +
     "1. Check if the project already exists:\n" +
     "   node " + crewHome + "/current/lib/crew-api.js --crew-home " + crewHome + " get-project --json '{\"id\": \"" + dashboardSlug + "\"}'\n" +
-    "   If it returns a project (ok: true), return { action: \"exists\", project_id: \"" + dashboardSlug + "\" }.\n" +
-    "2. If not found (error), create it:\n" +
-    "   node " + crewHome + "/current/lib/crew-api.js --crew-home " + crewHome + " create-project --json '{\"id\": \"" + dashboardSlug + "\", \"display_name\": \"" + safeDashboardName + "\", \"repo_path\": \"" + crewHome + "\", \"deploy_type\": \"artifact\", \"deploy_slug\": \"" + dashboardSlug + "\", \"description\": \"The dashboard task service — the crew\\u0027s first project\"}'\n" +
+    "2. If it returns a project (ok: true):\n" +
+    "   a. Compare its repo_path to: " + gateFacts.dashboardRepoExpanded + "\n" +
+    "   b. If they match, return { action: \"exists\", project_id: \"" + dashboardSlug + "\" }.\n" +
+    "   c. If they differ, repair it:\n" +
+    "      node " + crewHome + "/current/lib/crew-api.js --crew-home " + crewHome + " update-project --json '{\"id\": \"" + dashboardSlug + "\", \"repo_path\": \"" + safeDashboardRepo + "\"}'\n" +
+    "      Return { action: \"repaired\", project_id: \"" + dashboardSlug + "\" }.\n" +
+    "3. If not found (error), create it:\n" +
+    "   node " + crewHome + "/current/lib/crew-api.js --crew-home " + crewHome + " create-project --json '{\"id\": \"" + dashboardSlug + "\", \"display_name\": \"" + safeDashboardName + "\", \"repo_path\": \"" + safeDashboardRepo + "\", \"deploy_type\": \"artifact\", \"deploy_slug\": \"" + dashboardSlug + "\", \"description\": \"The dashboard task service — the crew\\u0027s first project\"}'\n" +
     "   Return { action: \"created\", project_id: \"" + dashboardSlug + "\" }.\n\n" +
-    "Return JSON with action (\"exists\" or \"created\") and project_id (string).",
+    "The repo_path must be the dashboard git repository — never the crew home.\n" +
+    "Return JSON with action (\"exists\", \"repaired\", or \"created\") and project_id (string).",
     {
       key: "project-1",
       label: "Register dashboard project",
       schema: {
         type: "object",
         properties: {
-          action: { type: "string", enum: ["exists", "created"] },
+          action: { type: "string", enum: ["exists", "repaired", "created"] },
           project_id: { type: "string" }
         },
         required: ["action", "project_id"]
@@ -222,21 +308,30 @@ try {
 } catch (e) {
   return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Project registration failed", message: String(e.message || e) } };
 }
-log("Project: " + dashboardSlug + " " + projectResult.action);
+log("Project: " + dashboardSlug + " " + projectResult.action + " (repo_path=" + gateFacts.dashboardRepoExpanded + ")");
+} // end dashboard-mode project registration
 
 // ── Phase 4: Cron jobs (declarative manifest) ──────────────────────────
 // The manifest lives in the repo at seed/crons.json. Body templates live
 // in seed/ with {crewHome} placeholders. Missing jobs are
 // created from the manifest; existing jobs converge to it — except `enabled`,
 // which is a creation-time default only and is never touched on update.
+// Instance identity: in dashboard mode the dashboard slug scopes cron ids
+// and ownership (space:<slug>); in CLI-only mode the crew-home basename
+// scopes them instead, so two crew instances never share a cron id and no
+// dashboard is required.
 phase("crons");
+var crewHomeBase = gateFacts.crewHomeExpanded.split("/").pop().replace(/^\./, "") || "crew";
+var instanceId = dashboardSlug || crewHomeBase;
+var cronOwner = inputs.cronOwner || (dashboardSlug ? "space:" + dashboardSlug : "cli:" + instanceId);
 var cronsResult;
 try {
   cronsResult = await agent(
     "Ensure the Muse Crew cron jobs match the repo's declarative manifest.\n\n" +
     "Manifest: " + crewRepoPath + "/seed/crons.json\n" +
     "crewHome: " + crewHome + "\n" +
-    "dashboardSlug: " + dashboardSlug + "\n" +
+    "Instance id (cron id suffix): " + instanceId + "\n" +
+    "Cron owner: " + cronOwner + "\n" +
     "Id overrides (manifest id -> live id): " + JSON.stringify(cronIds) + "\n\n" +
     "Steps:\n" +
     "1. Read the manifest at " + crewRepoPath + "/seed/crons.json and parse it as JSON.\n" +
@@ -245,18 +340,17 @@ try {
     "   owner, body_template).\n" +
     "2. For each manifest entry, in order:\n" +
     "   a. The live id is the override for entry.id when present (inputs.cronIds[entry.id]).\n" +
-    "      Otherwise, the live id is entry.id + '-' + dashboardSlug (instance-safe by\n" +
+    "      Otherwise, the live id is entry.id + '-' + \"" + instanceId + "\" (instance-safe by\n" +
     "      construction — two crew instances never share a cron id). The bare manifest\n" +
     "      id is never used as a live id.\n" +
     "   b. Read the body template at " + crewRepoPath + "/seed/<entry.body_template>.\n" +
     "   c. Replace all occurrences of {crewHome} with: " + crewHome + ".\n" +
-    "      Replace all occurrences of {dashboardSlug} with: " + dashboardSlug + ".\n" +
     "   d. Call cron_list and look for a job with the live id.\n" +
     "   e. If missing, call cron_add with:\n" +
     "      - id: the live id\n" +
     "      - title, enabled, mode from the entry\n" +
     "      - schedule: the entry's schedule object\n" +
-    "      - owner: the entry's owner with {dashboardSlug} replaced by: " + dashboardSlug + "\n" +
+    "      - owner: " + cronOwner + "\n" +
     "      - timeout_secs: the entry's timeout_secs when present\n" +
     "      - body: the resolved template text\n" +
     "      Record action 'created' with no updated fields.\n" +
@@ -315,7 +409,9 @@ log("Crons: " + cronsResult.summary.crons.map(function (c) { return c.id + "=" +
 return {
   message: "Muse Crew initialized.",
   crewHome: crewHome,
+  crewName: crewName,
   dashboardSlug: dashboardSlug,
+  dashboardRepoPath: gateFacts.dashboardRepoExpanded,
   dashboardName: dashboardName,
   releaseHash: releaseResult.hash,
   scaffold: { created: scaffoldCreated, skipped: scaffoldSkipped },

package/workflows/standard.js

@@ -1059,6 +1059,7 @@ while (i < STEPS.length) {
       "Claim this task for the " + step.name + " step.\n" +
       "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
       "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
+      "If the claim response has claimed=true, then run in shell and return the stdout verbatim:\n" + crewCmd("clear-reservation", { task_id: taskId }) + "\n" +
       "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
       "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
       {