muse-crew 0.6.6 → 0.6.7

package/workflows/crew-dispatch.js

@@ -6,16 +6,36 @@ export const meta = {
 
 // Config from args — no instance constants
 const inputs = args ?? {};
-const DASHBOARD_SLUG = inputs.dashboardSlug;
 const crewHome = inputs.crewHome;
 
-if (!DASHBOARD_SLUG) throw new Error("dashboardSlug is required");
 if (!crewHome) throw new Error("crewHome is required");
+// Crew API: the dispatcher calls the crew-owned CLI, not the dashboard.
+// The CLI implements the API.md contract against $CREW_HOME/crew-state.db.
+const CREW_API = crewHome + "/current/lib/crew-api.js";
+// Build a shell command invoking the CLI. Args are JSON-encoded and
+// single-quote-wrapped for safe shell passing. The agent runs this and
+// returns the stdout verbatim (the CLI emits JSON on stdout).
+function crewCmd(command, args) {
+  var json = JSON.stringify(args || {}).replace(/'/g, "'\\''");
+  return "node " + CREW_API + " --crew-home " + crewHome + " " + command + " --json '" + json + "'";
+}
+// Launchability invariant: workflow_launch only accepts workspace-contained
+// scripts. crew-init's Gate 0 fails closed on any crewHome outside the
+// workspace, so WORKFLOW_DIR below is always launchable — the dispatcher
+// never needs to stage or copy scripts (the Gate 1 canary's ad-hoc copies
+// are the failure mode this invariant eliminates).
 const WORKFLOW_DIR = crewHome + "/workflows";
 
 // Project config is built from dashboard project records (getdispatchstate)
 // — no separate registry file needed.
 
+// Effective visual protocol for a launch. Crew default is off; a project
+// opts in per-project with visual_protocol:true on its project record.
+// null (inherit) and false (explicit off) both resolve to false here.
+function effectiveVisualProtocol(project) {
+  return !!project && project.visual_protocol === true;
+}
+
 // Per-poll processing cap. The launching cron times out at 300s; each
 // processed task costs roughly one agent() round trip, so cap the number of
 // tasks processed per poll and defer the rest to the next tick. Wall-clock
@@ -71,33 +91,151 @@ for (var wi = 0; wi < wfNames.length; wi++) {
 phase("dispatch");
 
 // ── 1. Read the board ────────────────────────────────────────────────
-const boardResult = await agent(
+// The agent ferries the getdispatchstate stdout back as a RAW STRING — it
+// must not parse, select, rewrite, summarize, paraphrase, or reformat the
+// JSON. All board shaping happens deterministically in JS below
+// (parseBoardJson, then unwrapBoardResult as defense-in-depth), so the LLM
+// has no formatting discretion at all.
+// NO schema on this call. A schema is a contract on a consumed return value
+// only, and here the contract belongs on the deterministic parse, not on
+// the agent's formatting choice. (Prompt/schema contradiction, 2026-09-12:
+// the prompt demanded "stdout verbatim, byte-for-byte" — a string — while
+// the schema demanded a top-level object with ready_tasks. The LLM resolved
+// the contradiction non-deterministically: some ticks validated, some
+// burned retries and blocked the whole dispatcher.)
+const boardReturn = await agent(
   "Read the dispatch state.\n" +
-  "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getdispatchstate\", args {}.\n" +
-  "Return ONLY the following projection as JSON. Do not reproduce any other fields:\n" +
-  "{\n" +
-  "  \"ready_tasks\": [ { \"id\", \"title\", \"description\", \"state\", \"project\", \"workflow\", \"blocked\", \"latest_session\": { \"id\", \"status\", \"step\", \"notes\" } or null } ],\n" +
-  "  \"projects\": [ { \"id\", \"simultaneity\", \"quiesced\", \"repo_path\", \"deploy_type\", \"deploy_slug\", \"description\" } ],\n" +
-  "  \"config\": { ... } // the config object as-is\n" +
-  "}",
+  "Run in shell and return the stdout as a raw string:\n" + crewCmd("get-dispatch-state", {}) + "\n" +
+  "Return the command's stdout JSON as a plain string, byte-for-byte, unmodified. " +
+  "Do NOT parse the JSON — your return value must be the raw stdout string, never an object. " +
+  "Do not select fields, do not rewrite, summarize, paraphrase, or reformat anything. " +
+  "The result has keys ready_tasks, projects, config, counts — ferry the string exactly as received.",
   {
     key: "read-board",
-    label: "Reading board state",
-    schema: {
-      type: "object",
-      properties: {
-        ready_tasks: { type: "array" },
-        projects: { type: "array" },
-        config: { type: "object" }
-      },
-      required: ["ready_tasks"]
-    }
+    label: "Reading board state"
   }
 );
 
-const allTasks = boardResult.ready_tasks || [];
-const config = boardResult.config || {};
-const projects = boardResult.projects || [];
+// Deterministic board parse — the read-board agent is told to return the
+// CLI stdout as a raw string; the workflow parses it here. Fails closed:
+// an unparseable return throws, never a silent empty task set.
+function parseBoardJson(boardReturn) {
+  if (typeof boardReturn === "string") {
+    try {
+      return JSON.parse(boardReturn);
+    } catch (e) {
+      throw new Error("parseBoardJson: read-board stdout is not valid JSON: " + e.message);
+    }
+  }
+  // The agent may still hand back the parsed board object instead of the
+  // raw string (the non-deterministic behavior this fix removes from the
+  // contract). JSON values round-trip deterministically, so the object is
+  // accepted as-is — the LLM has no formatting discretion that affects the
+  // outcome, and every return shape converges on the same boardData.
+  if (boardReturn !== null && typeof boardReturn === "object") {
+    return boardReturn;
+  }
+  throw new Error(
+    "parseBoardJson: expected the read-board return to be a raw stdout string or a parsed board object, got " +
+    (boardReturn === null ? "null" : typeof boardReturn)
+  );
+}
+
+// Deterministic board projection — the ONLY place task records are shaped.
+// Pure function, no I/O: covered by tests/board-projection.test.js. The
+// retry field is dashboard-owned state (consecutive failures / rejections
+// since reset, computed server-side); carrying it through here is what
+// makes the retry cap below enforceable instead of fail-open.
+function projectTaskRecord(t) {
+  if (!t || typeof t !== "object") return null;
+  var ls = (t.latest_session && typeof t.latest_session === "object") ? t.latest_session : null;
+  var retry = (t.retry && typeof t.retry === "object") ? t.retry : null;
+  var cf = retry ? retry.consecutive_failures : undefined;
+  var rsr = retry ? retry.rejections_since_reset : undefined;
+  return {
+    id: t.id,
+    title: t.title,
+    description: t.description,
+    state: t.state,
+    project: t.project,
+    workflow: t.workflow,
+    blocked: t.blocked,
+    deps: Array.isArray(t.deps) ? t.deps.slice() : [],
+    priority: t.priority,
+    latest_session: ls ? { id: ls.id, status: ls.status, step: ls.step, notes: ls.notes } : null,
+    retry: {
+      consecutive_failures: (typeof cf === "number" && cf >= 0) ? cf : 0,
+      rejections_since_reset: (typeof rsr === "number" && rsr >= 0) ? rsr : 0
+    }
+  };
+}
+
+// Unwrap the board result — the read-board agent may return the action
+// result wrapped in an envelope (e.g. {status, result: {data: {...}}})
+// instead of verbatim. We need ready_tasks at the top level.
+// Fails closed: unknown envelopes throw instead of silently producing no tasks.
+function unwrapBoardResult(boardResult) {
+  var boardData = boardResult;
+  // The read-board agent runs the CLI in shell and returns stdout. If it
+  // wraps the stdout in {"stdout": "<json string>"}, parse the inner JSON.
+  if (boardData && typeof boardData === 'object' && typeof boardData.stdout === 'string' && !Array.isArray(boardData.ready_tasks)) {
+    try {
+      var parsed = JSON.parse(boardData.stdout);
+      if (parsed && typeof parsed === 'object') {
+        boardData = parsed;
+      }
+    } catch (e) {
+      // Fall through to the fail-closed error below.
+    }
+  }
+  if (boardData && typeof boardData === 'object' && !Array.isArray(boardData.ready_tasks)) {
+    if (boardData.data && typeof boardData.data === 'object' && Array.isArray(boardData.data.ready_tasks)) {
+      boardData = boardData.data;
+    } else if (boardData.result && typeof boardData.result === 'object') {
+      var inner = boardData.result;
+      if (inner.data && typeof inner.data === 'object' && Array.isArray(inner.data.ready_tasks)) {
+        boardData = inner.data;
+      } else if (Array.isArray(inner.ready_tasks)) {
+        boardData = inner;
+      }
+    }
+  }
+  // The read-board agent may hand back the envelope with ready_tasks as a
+  // JSON string — {"ready_tasks": "<json string>"} — the get-dispatch-state
+  // stdout placed in the envelope instead of parsed (14:24 PDT tick,
+  // 2026-09-12). Parse it deterministically in JS: a string that parses to
+  // an array is used directly; a string that parses to an object is the
+  // whole board stdout, so re-run the unwrap on it. Unparseable or scalar
+  // strings fall through to the fail-closed throw below.
+  if (boardData && typeof boardData === 'object' && typeof boardData.ready_tasks === 'string') {
+    try {
+      var parsedReadyTasks = JSON.parse(boardData.ready_tasks);
+      if (Array.isArray(parsedReadyTasks)) {
+        boardData.ready_tasks = parsedReadyTasks;
+      } else if (parsedReadyTasks && typeof parsedReadyTasks === 'object') {
+        return unwrapBoardResult(parsedReadyTasks);
+      }
+    } catch (e) {
+      // Unparseable or scalar — fall through to fail-closed below.
+    }
+  }
+  // Fail closed: if we still don't have ready_tasks, the envelope is unknown.
+  // Silently returning [] would masquerade as "no tasks" — that's a lie.
+  if (!boardData || typeof boardData !== 'object' || !Array.isArray(boardData.ready_tasks)) {
+    throw new Error(
+      "unwrapBoardResult: unknown board envelope — expected ready_tasks at top level, " +
+      "in .data, in .result, in .result.data, or as a JSON string of a ready_tasks array " +
+      "or of a whole board object. Got keys: " +
+      (boardData && typeof boardData === 'object' ? Object.keys(boardData).join(",") : typeof boardData)
+    );
+  }
+  return boardData;
+}
+
+var boardData = unwrapBoardResult(parseBoardJson(boardReturn));
+const allTasks = boardData.ready_tasks.map(projectTaskRecord).filter(function (t) { return t !== null; });
+const config = boardData.config || {};
+const projects = boardData.projects || [];
 
 // Default project: explicit arg, or first registered project
 const DEFAULT_PROJECT = inputs.defaultProject || (projects.length > 0 ? projects[0].id : "");
@@ -252,6 +390,16 @@ for (var t = 0; t < allTasks.length; t++) {
     continue;
   }
 
+  // Skip tasks on projects with no repo configured. Dispatching them
+  // would fail closed in the workflow (no silent fallback to another
+  // checkout); skip here with the reason so the board shows why the
+  // task never moves. Set repo_path via updateproject to re-enable.
+  var taskProjCfg = PROJECTS[taskProject];
+  if (!taskProjCfg || !taskProjCfg.repo_path) {
+    log("Skipped \"" + task.title + "\" — project " + taskProject + " has no repo_path configured");
+    continue;
+  }
+
   var latest = task.latest_session;
   var workflow = task.workflow || "standard";
   var steps = WORKFLOWS[workflow] || WORKFLOWS.standard;
@@ -372,13 +520,17 @@ if (parkJobs.length > 0) {
     var pj = parkJobs[pji];
     log("Parking \"" + pj.task.title + "\" — " + pj.message);
     parkSteps.push(
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"parktask\", args: { \"task_id\": \"" + pj.task.id + "\", \"message\": " + JSON.stringify(pj.message) + " }."
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("park-task", { task_id: pj.task.id, message: pj.message })
     );
   }
   try {
+    // Fire-and-forget: the park side effects are the contract and the agent's
+    // return is discarded, so no schema. A schema on an unconsumed return is
+    // pure failure surface — validation can only abort a call whose result
+    // nobody reads.
     await agent(
       "Park " + parkJobs.length + " task(s) for human attention, in order:\n\n" + parkSteps.join("\n\n"),
-      { key: "park-batch", label: "Parking " + parkJobs.length + " task(s) at retry cap", schema: { type: "object" } }
+      { key: "park-batch", label: "Parking " + parkJobs.length + " task(s) at retry cap" }
     );
     log("Parked " + parkJobs.length + " task(s)");
   } catch (parkErr) {
@@ -472,12 +624,11 @@ if (eligible.length === 0) {
 
     var fileResult = await agent(
       "Advance the playtest cursors, then file the idle playtest task.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updateconfig\", args: { \"key\": \"playtest." + ptProject + ".journey_cursor\", \"value\": \"" + nextJ + "\" }.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updateconfig\", args: { \"key\": \"playtest." + ptProject + ".persona_cursor\", \"value\": \"" + nextP + "\" }.\n" +
-      "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"createtask\", args: { \"title\": \"" + safeTitle + "\", \"description\": \"SEE BELOW\", \"project\": \"" + ptProject + "\", \"workflow\": \"standard\", \"filed_by\": \"hazel\" }.\n" +
-      "For the description, use EXACTLY the following text (it is the playtest assignment — do not paraphrase):\n" +
-      "---DESCRIPTION START---\n" + safeDesc + "\n---DESCRIPTION END---\n" +
-      "Return { \"task_id\": \"<the created task's id>\" }. If createtask fails, return { \"task_id\": \"\" }.",
+      "Run each of these in shell, in order:\n" +
+      crewCmd("update-config", { key: "playtest." + ptProject + ".journey_cursor", value: String(nextJ) }) + "\n" +
+      crewCmd("update-config", { key: "playtest." + ptProject + ".persona_cursor", value: String(nextP) }) + "\n" +
+      crewCmd("create-task", { title: safeTitle, description: safeDesc, project: ptProject, workflow: "standard", filed_by: "hazel" }) + "\n" +
+      "Return { \"task_id\": \"<the created task's id from the create-task stdout JSON>\" }. If create-task fails, return { \"task_id\": \"\" }.",
       {
         key: "file-playtest",
         label: "Filing idle playtest",
@@ -555,11 +706,15 @@ for (var p = 0; p < toProcess.length; p++) {
   var isteps = WORKFLOWS[iworkflow] || WORKFLOWS.standard;
 
   if (item.action === "complete") {
+    // Fire-and-forget: the update-task/log-event side effects are the contract
+    // and the agent's return is discarded, so no schema. A schema here is pure
+    // failure surface — and it contradicts the "return the stdout verbatim"
+    // prompt, since verbatim stdout is a string that {type:"object"} rejects.
     await agent(
       "Mark task done and log completion.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updatetask\", args: { \"id\": \"" + itask.id + "\", \"state\": \"done\" }.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args: { \"task_id\": \"" + itask.id + "\", \"type\": \"completed\", \"message\": \"All workflow steps complete.\" }.",
-      { key: "done-" + itask.id, label: "Completing: " + itask.title, schema: { type: "object" } }
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", { id: itask.id, state: "done" }) + "\n" +
+      "Then run in shell and return the stdout verbatim:\n" + crewCmd("log-event", { task_id: itask.id, type: "completed", message: "All workflow steps complete." }),
+      { key: "done-" + itask.id, label: "Completing: " + itask.title }
     );
     results.push({ task_id: itask.id, action: "completed" });
     continue;
@@ -586,8 +741,11 @@ for (var p = 0; p < toProcess.length; p++) {
     rejection_notes: item.rejectionNotes || "",
     project_config: projectCfg,
     project_id: taskProject,
-    dashboardSlug: DASHBOARD_SLUG,
     crewHome: crewHome,
+    // Effective visual protocol for this run, resolved from the project's
+    // visual_protocol setting (null=inherits crew default=off). Workflows
+    // must not re-derive from project_config — the resolution lives here.
+    visual_protocol: effectiveVisualProtocol(projectCfg),
     // Facts the launched workflow needs to persist the resolution at claim time:
     // the workflow name the dispatcher actually resolved and is launching, and
     // whether the task record had no workflow (playtest filings carry explicit
@@ -606,9 +764,15 @@ for (var p = 0; p < toProcess.length; p++) {
 // Single acknowledge path: always ack, even when nothing was processed or
 // the per-poll cap deferred tasks. acknowledge_poll is idempotent (it only updates
 // last_poll_at), so a partial ack followed by a later tick's ack is harmless.
+// Fire-and-forget: the acknowledge-poll side effect is the whole contract and
+// the agent's return is discarded, so no schema. A schema here is pure failure
+// surface — and it contradicts the "return the stdout verbatim" prompt, since
+// verbatim stdout is a string that {type:"object"} rejects. (2026-09-11: the
+// agent returned the stdout as a string per the prompt, validation rejected it,
+// and the entire dispatcher aborted.)
 await agent(
-  "Acknowledge the poll.\nCall artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"acknowledge_poll\", args {}.",
-  { key: "ack", label: "Acknowledging poll", schema: { type: "object" } }
+  "Acknowledge the poll.\nRun in shell and return the stdout verbatim:\n" + crewCmd("acknowledge-poll", {}),
+  { key: "ack", label: "Acknowledging poll" }
 );
 
 var recommended = [];

package/workflows/crew-init.js

@@ -1,10 +1,9 @@
 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, set up cron jobs. Idempotent — safe to re-run.",
   phases: [
     { name: "release", title: "Bootstrap release system" },
     { name: "scaffold", title: "Scaffold orchestration directory" },
-    { name: "project", title: "Register dashboard project" },
     { name: "crons", title: "Create and converge cron jobs" }
   ]
 };
@@ -13,16 +12,89 @@ export const meta = {
 const inputs = args ?? {};
 const crewRepoPath = inputs.crewRepoPath;
 const crewHome = inputs.crewHome;
-const dashboardSlug = inputs.dashboardSlug;
-const dashboardName = inputs.dashboardName || "Muse Crew";
 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. ~/.crew");
-if (!dashboardSlug) throw new Error("dashboardSlug is required — create the dashboard artifact first, then pass its slug here");
+if (!crewHome) throw new Error("crewHome is required — e.g. ~/workspace/.crew (must be inside the workspace)");
 
 const orchDir = crewHome + "/.orchestration";
 
+// ── Gate 0: Launchable-path + repo validation ───────────────────────
+// workflow_launch only accepts workspace-contained scripts. A crewHome
+// outside the workspace would produce an instance whose workflows can
+// never launch (the Gate 1 canary's /home/hatch/.crew-canary-gate1
+// defect, 2026-09-11: workers resorted to changing, manually staged
+// 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).
+// 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,
+// 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.)
+function expandTilde(p, home) {
+  if (p === "~") return home;
+  if (p.indexOf("~/") === 0) return home + p.slice(1);
+  return p;
+}
+function gate0Decide(facts) {
+  // facts: { home, crewHomeExpanded, gitExitCode }
+  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 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" +
+    "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.",
+    {
+      key: "gate-0",
+      label: "Validate crew home",
+      schema: {
+        type: "object",
+        properties: {
+          home: { type: "string" },
+          crewHomeExpanded: { type: "string" },
+          gitExitCode: { type: "number" }
+        },
+        required: ["home", "crewHomeExpanded", "gitExitCode"]
+      }
+    }
+  );
+} catch (e) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Pre-init validation failed", message: String(e.message || e) } };
+}
+var gateResult = gate0Decide(gateFacts);
+if (!gateResult.launchable) {
+  return {
+    __hatchWorkflowControl: "blocked",
+    result: {
+      blocked_reason: "crewHome is not workspace-contained",
+      message: "crewHome must be inside the workspace (" + gateResult.workspace + ") because workflow_launch only accepts workspace-contained scripts. Requested: " + gateFacts.crewHomeExpanded + ". Pick a home like " + gateResult.workspace + "/.crew and re-run init."
+    }
+  };
+}
+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."
+    }
+  };
+}
+log("Gate 0: crewHome " + gateFacts.crewHomeExpanded + " is workspace-contained and a valid git repo");
+
 // ── Phase 1: Release ──────────────────────────────────────────────────
 phase("release");
 var releaseResult;
@@ -104,48 +176,9 @@ var scaffoldCreated = scaffoldResult.created ? scaffoldResult.created.length : 0
 var scaffoldSkipped = scaffoldResult.skipped ? scaffoldResult.skipped.length : 0;
 log("Scaffold: " + scaffoldCreated + " created, " + scaffoldSkipped + " skipped");
 
-// ── Phase 3: Register dashboard as project ────────────────────────────
-// The dashboard IS the project. Register it so the crew knows what to work on.
-phase("project");
-var projectResult;
-try {
-  projectResult = await agent(
-    "Register the dashboard as a project in its own database.\n\n" +
-    "Dashboard slug: " + dashboardSlug + "\n\n" +
-    "Steps:\n" +
-    "1. Call artifact_invoke_action with:\n" +
-    "   slug: '" + dashboardSlug + "'\n" +
-    "   action_name: 'createproject'\n" +
-    "   args: {\n" +
-    "     id: '" + dashboardSlug + "',\n" +
-    "     display_name: '" + dashboardName + "',\n" +
-    "     repo_path: '" + crewRepoPath + "',\n" +
-    "     deploy_type: 'artifact',\n" +
-    "     deploy_slug: '" + dashboardSlug + "',\n" +
-    "     description: 'The Muse Crew dashboard — task board, activity feed, and crew controls'\n" +
-    "   }\n" +
-    "2. Return { registered: true } on success.\n\n" +
-    "Return JSON with registered (boolean).",
-    {
-      key: "project-1",
-      label: "Register dashboard project",
-      schema: {
-        type: "object",
-        properties: {
-          registered: { type: "boolean" }
-        },
-        required: ["registered"]
-      }
-    }
-  );
-} catch (e) {
-  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Project registration failed", message: String(e.message || e) } };
-}
-log("Project: " + (projectResult.registered ? "registered" : "failed"));
-
-// ── Phase 4: Cron jobs (declarative manifest) ──────────────────────────
+// ── Phase 3: Cron jobs (declarative manifest) ──────────────────────────
 // The manifest lives in the repo at seed/crons.json. Body templates live
-// in seed/ with {crewHome}/{dashboardSlug} placeholders. Missing jobs are
+// 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.
 phase("crons");
@@ -155,7 +188,6 @@ try {
     "Ensure the Muse Crew cron jobs match the repo's declarative manifest.\n\n" +
     "Manifest: " + crewRepoPath + "/seed/crons.json\n" +
     "crewHome: " + crewHome + "\n" +
-    "Dashboard slug: " + dashboardSlug + "\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" +
@@ -165,14 +197,13 @@ try {
     "2. For each manifest entry, in order:\n" +
     "   a. The live id is the override for entry.id when present, else entry.id.\n" +
     "   b. Read the body template at " + crewRepoPath + "/seed/<entry.body_template>.\n" +
-    "   c. Replace all occurrences of {crewHome} with: " + crewHome + " and all\n" +
-    "      occurrences of {dashboardSlug} with: " + dashboardSlug + ".\n" +
+    "   c. Replace all occurrences of {crewHome} with: " + crewHome + ".\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: the entry's owner\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" +
@@ -231,10 +262,7 @@ log("Crons: " + cronsResult.summary.crons.map(function (c) { return c.id + "=" +
 return {
   message: "Muse Crew initialized.",
   crewHome: crewHome,
-  dashboardSlug: dashboardSlug,
-  dashboardName: dashboardName,
   releaseHash: releaseResult.hash,
   scaffold: { created: scaffoldCreated, skipped: scaffoldSkipped },
-  project: projectResult.registered ? "registered" : "failed",
   crons: cronsResult.summary.crons
 };