muse-crew 0.6.8 → 0.7.1

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

@@ -529,6 +529,12 @@ commands["claim-task"] = (db, args) => {
   const task = requireTask(db, args.task_id);
   const project = requireProject(db, task.project);
   if (project.quiesced) throw conflict("This project is paused. Resume it before claiming tasks.");
+  // Mechanical guard: never claim a task that is already in a terminal state.
+  // The dispatcher may recommend a task based on stale state (e.g. a task that
+  // was marked done between the dispatcher's read and the workflow's claim).
+  // The claim must fail closed here, not launch a duplicate run.
+  if (task.state === "done") throw conflict("Task is already done and cannot be claimed.");
+  if (task.state === "cancelled") throw conflict("Task is cancelled and cannot be claimed.");
 
   const row = {
     id: uuid(), task_id: args.task_id, identity,

package/lib/test-version-write.sh

@@ -30,12 +30,29 @@ TMPBASE="$(mktemp -d)"
 trap 'rm -rf "$TMPBASE"' EXIT
 
 # --- Fixture: temp git repo seeded with the repo's current package.json ---
+# The test injects a \u2014 escape into the description field so the fixture
+# carries the escape this regression is about, regardless of whether the
+# repo's own package.json still has one. We write the JSON manually to ensure
+# the escape appears as literal backslash-u bytes, not the decoded character.
 FIX="$TMPBASE/fixture"
 mkdir -p "$FIX"
 git init -q -b main "$FIX" >/dev/null
 git -C "$FIX" config user.email "test@example.com"
 git -C "$FIX" config user.name "test"
-cp "$REPO_DIR/package.json" "$FIX/package.json"
+node -e '
+const fs = require("fs");
+const pkg = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+pkg.version = pkg.version; // keep version from repo
+const lines = JSON.stringify(pkg, null, 2).split("\n");
+// Replace the description line with one carrying a literal \u2014 escape
+const out = lines.map(function (l) {
+  if (l.match(/"description":/)) {
+    return "  \"description\": \"Test description with em-dash escape \\u2014 here\",";
+  }
+  return l;
+});
+fs.writeFileSync(process.argv[2], out.join("\n") + "\n");
+' "$REPO_DIR/package.json" "$FIX/package.json"
 git -C "$FIX" add package.json
 git -C "$FIX" commit -qm "initial"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.6.8",
+  "version": "0.7.1",
   "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

@@ -1,6 +1,6 @@
 ## Muse Crew Dispatcher
 
-You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher workflow and report its claims. The main chat agent handles the actual task workflow launches.
+You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher workflow and launch its claims autonomously.
 
 ### Steps
 
@@ -12,11 +12,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. **Report claims:** Extract the `claims` array from the dispatcher result. For each claim, emit one line:
-   LAUNCH: script={claim.scriptPath} args={JSON.stringify(claim.args)}
+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.
 
    If the dispatcher returned no claims or the claims array is empty, report: NO_DISPATCH
 
-   Do NOT call workflow_launch_async for any task workflow. The main chat agent does that.
-
 5. Exit silently.

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/crew-init.js

@@ -1,9 +1,10 @@
 export const meta = {
   name: "crew-init",
-  description: "Initialize Muse Crew: bootstrap release, scaffold orchestration, 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 first project" },
     { name: "crons", title: "Create and converge cron jobs" }
   ]
 };
@@ -13,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";
 
@@ -30,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.)
@@ -43,23 +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(
-    "Report raw facts about the requested crew home. Do NOT judge it — just report.\\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. Run: git -C <expanded crewHome> rev-parse --git-dir; echo EXIT:$?\\n" +
-    "4. Return JSON { home, crewHomeExpanded, gitExitCode }.\\n\\n" +
-    "Do not create anything. This is a read-only check.",
+    "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" +
+    (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",
@@ -68,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"]
       }
     }
   );
@@ -91,12 +119,56 @@ if (!gateResult.repoValid) {
   return {
     __hatchWorkflowControl: "blocked",
     result: {
-      blocked_reason: "crewHome is not a git repository",
-      message: "crewHome (" + gateFacts.crewHomeExpanded + ") is not a valid git repository (git exit code " + gateFacts.gitExitCode + "). Initialize it with git init or pick an existing repo."
+      blocked_reason: "crewHome git init failed",
+      message: "crewHome (" + gateFacts.crewHomeExpanded + ") could not be initialized as a git repository (git exit code " + gateFacts.gitExitCode + "). Check permissions and try again."
     }
   };
 }
-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");
@@ -109,11 +181,11 @@ try {
     "Release script (in repo): " + crewRepoPath + "/lib/crew-release.sh\n\n" +
     "Steps:\n" +
     "1. Run: test -f " + crewHome + "/crew-release.sh && echo EXISTS || echo MISSING\n" +
-    "2. If EXISTS, run: " + crewHome + "/crew-release.sh current\n" +
+    "2. If EXISTS, run: " + crewHome + "/crew-release.sh current " + crewHome + "\n" +
     "   Return { existed: true, hash: <current hash> }\n" +
     "3. If MISSING, bootstrap:\n" +
     "   a. Run: bash " + crewRepoPath + "/lib/crew-release.sh init " + crewHome + " " + crewRepoPath + "\n" +
-    "   b. Verify: " + crewHome + "/crew-release.sh current\n" +
+    "   b. Verify: " + crewHome + "/crew-release.sh current " + crewHome + "\n" +
     "   c. Return { existed: false, hash: <hash from current> }\n\n" +
     "Return JSON with existed (boolean) and hash (string).",
     {
@@ -179,19 +251,87 @@ var scaffoldCreated = scaffoldResult.created ? scaffoldResult.created.length : 0
 var scaffoldSkipped = scaffoldResult.skipped ? scaffoldResult.skipped.length : 0;
 log("Scaffold: " + scaffoldCreated + " created, " + scaffoldSkipped + " skipped");
 
-// ── Phase 3: Cron jobs (declarative manifest) ──────────────────────────
+// ── Phase 3: Project registration ─────────────────────────────────────
+// 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" +
+    "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" +
+    "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" +
+    "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", "repaired", "created"] },
+          project_id: { type: "string" }
+        },
+        required: ["action", "project_id"]
+      }
+    }
+  );
+} catch (e) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Project registration failed", message: String(e.message || e) } };
+}
+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" +
@@ -199,16 +339,18 @@ try {
     "   or any entry lacks a required field (id, title, enabled, mode, schedule,\n" +
     "   owner, body_template).\n" +
     "2. For each manifest entry, in order:\n" +
-    "   a. The live id is the override for entry.id when present, else entry.id.\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 + '-' + \"" + 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" +
@@ -267,9 +409,12 @@ 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 },
+  project: projectResult.action,
   crons: cronsResult.summary.crons
 };