muse-crew 0.1.0

package/workflows/chore.js

@@ -0,0 +1,294 @@
+export const meta = {
+  name: "crew-chore",
+  description: "Chore workflow: Triage → Map → Build → Review → Integrate → Deploy",
+  phases: ["Triage", "Map", "Build", "Review", "Integrate", "Deploy"],
+  steps: [
+    { name: "Triage", identity: "sage" },
+    { name: "Map", identity: "mara" },
+    { name: "Build", identity: "wren" },
+    { name: "Review", identity: "cass" },
+    { name: "Integrate", identity: "wren" },
+    { name: "Deploy", identity: "wren" }
+  ],
+  reworkTarget: "Build"
+};
+
+const inputs = args ?? {};
+const taskId = inputs.task_id;
+const taskTitle = inputs.task_title || "";
+const taskDescription = inputs.task_description || "";
+const firstSessionId = inputs.session_id || null;
+const startStepIndex = inputs.start_step_index || 0;
+
+// Config from args — backward-compatible fallbacks for manual launches
+const DASHBOARD_SLUG = inputs.dashboardSlug || "orchestra-dashboard";
+const crewHome = inputs.crewHome || "~/workspace/.jarvis";
+const ORCH_PATH = crewHome + "/.orchestration";
+// Pin lifecycle scripts to this run
+const LIFECYCLE_SRC = crewHome + "/lib/worktree-lifecycle.sh";
+const MERGE_LOCK_SRC = crewHome + "/lib/merge-lock.sh";
+const RUN_LIB = "/tmp/crew-lib-" + taskId;
+const LIFECYCLE = RUN_LIB + "/worktree-lifecycle.sh";
+const MERGE_LOCK = RUN_LIB + "/merge-lock.sh";
+
+// Project config — passed by dispatcher, falls back to dashboard defaults
+const projectConfig = inputs.project_config || {};
+const REPO_PATH = projectConfig.repo_path || "~/workspace/ts-spaces/orchestra-dashboard";
+const DEPLOY_TYPE = projectConfig.deploy_type || "artifact";
+const DEPLOY_SLUG = projectConfig.deploy_slug || DASHBOARD_SLUG;
+const PROJECT_DESC = projectConfig.description || "React + TypeScript web dashboard (client/src/, server/src/, drizzle/)";
+const RELEASE_SCRIPT = crewHome + "/crew-release.sh";
+
+if (!taskId) {
+  throw new Error("task_id is required in args");
+}
+
+// Work-agent result schema. Runtime retries on non-JSON (structured outputs).
+// Workflow wraps in try/catch so exhausted retries block instead of crashing.
+const WORK_SCHEMA = {
+  type: "object",
+  properties: { passed: { type: "boolean" }, summary: { type: "string" } },
+  required: ["passed", "summary"]
+};
+
+// STEPS inline — export const meta is parsed as metadata, not a runtime binding
+const STEPS = [
+  { name: "Triage", identity: "sage" },
+  { name: "Map", identity: "mara" },
+  { name: "Build", identity: "wren" },
+  { name: "Review", identity: "cass" },
+  { name: "Integrate", identity: "wren" },
+  { name: "Deploy", identity: "wren" }
+];
+const BUILD_INDEX = STEPS.findIndex(s => s.name === 'Build');
+if (BUILD_INDEX < 0) throw new Error("STEPS missing 'Build' step");
+const MAX_REWORK = 2;
+let reworkCount = 0;
+let rejectionNotes = inputs.rejection_notes || "";
+let mapperSpec = "";
+let i = startStepIndex;
+
+// Pin lifecycle scripts
+await agent(
+  "Snapshot lifecycle scripts for version pinning.\n" +
+  "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK,
+  { key: "pin-lifecycle", label: "Pinning lifecycle scripts", schema: { type: "object" } }
+);
+
+while (i < STEPS.length) {
+  const step = STEPS[i];
+  const isFirstClaim = (i === startStepIndex && reworkCount === 0);
+
+  phase(step.name);
+  log(step.name + " step (" + step.identity + ") for task " + taskId);
+
+  let activeSessionId;
+  if (isFirstClaim && firstSessionId) {
+    activeSessionId = firstSessionId;
+  } else {
+    const claimResult = await agent(
+      "Claim a session for this task step.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"claimtask\", args:\n" +
+      "{ \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"notes\": \"" + step.name + " step started" + (reworkCount > 0 ? " (rework #" + reworkCount + ")" : "") + "\" }.\n" +
+      "Return the session_id from the response.",
+      {
+        key: "claim-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : ""),
+        label: "Claiming " + step.name,
+        schema: {
+          type: "object",
+          properties: { session_id: { type: "string" } },
+          required: ["session_id"]
+        }
+      }
+    );
+    activeSessionId = claimResult.session_id;
+  }
+
+  var safeTitle = taskTitle.replace(/"/g, "'").replace(/\\/g, "\\\\").replace(/`/g, "'");
+  var instructions = "";
+
+  if (step.name === "Triage") {
+    instructions = "Validate the task, check clarity, note dependencies, confirm the chore workflow assignment.\nYour final response MUST be valid JSON and nothing else: { \"summary\": \"your assessment\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+
+  } else if (step.name === "Map") {
+    instructions = "Research options, pick the path, write a clear spec for the builder.\nThe builder will edit source files in a git worktree of the project at " + REPO_PATH + ".\nProject: " + PROJECT_DESC + "\nTo understand the current code, read source files directly using the read tool. Do NOT use artifact_inspect — it is async and will not return in time.\nIdentify the exact files and changes needed. Be specific: file paths, what to add or change.\nYour final response MUST be valid JSON and nothing else: { \"summary\": \"what you specified\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+
+  } else if (step.name === "Build") {
+    instructions = "STEP 1: Prepare your worktree.\n" +
+      "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " prepare " + taskId + "\n" +
+      "If the output says CREATED or REUSED, proceed. If it says ERROR, stop and set passed to false.\n\n" +
+      "STEP 2: Edit source files to implement the mapper's spec below.\n" +
+      (mapperSpec ? "MAPPER'S SPEC (implement exactly this):\n" + mapperSpec + "\n\n" : "") +
+      "Your working directory: " + REPO_PATH + "/.worktrees/" + taskId + "/\n" +
+      "This is the project source: " + PROJECT_DESC + "\n" +
+      "Edit the TypeScript source files directly. Do NOT use artifact_edit — that happens in the Deploy phase.\n" +
+      "Do not add unrequested features.\n\n" +
+      "STEP 3: Commit your changes.\n" +
+      "cd " + REPO_PATH + "/.worktrees/" + taskId + "\n" +
+      "git add -A\n" +
+      "git commit -m \"chore: " + safeTitle + "\"\n\n" +
+      (rejectionNotes ? "REWORK after rejection. Address:\n" + rejectionNotes + "\n\n" : "") +
+      "Your final response MUST be valid JSON and nothing else: { \"summary\": \"what you built\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+
+  } else if (step.name === "Review") {
+    instructions = "Review independently and cold. No prior context from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
+      (mapperSpec ? "MAPPER'S SPEC (the builder was asked to implement exactly this):\n" + mapperSpec + "\n\n" : "Read the spec from the task description.\n\n") +
+      "Examine the code changes by running:\n" +
+      "CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " inspect " + taskId + "\n\n" +
+      "You can also read specific files in the worktree at:\n" +
+      REPO_PATH + "/.worktrees/" + taskId + "/\n\n" +
+      "Check quality, correctness, spec compliance.\n" +
+      "If it passes, your final response MUST be valid JSON and nothing else: { \"passed\": true, \"summary\": \"approval notes\" }.\n" +
+      "If it fails, your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"rejection notes\" }.\n" +
+      "No prose, no markdown, just the JSON object.";
+
+  } else if (step.name === "Integrate") {
+    instructions = "Merge the approved task branch into main.\n\n" +
+      "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " integrate " + taskId + " \"merge: chore: " + safeTitle + "\"\n\n" +
+      "Read the output:\n" +
+      "- If it contains MERGED, integration succeeded. Report the merged commit hash.\n" +
+      "- If it contains LOCK_HELD, another task is deploying. Set passed to false.\n" +
+      "- If it contains CONFLICT, a merge conflict occurred. Set passed to false with details.\n" +
+      "- If it contains ERROR, something else failed. Set passed to false.\n\n" +
+      "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true/false }. No prose, no markdown, just the JSON object.";
+
+  } else if (step.name === "Deploy") {
+    if (DEPLOY_TYPE === "repo") {
+      // Repo projects: install immutable release and atomically activate
+      instructions = "Deploy repo changes via the immutable release system.\n\n" +
+        "STEP 0: Refresh the merge lock to prevent stale-lock breaking during deploy.\n" +
+        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " refresh-lock " + taskId + "\n\n" +
+        "STEP 1: Install and activate the new release.\n" +
+        "Run: " + RELEASE_SCRIPT + " deploy " + REPO_PATH + "\n" +
+        "Verify the output contains INSTALLED and ACTIVATED (or EXISTS and ACTIVATED if unchanged).\n\n" +
+        "STEP 2: Finalize.\n" +
+        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
+        "If the output contains DEPLOYED, finalization is complete.\n\n" +
+        "Your final response MUST be valid JSON and nothing else: { \"summary\": \"release activated and finalized\", \"passed\": true }.\n" +
+        "No prose, no markdown, just the JSON object.";
+    } else {
+      instructions = "Deploy the merged code to the live artifact.\n\n" +
+        "STEP 0: Refresh the merge lock to prevent stale-lock breaking during deploy.\n" +
+        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " refresh-lock " + taskId + "\n\n" +
+        "STEP 1: Deploy to the live artifact.\n" +
+        "Get the change summary: cd " + REPO_PATH + " && git log -1 --stat\n" +
+        "Then call artifact_edit with slug \"" + DEPLOY_SLUG + "\" and verbatim_request:\n" +
+        "'Rebuild the application from current source. Do not modify any source files — just rebuild and deploy what is on disk.'\n" +
+        "Wait for the build to complete by polling artifact_status until it is no longer running.\n\n" +
+        "STEP 2: Finalize.\n" +
+        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
+        "If the output contains DEPLOYED, deployment is complete.\n\n" +
+        "If artifact_edit failed, still run post-deploy to release the merge lock and clean up.\n" +
+        "Report the failure: { \"passed\": false, \"summary\": \"artifact deployment failed: [details]\" }.\n\n" +
+        "Your final response MUST be valid JSON and nothing else: { \"summary\": \"deployed changes\", \"passed\": true }.\n" +
+        "No prose, no markdown, just the JSON object.";
+    }
+  }
+
+  // Task event history — all phases except Review see the comment log
+  var eventPreamble = "";
+  if (step.name !== "Review") {
+    eventPreamble = "CONTEXT: First, fetch this task's event history for background.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getevents\", args: { \"limit\": 100 }.\n" +
+      "Look through returned events for entries matching task_id \"" + taskId + "\". They contain notes and decisions from prior phases.\n\n";
+  }
+
+  var stepResult;
+  try {
+    stepResult = await agent(
+    "Read the identity file at " + ORCH_PATH + "/identities/" + step.identity + ".md using the read tool, and embody that character fully.\n\n" +
+    "## Your Assignment\n\n" +
+    "Task: " + taskTitle + "\nTask ID: " + taskId + "\nDescription: " + taskDescription + "\nStep: " + step.name + "\n" +
+    (step.name !== "Review" ? "Dashboard slug: " + DASHBOARD_SLUG + "\n" : "") +
+    "\n## Instructions\n\n" + eventPreamble + instructions + "\n\nCONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\nStay in character. Do the work thoroughly.",
+    {
+      key: "work-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : ""),
+      label: step.identity + ": " + step.name + " on \"" + taskTitle + "\"",
+      timeoutMs: 3600000,
+      schema: WORK_SCHEMA
+    }
+    );
+  } catch (e) {
+    log(step.name + " agent failed: " + (e.message || String(e)).slice(0, 500));
+    stepResult = null;
+  }
+
+  // If schema retries were exhausted, block gracefully
+  if (!stepResult || typeof stepResult.summary !== "string") {
+    log(step.name + " closeout unrecoverable — blocking");
+    await agent(
+      "Record closeout failure.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+      "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"blocked\", \"notes\": \"Agent failed to return structured result after retries\" }.\n" +
+      "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+      "{ \"task_id\": \"" + taskId + "\", \"type\": \"blocked\", \"message\": \"" + step.name + " agent failed after retries — workflow blocked\" }.",
+      { key: "record-block-" + step.name, label: "Recording closeout failure", schema: { type: "object" } }
+    );
+    return {
+      __hatchWorkflowControl: "blocked",
+      result: {
+        blocked_reason: step.name + " agent failed after retries",
+        message: "The " + step.identity + " agent's work may be valid — structured output failed.",
+        task_id: taskId
+      }
+    };
+  }
+
+  const summary = (stepResult.summary || "Step completed").slice(0, 2000);
+  const passed = stepResult.passed !== false;
+  const status = passed ? "completed" : "rejected";
+
+  // Capture mapper's spec for Build and Review
+  if (step.name === "Map" && passed) {
+    mapperSpec = summary;
+  }
+
+  await agent(
+    "Update session and log event.\n" +
+    "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+    "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"" + status + "\", \"notes\": " + JSON.stringify(summary) + " }.\n" +
+    "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+    "{ \"task_id\": \"" + taskId + "\", \"type\": \"" + status + "\", \"identity\": \"" + step.identity + "\", \"message\": \"" + step.name + " " + status + " by " + step.identity + "\" }.",
+    {
+      key: "record-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : ""),
+      label: "Recording " + step.name + " result",
+      schema: { type: "object" }
+    }
+  );
+
+  if (!passed && step.name === "Review") {
+    reworkCount++;
+    if (reworkCount > MAX_REWORK) {
+      log("Max rework attempts reached for task " + taskId + " — worktree preserved at .worktrees/" + taskId + " for manual inspection");
+      return { status: "blocked", task_id: taskId, reason: "Exceeded " + MAX_REWORK + " rework attempts after Review rejection. Worktree preserved." };
+    }
+    rejectionNotes = summary;
+    i = BUILD_INDEX;
+    log("Review rejected — bouncing to Build (rework #" + reworkCount + ")");
+    continue;
+  }
+
+  if (!passed && step.name === "Integrate") {
+    log("Integration failed for task " + taskId + ": " + summary);
+    return { status: "blocked", task_id: taskId, reason: "Integration failed: " + summary };
+  }
+
+  if (!passed && step.name === "Deploy") {
+    log("Deploy failed for task " + taskId + ": " + summary);
+    return { status: "blocked", task_id: taskId, reason: "Deploy failed: " + summary };
+  }
+
+  i++;
+}
+
+await agent(
+  "Mark this task as done.\n" +
+  "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updatetask\", args: { \"id\": \"" + taskId + "\", \"state\": \"done\" }.\n" +
+  "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+  "{ \"task_id\": \"" + taskId + "\", \"type\": \"completed\", \"message\": \"All chore workflow steps complete.\" }.",
+  { key: "task-done", label: "Completing task: " + taskTitle, schema: { type: "object" } }
+);
+
+log("Chore workflow complete for task " + taskId);
+await agent("Clean up pinned lifecycle scripts: rm -rf " + RUN_LIB, { key: "cleanup-pins", label: "Cleaning pinned scripts", schema: { type: "object" } });
+return { status: "ok", task_id: taskId, message: "Chore workflow complete for " + taskTitle };

package/workflows/crew-dispatch.js

@@ -0,0 +1,315 @@
+export const meta = {
+  name: "crew-dispatch",
+  description: "Thin Muse Crew dispatcher — reads the board, claims eligible tasks, launches the right workflow script per task.",
+  phases: ["dispatch"]
+};
+
+// 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");
+const WORKFLOW_DIR = crewHome + "/workflows";
+
+// Project config is built from dashboard project records (getdispatchstate)
+// — no separate registry file needed.
+
+// Load canonical step definitions from workflow files (single source of truth)
+const registryResult = await agent(
+  "Read the following 4 workflow files using the read tool and extract the `steps` array and `reworkTarget` string from each file's `export const meta` block at the top of the file.\n\n" +
+  "Files:\n" +
+  "1. " + WORKFLOW_DIR + "/standard.js\n" +
+  "2. " + WORKFLOW_DIR + "/bugfix.js\n" +
+  "3. " + WORKFLOW_DIR + "/chore.js\n" +
+  "4. " + WORKFLOW_DIR + "/docs.js\n\n" +
+  "Return an object with keys: standard, bugfix, chore, docs. Each value has { steps: [{name, identity}], reworkTarget: string }.",
+  {
+    key: "load-registry",
+    label: "Loading workflow step registry",
+    schema: {
+      type: "object",
+      properties: {
+        standard: { type: "object" },
+        bugfix: { type: "object" },
+        chore: { type: "object" },
+        docs: { type: "object" }
+      },
+      required: ["standard", "bugfix", "chore", "docs"]
+    }
+  }
+);
+
+// Derive lookup tables from canonical definitions
+const WORKFLOWS = {};
+const STEP_IDENTITY = {};
+const BUILD_STEPS = {};
+var wfNames = ["standard", "bugfix", "chore", "docs"];
+for (var wi = 0; wi < wfNames.length; wi++) {
+  var wfName = wfNames[wi];
+  var wfData = registryResult[wfName];
+  WORKFLOWS[wfName] = wfData.steps.map(function(s) { return s.name; });
+  BUILD_STEPS[wfName] = wfData.reworkTarget;
+  for (var si = 0; si < wfData.steps.length; si++) {
+    STEP_IDENTITY[wfData.steps[si].name] = wfData.steps[si].identity;
+  }
+}
+
+phase("dispatch");
+
+// ── 1. Read the board ────────────────────────────────────────────────
+const boardResult = await agent(
+  "Read the dispatch state.\n" +
+  "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getdispatchstate\", args {}.\n" +
+  "Return the full JSON response — ready_tasks array, projects array, config object, counts object.",
+  {
+    key: "read-board",
+    label: "Reading board state",
+    schema: {
+      type: "object",
+      properties: {
+        ready_tasks: { type: "array" },
+        projects: { type: "array" },
+        config: { type: "object" },
+        counts: { type: "object" }
+      },
+      required: ["ready_tasks"]
+    }
+  }
+);
+
+const allTasks = boardResult.ready_tasks || [];
+const config = boardResult.config || {};
+const projects = boardResult.projects || [];
+
+// Default project: explicit arg, or first registered project
+const DEFAULT_PROJECT = inputs.defaultProject || (projects.length > 0 ? projects[0].id : "");
+
+// Per-project quiesce: build a set of quiesced project IDs
+const quiescedProjects = {};
+for (var qi = 0; qi < projects.length; qi++) {
+  if (projects[qi].quiesced) {
+    quiescedProjects[projects[qi].id] = true;
+  }
+}
+
+// Per-project simultaneity: build a map, fall back to global config
+// Explicit 0 means "paused" — do not destroy it with || fallback
+const projectSimultaneity = {};
+for (var si = 0; si < projects.length; si++) {
+  var rawSim = Number(projects[si].simultaneity);
+  projectSimultaneity[projects[si].id] = isNaN(rawSim) ? 2 : rawSim;
+}
+var rawGlobal = Number(config.simultaneity);
+const globalSimultaneity = isNaN(rawGlobal) ? 1 : rawGlobal;
+
+// Build project config map from dashboard records (single source of truth)
+var PROJECTS = {};
+for (var pi = 0; pi < projects.length; pi++) {
+  var proj = projects[pi];
+  PROJECTS[proj.id] = {
+    repo_path: proj.repo_path,
+    deploy_type: proj.deploy_type,
+    deploy_slug: proj.deploy_slug,
+    description: proj.description
+  };
+}
+
+log("Board: " + allTasks.length + " active tasks, quiesced=" + Object.keys(quiescedProjects).join(","));
+
+// ── 2. Determine eligible tasks ──────────────────────────────────────
+const eligible = [];
+
+for (var t = 0; t < allTasks.length; t++) {
+  var task = allTasks[t];
+  if (task.blocked) continue;
+
+  // Skip tasks from quiesced projects
+  var taskProject = task.project || DEFAULT_PROJECT;
+  if (quiescedProjects[taskProject]) {
+    log("Skipped \"" + task.title + "\" — project " + taskProject + " is quiesced");
+    continue;
+  }
+
+  var latest = task.latest_session;
+  var workflow = task.workflow || "standard";
+  var steps = WORKFLOWS[workflow] || WORKFLOWS.standard;
+
+  if (task.state === "todo") {
+    eligible.push({ task: task, startStep: 0, reason: "new", workflow: workflow });
+    continue;
+  }
+
+  if (task.state !== "in_progress") continue;
+
+  if (!latest) {
+    eligible.push({ task: task, startStep: 0, reason: "no_session", workflow: workflow });
+    continue;
+  }
+
+  if (latest.status === "running") continue; // work in flight
+
+  if (latest.status === "completed") {
+    var stepName = latest.step || "";
+    var stepIndex = steps.indexOf(stepName);
+    var nextIndex = stepIndex + 1;
+
+    if (nextIndex >= steps.length) {
+      eligible.push({ task: task, action: "complete", workflow: workflow });
+    } else {
+      eligible.push({ task: task, startStep: nextIndex, reason: "next_step", workflow: workflow });
+    }
+    continue;
+  }
+
+  if (latest.status === "rejected") {
+    var buildStepName = BUILD_STEPS[workflow] || "Build";
+    var buildIdx = steps.indexOf(buildStepName);
+    if (buildIdx >= 0) {
+      eligible.push({ task: task, startStep: buildIdx, reason: "rework", workflow: workflow, rejectionNotes: latest.notes || "" });
+    }
+    continue;
+  }
+
+  if (latest.status === "failed" || latest.status === "timed_out") {
+    var failedStep = latest.step || "";
+    var retryIdx = steps.indexOf(failedStep);
+    eligible.push({ task: task, startStep: retryIdx >= 0 ? retryIdx : 0, reason: "retry", workflow: workflow });
+    continue;
+  }
+}
+
+log("Eligible: " + eligible.length + " tasks");
+
+if (eligible.length === 0) {
+  await agent(
+    "Acknowledge the poll.\nCall artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"acknowledge_poll\", args {}.",
+    { key: "ack-empty", label: "Acknowledging poll (nothing to do)", schema: { type: "object" } }
+  );
+  return { status: "ok", message: "No tasks ready." };
+}
+
+// ── 3. Process eligible tasks, respecting per-project simultaneity ───
+// Count in-flight tasks per project to enforce per-project limits
+var inFlightByProject = {};
+for (var ct = 0; ct < allTasks.length; ct++) {
+  var ctask = allTasks[ct];
+  if (ctask.state === "in_progress" && ctask.latest_session && ctask.latest_session.status === "running") {
+    var cp = ctask.project || DEFAULT_PROJECT;
+    inFlightByProject[cp] = (inFlightByProject[cp] || 0) + 1;
+  }
+}
+
+var toProcess = [];
+for (var ei = 0; ei < eligible.length; ei++) {
+  var eitem = eligible[ei];
+  var ep = eitem.task.project || DEFAULT_PROJECT;
+  var limit = (ep in projectSimultaneity) ? projectSimultaneity[ep] : globalSimultaneity;
+  var current = inFlightByProject[ep] || 0;
+  if (current < limit) {
+    toProcess.push(eitem);
+    inFlightByProject[ep] = current + 1;
+  } else {
+    log("Skipped \"" + eitem.task.title + "\" — project " + ep + " at simultaneity limit (" + limit + ")");
+  }
+}
+var results = [];
+
+for (var p = 0; p < toProcess.length; p++) {
+  var item = toProcess[p];
+  var itask = item.task;
+  var iworkflow = item.workflow;
+  var isteps = WORKFLOWS[iworkflow] || WORKFLOWS.standard;
+
+  if (item.action === "complete") {
+    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" } }
+    );
+    results.push({ task_id: itask.id, action: "completed" });
+    continue;
+  }
+
+  var nextStepName = isteps[item.startStep];
+  var identity = STEP_IDENTITY[nextStepName] || "sage";
+
+  // Set to in_progress if todo
+  if (itask.state === "todo") {
+    await agent(
+      "Set task to in_progress.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updatetask\", args: { \"id\": \"" + itask.id + "\", \"state\": \"in_progress\" }.",
+      { key: "activate-" + itask.id, label: "Activating: " + itask.title, schema: { type: "object" } }
+    );
+  }
+
+  // Atomic claim — check response before proceeding
+  var claimResult = await agent(
+    "Claim the task for the " + nextStepName + " step.\n" +
+    "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"claimtask\", args:\n" +
+    "{ \"task_id\": \"" + itask.id + "\", \"identity\": \"" + identity + "\", \"step\": \"" + nextStepName + "\", \"notes\": \"" + nextStepName + " step started\" }.\n" +
+    "Check the response. If the task was successfully claimed (a new session was created), return { claimed: true, session_id: \"<the new session id>\" }.\n" +
+    "If the task was already claimed by another tick (already has a running session), return { claimed: false, session_id: \"\" }.",
+    {
+      key: "claim-" + itask.id,
+      label: "Claiming " + nextStepName + " for: " + itask.title,
+      schema: {
+        type: "object",
+        properties: {
+          claimed: { type: "boolean" },
+          session_id: { type: "string" }
+        },
+        required: ["claimed", "session_id"]
+      }
+    }
+  );
+
+  if (!claimResult.claimed) {
+    log("Skipped \"" + itask.title + "\" — already claimed by another tick");
+    results.push({ task_id: itask.id, action: "skipped" });
+    continue;
+  }
+
+  // Return claim for the caller to launch (workflows can't launch workflows)
+  var scriptPath = WORKFLOW_DIR + "/" + iworkflow + ".js";
+  var taskProject = itask.project || DEFAULT_PROJECT;
+  var projectCfg = PROJECTS[taskProject] || PROJECTS[DEFAULT_PROJECT];
+  var launchArgs = {
+    task_id: itask.id,
+    task_title: itask.title || "",
+    task_description: itask.description || "",
+    session_id: claimResult.session_id,
+    start_step_index: item.startStep,
+    rejection_notes: item.rejectionNotes || "",
+    project_config: projectCfg,
+    dashboardSlug: DASHBOARD_SLUG,
+    crewHome: crewHome
+  };
+
+  log("Claimed " + iworkflow + " for \"" + itask.title + "\" at step " + nextStepName);
+  results.push({ task_id: itask.id, workflow: iworkflow, step: nextStepName, action: "claimed", scriptPath: scriptPath, args: launchArgs });
+}
+
+// ── 4. Acknowledge ───────────────────────────────────────────────────
+await agent(
+  "Acknowledge the poll.\nCall artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"acknowledge_poll\", args {}.",
+  { key: "ack-final", label: "Acknowledging poll", schema: { type: "object" } }
+);
+
+var claimed = results.filter(function(r) { return r.action === "claimed"; });
+var completed = results.filter(function(r) { return r.action === "completed"; });
+var msg = "Dispatch complete.";
+if (claimed.length > 0) {
+  msg += " Claimed: " + claimed.map(function(r) { return r.workflow + "/" + r.step + " for " + r.task_id; }).join(", ") + ".";
+}
+if (completed.length > 0) {
+  msg += " Completed: " + completed.map(function(r) { return r.task_id; }).join(", ") + ".";
+}
+var skipped = results.filter(function(r) { return r.action === "skipped"; });
+if (skipped.length > 0) {
+  msg += " Skipped (already claimed): " + skipped.length + ".";
+}
+
+return { status: "ok", message: msg, claims: claimed };