muse-crew 0.7.0 → 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/package.json

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