muse-crew 0.4.3 → 0.4.5

package/workflows/crew-dispatch.js

@@ -1,6 +1,6 @@
 export const meta = {
   name: "crew-dispatch",
-  description: "Thin Muse Crew dispatcher — reads the board, claims eligible tasks, launches the right workflow script per task.",
+  description: "Thin Muse Crew dispatcher — reads the board, recommends eligible tasks, returns structured launch records for the caller to launch (workflows can't launch workflows).",
   phases: ["dispatch"]
 };
 
@@ -16,34 +16,49 @@ 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"]
+// 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
+// timing is unavailable in workflow scripts (Date.now() is forbidden for
+// deterministic replay), so a task-count cap is the mechanical bound.
+// Overridable via inputs for QA probing.
+const MAX_TASKS_PER_POLL = inputs.maxTasksPerPoll || 6;
+
+// Workflow step registry: static per release. The poll cron body reads
+// <crewHome>/workflows/registry.json (generated at release time from the
+// workflow files, which stay the single source of truth) and passes it as
+// inputs.registry. Fall back to the agent() load only when the caller
+// predates the registry — slow, but never broken.
+var registryResult = inputs.registry;
+if (!registryResult) {
+  log("WARNING: no registry in args — falling back to slow registry load");
+  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++) {
@@ -51,9 +66,6 @@ for (var wi = 0; wi < wfNames.length; 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");
@@ -62,7 +74,12 @@ phase("dispatch");
 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.",
+  "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" +
+  "}",
   {
     key: "read-board",
     label: "Reading board state",
@@ -71,8 +88,7 @@ const boardResult = await agent(
       properties: {
         ready_tasks: { type: "array" },
         projects: { type: "array" },
-        config: { type: "object" },
-        counts: { type: "object" }
+        config: { type: "object" }
       },
       required: ["ready_tasks"]
     }
@@ -83,10 +99,8 @@ const allTasks = boardResult.ready_tasks || [];
 const config = boardResult.config || {};
 const projects = boardResult.projects || [];
 
-// Default project: explicit arg wins, then the dashboard's configured default
-// project (config.default_project — set by crew-init or the dashboard UI),
-// then the first registered project as a last resort.
-const DEFAULT_PROJECT = inputs.defaultProject || config.default_project || (projects.length > 0 ? projects[0].id : "");
+// 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 = {};
@@ -120,8 +134,112 @@ for (var pi = 0; pi < projects.length; pi++) {
 
 log("Board: " + allTasks.length + " active tasks, quiesced=" + Object.keys(quiescedProjects).join(","));
 
+// ── Idle playtesting helpers ─────────────────────────────────────────
+// A playtest is an ordinary board task (filed_by "hazel") whose title starts
+// with PLAYTEST_PREFIX. The filing carries the full assignment (journey +
+// persona + filings cap), so a playtest always enters its workflow at QA.
+const PLAYTEST_PREFIX = "Idle playtest: ";
+
+function isPlaytestTask(t) {
+  return !!t && typeof t.title === "string" && t.title.indexOf(PLAYTEST_PREFIX) === 0;
+}
+
+function qaStepIndex(workflowName) {
+  var steps = WORKFLOWS[workflowName] || WORKFLOWS.standard;
+  var idx = steps.indexOf("QA");
+  return idx >= 0 ? idx : 0;
+}
+
+// Roster format: a markdown string; each "## <name>" section is one journey
+// (heading = journey name, body = the steps to walk). Returns [{name, body}].
+function parseJourneys(md) {
+  var journeys = [];
+  if (!md || !String(md).trim()) return journeys;
+  var lines = String(md).split("\n");
+  var cur = null;
+  for (var i = 0; i < lines.length; i++) {
+    var m = lines[i].match(/^##\s+(.+?)\s*$/);
+    if (m) {
+      if (cur) { cur.body = cur.body.trim(); journeys.push(cur); }
+      cur = { name: m[1], body: "" };
+    } else if (cur) {
+      cur.body += lines[i] + "\n";
+    }
+  }
+  if (cur) { cur.body = cur.body.trim(); journeys.push(cur); }
+  return journeys.filter(function (j) { return j.name.length > 0; });
+}
+
+function configInt(cfg, key, fallback) {
+  var n = parseInt(cfg[key], 10);
+  return isNaN(n) ? fallback : n;
+}
+
+// Pure: unit-testable. Decides park vs retry from the dashboard's explicit
+// retry state (task.retry.consecutive_failures, computed deterministically
+// server-side). Missing/invalid state fails open to "retry" — a dashboard
+// that predates the retry field must not strand a task. A non-positive cap
+// disables the cap entirely (unbounded retries).
+function decideRetry(consecutiveFailures, maxFailures) {
+  if (!(maxFailures > 0)) return "retry";
+  if (typeof consecutiveFailures !== "number" || consecutiveFailures < 0) return "retry";
+  return consecutiveFailures >= maxFailures ? "park" : "retry";
+}
+
+function buildPlaytestDescription(journey, personaName, personaFile, maxFilings) {
+  var filingRule = maxFilings === 0
+    ? "File no follow-up tasks on this run (max_filings is 0). Note anything you find in your summary instead."
+    : "File follow-up tasks for real issues you find: at most " + maxFilings + " on this run (max_filings). If you find more, note the extras in your summary.";
+  var body = journey.body.length > 3000 ? journey.body.slice(0, 3000) + "\n[truncated]" : journey.body;
+  return (
+    "IDLE PLAYTEST — this task carries no code change. You are Hazel, code-blind QA.\n" +
+    "\n" +
+    "Assignment: journey \"" + journey.name + "\" as the \"" + personaName + "\" persona.\n" +
+    "Persona file: " + crewHome + "/.orchestration/personas/" + personaFile + " — read it first and wear that perspective for the whole run.\n" +
+    "\n" +
+    "Journey:\n" + body + "\n" +
+    "\n" +
+    "Rules:\n" +
+    "- Walk the journey end to end from a user's perspective, wearing the persona.\n" +
+    "- Use the normal QA surface for this project (visual inspection via artifact_inspect for artifact projects; read-only dashboard API checks otherwise).\n" +
+    "- There is no code change under test: skip change-verification steps (provenance / publish checks) and judge only what you observe.\n" +
+    "- " + filingRule + "\n" +
+    "- File via the existing createtask action with filed_by \"hazel\": set workflow to \"standard\" when the fix is clear feature work, or omit workflow (untriaged) when unsure — triage routes untriaged filings to bugfix/feature as usual.\n"
+  ).slice(0, 4800);
+}
+
 // ── 2. Determine eligible tasks ──────────────────────────────────────
 const eligible = [];
+const retryCandidates = [];
+const rejectionCandidates = [];
+
+// ── Retry cap ────────────────────────────────────────────────────────
+// Symphony owns phase-redispatch policy (coordination layer): the spec
+// defines backoff but no attempt cap ("implementation-defined"), so the
+// dispatcher defines it here. After MAX_CONSECUTIVE_FAILURES consecutive
+// failed/timed_out sessions for the same step, the task is parked for
+// human attention instead of retried forever. The count is explicit
+// dashboard-owned state (task.retry.consecutive_failures from
+// getdispatchstate) — the dispatcher never projects history and never
+// parses event messages. Parked tasks leave getdispatchstate's ready set,
+// so the park happens exactly once; parked → todo is the designed human
+// decision point, and the dashboard stamps retry_reset_at on that
+// transition so the streak restarts mechanically on re-queue.
+// Overridable via dashboard config key "maxConsecutiveFailures";
+// 0 or negative disables the cap (pre-cap behavior: unbounded retries).
+var MAX_CONSECUTIVE_FAILURES = configInt(config, "maxConsecutiveFailures", 3);
+
+// ── Rejection budget ─────────────────────────────────────────────────
+// Review/QA rejections route through rework, but the workflow's in-run
+// rework counter resets every tick — a rejecting Review plus a flaky Build
+// can cycle forever across ticks, evading both the in-run budget and the
+// operational cap above. The dashboard owns the cross-tick count
+// (task.retry.rejections_since_reset: rejected sessions since the
+// retry_reset_at watermark, any step). When it reaches
+// MAX_CONSECUTIVE_REJECTIONS the dispatcher parks the task instead of
+// redispatching to Build/Write. Same shape as the failure cap:
+// overridable via "maxConsecutiveRejections"; 0 or negative disables.
+var MAX_CONSECUTIVE_REJECTIONS = configInt(config, "maxConsecutiveRejections", 2);
 
 for (var t = 0; t < allTasks.length; t++) {
   var task = allTasks[t];
@@ -139,7 +257,10 @@ for (var t = 0; t < allTasks.length; t++) {
   var steps = WORKFLOWS[workflow] || WORKFLOWS.standard;
 
   if (task.state === "todo") {
-    eligible.push({ task: task, startStep: 0, reason: "new", workflow: workflow });
+    // Idle playtests always enter at QA — the filing carries the full
+    // assignment, so Triage/Map have nothing to add.
+    var todoStart = isPlaytestTask(task) ? qaStepIndex(task.workflow || "standard") : 0;
+    eligible.push({ task: task, startStep: todoStart, reason: "new", workflow: workflow });
     continue;
   }
 
@@ -155,6 +276,10 @@ for (var t = 0; t < allTasks.length; t++) {
   if (latest.status === "completed") {
     var stepName = latest.step || "";
     var stepIndex = steps.indexOf(stepName);
+    if (stepIndex < 0) {
+      log("Skipped \"" + task.title + "\" — step \"" + stepName + "\" not in " + workflow + " step registry");
+      continue;
+    }
     var nextIndex = stepIndex + 1;
 
     if (nextIndex >= steps.length) {
@@ -169,30 +294,233 @@ for (var t = 0; t < allTasks.length; t++) {
     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 || "" });
+      // Budgeted in 2a before becoming eligible.
+      rejectionCandidates.push({ task: task, startStep: buildIdx, reason: "rework", workflow: workflow, rejectionNotes: latest.notes || "" });
     }
     continue;
   }
 
-  if (latest.status === "failed" || latest.status === "timed_out") {
+  // "stalled" is operational like "timed_out": the run died without a verdict.
+  if (latest.status === "failed" || latest.status === "timed_out" || latest.status === "stalled") {
     var failedStep = latest.step || "";
     var retryIdx = steps.indexOf(failedStep);
-    eligible.push({ task: task, startStep: retryIdx >= 0 ? retryIdx : 0, reason: "retry", workflow: workflow });
+    if (retryIdx < 0) {
+      log("Skipped \"" + task.title + "\" — step \"" + failedStep + "\" not in " + workflow + " step registry");
+      continue;
+    }
+    // Counted against the retry cap in 2a before becoming eligible.
+    retryCandidates.push({ task: task, startStep: retryIdx, reason: "retry", workflow: workflow, failedStep: failedStep });
     continue;
   }
 }
 
-log("Eligible: " + eligible.length + " tasks");
+// ── 2a. Retry cap and rejection budget ─────────────────────────────
+// A retry candidate becomes eligible only while its step has failed fewer
+// than MAX_CONSECUTIVE_FAILURES times in a row. A rejection candidate
+// becomes eligible only while its rejections-since-reset are fewer than
+// MAX_CONSECUTIVE_REJECTIONS. Both counts are explicit dashboard-owned
+// state (task.retry from getdispatchstate), computed deterministically
+// server-side. The dispatcher consumes them directly: no LLM history
+// projection, no event-message parsing, no "[retry-cap]" markers.
+// A missing/invalid retry field fails open to "retry" (see decideRetry)
+// so an older dashboard never strands a task — with a warning.
+var parkJobs = [];
+if (retryCandidates.length > 0) {
+  for (var rci = 0; rci < retryCandidates.length; rci++) {
+    var rc = retryCandidates[rci];
+    var retryState = (rc.task && rc.task.retry) || null;
+    var consecutiveFailures = retryState ? retryState.consecutive_failures : undefined;
+    if (typeof consecutiveFailures !== "number" || consecutiveFailures < 0) {
+      log("WARNING: invalid retry state for \"" + rc.task.title + "\" (consecutive_failures=" + String(consecutiveFailures) + ") — retrying, cap unenforced");
+    } else if (retryState == null) {
+      log("WARNING: no explicit retry state for \"" + rc.task.title + "\" — retrying (dashboard predates retry field)");
+    }
+    if (decideRetry(consecutiveFailures, MAX_CONSECUTIVE_FAILURES) === "park") {
+      parkJobs.push({ task: rc.task, message: ("Parked: " + rc.failedStep + " failed " + consecutiveFailures + " consecutive times (cap " + MAX_CONSECUTIVE_FAILURES + ")").slice(0, 1000) });
+    } else {
+      eligible.push({ task: rc.task, startStep: rc.startStep, reason: "retry", workflow: rc.workflow });
+    }
+  }
+}
+if (rejectionCandidates.length > 0) {
+  for (var jci = 0; jci < rejectionCandidates.length; jci++) {
+    var jc = rejectionCandidates[jci];
+    var jcRetryState = (jc.task && jc.task.retry) || null;
+    var rejectionsSinceReset = jcRetryState ? jcRetryState.rejections_since_reset : undefined;
+    if (typeof rejectionsSinceReset !== "number" || rejectionsSinceReset < 0) {
+      log("WARNING: invalid retry state for \"" + jc.task.title + "\" (rejections_since_reset=" + String(rejectionsSinceReset) + ") — reworking, budget unenforced");
+    } else if (jcRetryState == null) {
+      log("WARNING: no explicit retry state for \"" + jc.task.title + "\" — reworking (dashboard predates retry field)");
+    }
+    if (decideRetry(rejectionsSinceReset, MAX_CONSECUTIVE_REJECTIONS) === "park") {
+      parkJobs.push({ task: jc.task, message: ("Parked: " + rejectionsSinceReset + " rejections since reset (budget " + MAX_CONSECUTIVE_REJECTIONS + ") — needs human review").slice(0, 1000) });
+    } else {
+      eligible.push({ task: jc.task, startStep: jc.startStep, reason: "rework", workflow: jc.workflow, rejectionNotes: jc.rejectionNotes });
+    }
+  }
+}
+
+// Batch all parks into one agent call (one round trip) via the atomic
+// parktask action: state=parked plus the note land in one transaction,
+// so a park can never half-apply. A park failure must not kill the tick —
+// the task stays retryable and is re-parked next tick, so this is
+// fail-safe. The dashboard stamps retry_reset_at on parked→todo, which
+// restarts both counters mechanically.
+if (parkJobs.length > 0) {
+  var parkSteps = [];
+  for (var pji = 0; pji < parkJobs.length; pji++) {
+    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) + " }."
+    );
+  }
+  try {
+    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" } }
+    );
+    log("Parked " + parkJobs.length + " task(s)");
+  } catch (parkErr) {
+    log("WARNING: park batch failed (" + (parkErr.message || String(parkErr)).slice(0, 200) + ") — tasks remain retryable");
+  }
+} else {
+  // Cap disabled, or no retry candidates: pre-cap behavior.
+  for (var dr = 0; dr < retryCandidates.length; dr++) {
+    var drc = retryCandidates[dr];
+    eligible.push({ task: drc.task, startStep: drc.startStep, reason: "retry", workflow: drc.workflow });
+  }
+}
+
+log("Eligible: " + eligible.length + " tasks (" + retryCandidates.length + " retry candidates)");
 
+// ── 2b. Idle playtesting ────────────────────────────────────────────
+// No claimable tasks: file a playtest instead of idling. Guards:
+// (a) this block is reachable ONLY when the claimable set is empty — there
+//     is no minimum-task-threshold knob;
+// (b) never more than one playtest outstanding (todo or in_progress);
+// (c) real work always wins — any eligible task skips this block entirely.
+// A quiesced default project is also disarmed: the kill switch pauses
+// dispatch for that project, and a playtest is dispatch.
 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." };
+  var ptProject = DEFAULT_PROJECT;
+  var ptArmed = true;
+  var ptWhy = "";
+
+  if (!ptProject) { ptArmed = false; ptWhy = "no default project"; }
+  if (ptArmed && quiescedProjects[ptProject]) { ptArmed = false; ptWhy = "project " + ptProject + " is quiesced"; }
+
+  // Guard (b): a playtest is already outstanding
+  if (ptArmed) {
+    for (var gi = 0; gi < allTasks.length; gi++) {
+      var gt = allTasks[gi];
+      if (isPlaytestTask(gt) && (gt.state === "todo" || gt.state === "in_progress")) {
+        ptArmed = false; ptWhy = "playtest already outstanding: " + gt.id;
+        break;
+      }
+    }
+  }
+
+  // Journeys roster: playtest.<project>.journeys (markdown string).
+  // Missing, empty, or unparseable => trigger no-ops (unarmed), no error.
+  var ptJourneys = [];
+  if (ptArmed) {
+    ptJourneys = parseJourneys(config["playtest." + ptProject + ".journeys"]);
+    if (ptJourneys.length === 0) { ptArmed = false; ptWhy = "no journeys roster for project " + ptProject + " (unarmed)"; }
+  }
+
+  // Personas: the existing personas/*.md files, sorted by filename.
+  var ptPersonas = [];
+  if (ptArmed) {
+    var personaResult = await agent(
+      "List the QA persona files.\n" +
+      "Use the read tool to list the directory \"" + crewHome + "/.orchestration/personas\".\n" +
+      "Return the sorted basenames of all files ending in .md (e.g. \"beginner.md\").\n" +
+      "If the directory cannot be read, return an empty list.",
+      {
+        key: "list-personas",
+        label: "Listing QA personas",
+        schema: {
+          type: "object",
+          properties: { personas: { type: "array" } },
+          required: ["personas"]
+        }
+      }
+    );
+    ptPersonas = (personaResult.personas || []).filter(function (f) {
+      return typeof f === "string" && f.slice(-3).toLowerCase() === ".md";
+    }).sort();
+    if (ptPersonas.length === 0) { ptArmed = false; ptWhy = "no persona files in " + crewHome + "/.orchestration/personas"; }
+  }
+
+  if (ptArmed) {
+    var J = ptJourneys.length;
+    var P = ptPersonas.length;
+    // Mod the indexes so roster length changes can't break the rotation.
+    var jc = configInt(config, "playtest." + ptProject + ".journey_cursor", 0);
+    var pc = configInt(config, "playtest." + ptProject + ".persona_cursor", 0);
+    var pti = ((jc % J) + J) % J;
+    var ppi = ((pc % P) + P) % P;
+    var ptJourney = ptJourneys[pti];
+    var ptPersonaFile = ptPersonas[ppi];
+    var ptPersonaName = ptPersonaFile.replace(/\.md$/i, "");
+    // Advance: journey += 1 mod J; persona advances only when journey wraps,
+    // so the rotation covers the full journeys x personas matrix over time.
+    var nextJ = (pti + 1) % J;
+    var nextP = (nextJ === 0) ? (ppi + 1) % P : ppi;
+    var maxFilings = configInt(config, "playtest." + ptProject + ".max_filings", 5);
+    if (maxFilings < 0) maxFilings = 5;
+
+    var ptTitle = (PLAYTEST_PREFIX + ptJourney.name + " as " + ptPersonaName).slice(0, 160);
+    var ptDesc = buildPlaytestDescription(ptJourney, ptPersonaName, ptPersonaFile, maxFilings);
+    var safeTitle = ptTitle.replace(/"/g, "'");
+    var safeDesc = ptDesc.replace(/"/g, "'");
+
+    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\": \"\" }.",
+      {
+        key: "file-playtest",
+        label: "Filing idle playtest",
+        schema: {
+          type: "object",
+          properties: { task_id: { type: "string" } },
+          required: ["task_id"]
+        }
+      }
+    );
+
+    if (fileResult.task_id) {
+      eligible.push({
+        task: { id: fileResult.task_id, title: ptTitle, description: ptDesc, project: ptProject, workflow: "standard", state: "todo" },
+        startStep: qaStepIndex("standard"),
+        reason: "playtest",
+        workflow: "standard"
+      });
+      log("Filed idle playtest \"" + ptTitle + "\" [" + ptProject + "] journey " + pti + "/" + J + ", persona " + ppi + "/" + P + ", max_filings " + maxFilings);
+    } else {
+      log("Idle playtest filing failed — cursors already advanced, assignment skipped");
+    }
+  } else {
+    log("Idle playtest not armed: " + ptWhy);
+  }
 }
 
 // ── 3. Process eligible tasks, respecting per-project simultaneity ───
+// Per-poll cap: process at most MAX_TASKS_PER_POLL tasks per tick so the run
+// stays comfortably under the 300s cron timeout (each recommended task
+// becomes one launched workflow run). Deferred tasks stay eligible and are
+// picked up on the next tick. A poll must still ack and exit cleanly — never
+// die mid-run.
+var results = [];
+var partial = false;
+
+{
 // Count in-flight tasks per project to enforce per-project limits
 var inFlightByProject = {};
 for (var ct = 0; ct < allTasks.length; ct++) {
@@ -216,7 +544,15 @@ for (var ei = 0; ei < eligible.length; ei++) {
     log("Skipped \"" + eitem.task.title + "\" — project " + ep + " at simultaneity limit (" + limit + ")");
   }
 }
-var results = [];
+
+// Per-poll cap: defer tasks beyond MAX_TASKS_PER_POLL to the next tick so
+// the run stays under the cron timeout. Deferred tasks remain eligible.
+if (toProcess.length > MAX_TASKS_PER_POLL) {
+  var deferred = toProcess.length - MAX_TASKS_PER_POLL;
+  log("Deferring " + deferred + " task(s) to next poll (per-poll cap " + MAX_TASKS_PER_POLL + ")");
+  toProcess = toProcess.slice(0, MAX_TASKS_PER_POLL);
+  partial = true;
+}
 
 for (var p = 0; p < toProcess.length; p++) {
   var item = toProcess[p];
@@ -236,46 +572,15 @@ for (var p = 0; p < toProcess.length; p++) {
   }
 
   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" +
-    "Do not interpret the response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
-    "Return { claimed: <the response's claimed field exactly>, session_id: \"<the response's session_id field>\" }.\n" +
-    "If claimed is false there is no session_id; 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)
+  // Recommend — do NOT claim. The dispatcher never writes task state or
+  // sessions for recommended tasks: the launched workflow claims the task
+  // itself as its first action (activate + claim), so a claim can never
+  // exist without a launched agent behind it. Two poll ticks can still
+  // recommend the same task in the window before the first workflow
+  // self-claims; the loser's claimtask returns claimed:false and that run
+  // stands down as a duplicate. (Workflows can't launch workflows, so the
+  // caller launches each recommendation from a non-workflow context.)
   var scriptPath = WORKFLOW_DIR + "/" + iworkflow + ".js";
   var taskProject = itask.project || DEFAULT_PROJECT;
   var projectCfg = PROJECTS[taskProject] || PROJECTS[DEFAULT_PROJECT];
@@ -283,7 +588,6 @@ for (var p = 0; p < toProcess.length; p++) {
     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,
@@ -292,28 +596,31 @@ for (var p = 0; p < toProcess.length; p++) {
     crewHome: crewHome
   };
 
-  log("Claimed " + iworkflow + " for \"" + itask.title + "\" [" + taskProject + "] at step " + nextStepName);
-  results.push({ task_id: itask.id, workflow: iworkflow, step: nextStepName, action: "claimed", scriptPath: scriptPath, args: launchArgs });
-}
+  log("Recommended " + iworkflow + " for \"" + itask.title + "\" [" + taskProject + "] at step " + nextStepName);
+  results.push({ task_id: itask.id, workflow: iworkflow, step: nextStepName, action: "recommended", scriptPath: scriptPath, args: launchArgs });
+
+} // end for (per-task loop)
+} // end processing block
 
 // ── 4. Acknowledge ───────────────────────────────────────────────────
+// 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.
 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" } }
+  { key: "ack", label: "Acknowledging poll", schema: { type: "object" } }
 );
 
-var claimed = results.filter(function(r) { return r.action === "claimed"; });
+var recommended = results.filter(function(r) { return r.action === "recommended"; });
 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 (recommended.length > 0) {
+  msg += " Recommended: " + recommended.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 + ".";
-}
+if (partial) { msg += " (partial: per-poll cap deferred tasks)"; }
+if (eligible.length === 0) { msg = "No tasks ready."; }
 
-return { status: "ok", message: msg, claims: claimed };
+return { status: "ok", message: msg, claims: recommended, partial: partial };