hilos-agent 0.4.0 → 0.6.0

package/src/handler.mjs

@@ -26,11 +26,12 @@ import {
   mentionHandle,
   detectPrContinuation,
 } from "./daemon.mjs";
-import { runCli, buildHeartbeat, ackText, oneLine, fmtElapsed } from "./cli.mjs";
+import { runCli, buildHeartbeat, ackText, oneLine, fmtElapsed, minimalEnv } from "./cli.mjs";
 import { makeStreamParser } from "./agent-events.mjs";
-import { detectVendor, codeStreamArgs, createProgressEmitter } from "./progress-emitter.mjs";
+import { detectVendor, codeStreamArgs, createProgressEmitter, fastChatCmd } from "./progress-emitter.mjs";
 import { resolveFollowupMode, classifyFollowupCue, normalizeSignal } from "./followup.mjs";
 import { buildResumeArgs, readStateEntry, writeState, HILOS_DIR } from "./resume.mjs";
+import { createModelArgsResolver } from "./model-resolve.mjs";
 import {
   buildReviewPrompt,
   parseReviewOutput,
@@ -38,6 +39,30 @@ import {
   shouldReview,
 } from "./review.mjs";
 import { buildMemoryBlock } from "./memory.mjs";
+import { deployFolder, resolveDeployTarget } from "./deploy.mjs";
+
+/**
+ * The environment for a coding/chat CLI run. runCli always strips HILOS_* on top
+ * of whatever this returns; here we additionally honor `codingEnv: "minimal"`
+ * (strict isolation — only what the tool needs to reach its own model provider).
+ * Returns undefined for the default "inherit" mode so runCli falls back to the
+ * scrubbed process.env.
+ */
+function codingChildEnv(cfg) {
+  return cfg?.codingEnv === "minimal"
+    ? minimalEnv(process.env, cfg.codingEnvAllow)
+    : undefined;
+}
+
+/**
+ * The fast chat command for this config: an explicit chatCmd wins, else the
+ * coding vendor's verified non-interactive print mode (fastChatCmd), else the
+ * coding command itself. Keeps chat/plan-ack/review on the USER'S tool — a
+ * Codex or Cursor daemon must never require Claude Code on PATH (0521).
+ */
+function chatCmdFor(cfg) {
+  return cfg.chatCmd || fastChatCmd(detectVendor(cfg.codingCmd)) || cfg.codingCmd;
+}
 
 /** PR number from a github pull-request URL, or null. */
 function prNumberFromUrl(url) {
@@ -51,6 +76,10 @@ function prNumberFromUrl(url) {
 // human re-triggering the review is the escape hatch past the cap.
 const reviewRounds = new Map();
 
+// Tier → account-verified `--model` args for the code run (0504). Memoized per
+// (binary, tier) for the process; a failed lookup emits [] and retries later.
+const modelArgsFor = createModelArgsResolver({ run: (opts) => runCli(opts) });
+
 
 // Sentinel the router model emits (only when a thread already owns a run) to
 // classify a follow-up: change | new-scope | ambiguous. Parsed out of the router
@@ -102,6 +131,8 @@ function defaultDeps() {
     // Does a path exist on disk? Injectable so folder mode's "missing folder"
     // guard is unit-testable without touching the real filesystem.
     pathExists: (p) => existsSync(p),
+    resolveDeployTarget: (args) => resolveDeployTarget(args),
+    deployFolder: (args) => deployFolder(args),
     openPR: (cwd, { title, body, branch, base }) => {
       const r = spawnSync(
         "gh",
@@ -167,7 +198,15 @@ async function awaitDecision({ tool, channelId, reportMessageId, cfg, deps, pare
       report = m && m.report ? m.report : null;
     }
     const kind = report ? decisionKind(report) : null;
-    if (kind) return { kind, note: report.decision?.note || null };
+    if (kind === "deploy") {
+      const provider = report.decision?.provider;
+      const prod = report.decision?.prod;
+      if ((provider === "vercel" || provider === "netlify") && typeof prod === "boolean") {
+        return { kind, provider, prod };
+      }
+    } else if (kind) {
+      return { kind, note: report.decision?.note || null };
+    }
     await deps.sleep(cfg.decisionPollMs);
   }
   return { kind: "timeout" };
@@ -371,7 +410,7 @@ const CODE_SIGNAL = "__CODE__";
  */
 async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cfg, signal, hasActiveRun = false, runCliFn }) {
   const doRun = runCliFn || runCli; // folder mode injects deps.runCli; repo flow uses the import
-  const cmd = cfg.chatCmd || cfg.codingCmd;
+  const cmd = chatCmdFor(cfg);
   const parts = cmd.split(" ").filter(Boolean);
   // When this thread already owns an OPEN pull request (a follow-up reply), the
   // router ALSO reads whether the latest message continues that PR, wants a
@@ -558,7 +597,7 @@ export function planAckPrompt(o) {
  * empty/timeout/error so the run keeps the instant template and never stalls.
  */
 async function proposePlanAck({ task, transcript, repoFullName, cfg, signal }) {
-  const cmd = cfg.chatCmd;
+  const cmd = chatCmdFor(cfg);
   if (!cmd) return null;
   const parts = cmd.split(" ").filter(Boolean);
   const prompt = planAckPrompt({ task, transcript, repoFullName });
@@ -568,6 +607,7 @@ async function proposePlanAck({ task, transcript, repoFullName, cfg, signal }) {
     timeoutMs: Math.min(cfg.chatTimeoutMs || 90000, 45000),
     label: "thinking",
     signal,
+    env: codingChildEnv(cfg),
   });
   if (run.aborted || signal?.aborted) return null;
   const text = (run.stdout || "").trim();
@@ -597,10 +637,10 @@ async function respondConversationally({ message, channelId, tool, me, cfg, repo
     `${memoryPreamble(workspaceMemory)}` +
     `Conversation so far:\n${transcript}`;
 
-  // Chat uses the FAST one-shot command (fall back to codingCmd if unset) bounded
-  // by chatTimeoutMs, so a casual reply lands in seconds and a stalled model can't
-  // dead-air the channel for the full coding timeout.
-  const cmd = cfg.chatCmd || cfg.codingCmd;
+  // Chat uses the FAST one-shot command (the coding vendor's own print mode when
+  // chatCmd is unset) bounded by chatTimeoutMs, so a casual reply lands in seconds
+  // and a stalled model can't dead-air the channel for the full coding timeout.
+  const cmd = chatCmdFor(cfg);
   const parts = cmd.split(" ").filter(Boolean);
   console.log(`  chat → running \`${cmd}\` (output appears when it finishes)…`);
 
@@ -636,6 +676,7 @@ async function respondConversationally({ message, channelId, tool, me, cfg, repo
       timeoutMs: cfg.chatTimeoutMs || cfg.runTimeoutMs,
       label: "thinking",
       signal,
+      env: codingChildEnv(cfg),
     });
   } finally {
     beatStopped = true;
@@ -807,7 +848,7 @@ async function reviewTask({ message, channelId, tool, me, cfg, workspaceMemory,
   // Read-only run: a throwaway cwd contains any stray write; the daemon reads ONLY
   // stdout and never stages/commits anything. Review uses the fast chat command
   // when set (no acceptEdits → can't write), falling back to the coding command.
-  const cmd = cfg.reviewCmd || cfg.chatCmd || cfg.codingCmd;
+  const cmd = cfg.reviewCmd || chatCmdFor(cfg);
   const parts = String(cmd).split(" ").filter(Boolean);
   let sandboxDir = null;
   try {
@@ -823,6 +864,7 @@ async function reviewTask({ message, channelId, tool, me, cfg, workspaceMemory,
     timeoutMs: cfg.chatTimeoutMs ? Math.max(cfg.chatTimeoutMs, 120000) : cfg.runTimeoutMs,
     label: "reviewing",
     signal,
+    env: codingChildEnv(cfg),
   });
   if (sandboxDir) {
     try {
@@ -890,6 +932,207 @@ function renderChangedList({ created, modified, deleted }) {
   return lines.join("\n");
 }
 
+function deployLabel(target) {
+  const provider = target.provider === "vercel" ? "Vercel" : "Netlify";
+  return `${provider} (${target.prod ? "production" : "preview"})`;
+}
+
+function folderDeployState(folderPath, git) {
+  const inside = git(folderPath, ["rev-parse", "--is-inside-work-tree"]);
+  const isGit = inside.status === 0 && String(inside.stdout || "").trim() === "true";
+  if (!isGit) return { commit: null, stat: "", changed: null };
+  const commitResult = git(folderPath, ["rev-parse", "--short", "HEAD"]);
+  const statResult = git(folderPath, ["diff", "--stat", "HEAD"]);
+  const statusResult = git(folderPath, ["status", "--porcelain"]);
+  const changed = diffStatusSets("", String(statusResult.stdout || ""));
+  return {
+    commit: commitResult.status === 0 ? String(commitResult.stdout || "").trim() : null,
+    stat: truncateDiff(String(statResult.stdout || "")).text.trim(),
+    changed,
+  };
+}
+
+// A report-card Deploy click is stored durably on the report as a pending
+// decision, and list_mentions re-projects it on EVERY poll until a post_report
+// settle clears it. So every terminal exit of handleFolderDeploy — including
+// "stopped" and "deploy is off" — must settle the source report, or the
+// decision re-triggers the deploy on the next poll / daemon restart (an
+// explicit human cancel of a production deploy would not stick) and the card
+// stays wedged on "deployment requested" with its action row hidden. Settling
+// re-posts the prior report content untouched plus one honest caveat; the
+// server replaces metadata.report wholesale, which clears the decision by
+// construction and brings the Deploy button back for a retry.
+async function settleDeploySource({ tool, channelId, sourceReportId, caveat }) {
+  if (!sourceReportId) return;
+  const prior = await tool("get_report", { messageId: sourceReportId }).catch(() => null);
+  const p = prior?.found && prior.report ? prior.report : null;
+  const caveats = [
+    ...(Array.isArray(p?.caveats) ? p.caveats.filter((v) => typeof v === "string") : []),
+    caveat,
+  ];
+  await tool("post_report", {
+    channelId,
+    messageId: sourceReportId,
+    broadcast: true,
+    ...(typeof p?.title === "string" ? { title: p.title } : {}),
+    summary: typeof p?.summary === "string" && p.summary ? p.summary : caveat,
+    caveats: [...new Set(caveats)],
+    todos: Array.isArray(p?.todos) ? p.todos.filter((v) => typeof v === "string") : [],
+    ...(Array.isArray(p?.verified) ? { verified: p.verified.filter((v) => typeof v === "string") } : {}),
+    ...(p?.deployment ? { deployment: p.deployment } : {}),
+    ...(typeof p?.previewUrl === "string" ? { previewUrl: p.previewUrl } : {}),
+    ...(typeof p?.pr?.url === "string" ? { prUrl: p.pr.url } : {}),
+    ...(typeof p?.pr?.number === "number" ? { prNumber: p.pr.number } : {}),
+  }).catch(() => {});
+}
+
+async function handleFolderDeploy({
+  message,
+  channelId,
+  tool,
+  cfg,
+  deps,
+  signal,
+  parentId,
+  folderPath,
+  sourceReportId,
+}) {
+  if (!deps.pathExists(folderPath)) {
+    await settleDeploySource({
+      tool,
+      channelId,
+      sourceReportId,
+      caveat: "A requested deployment didn't start: the folder wasn't found on this machine.",
+    });
+    await tool("post_message", {
+      channelId,
+      parentId,
+      body: `I couldn't find the folder \`${folderPath}\` on this machine, so nothing was deployed.`,
+    });
+    return { status: "no-path" };
+  }
+  const target = deps.resolveDeployTarget({
+    cfg,
+    channelId,
+    folderPath,
+    pathExists: deps.pathExists,
+  });
+  if (!target.enabled) {
+    await settleDeploySource({
+      tool,
+      channelId,
+      sourceReportId,
+      caveat: "A requested deployment didn't start: deployment is off for this folder.",
+    });
+    await tool("post_message", {
+      channelId,
+      parentId,
+      body:
+        "Deployment is off for this folder. Add a `deploy` entry for this channel in `hilos-agent.json`, " +
+        "or link the folder once with Vercel/Netlify so its local project marker can be detected.",
+    });
+    return { status: "deploy-off" };
+  }
+
+  const requested = message?.deployRequest;
+  if (
+    requested &&
+    (requested.provider !== target.provider || requested.prod !== target.prod)
+  ) {
+    await settleDeploySource({
+      tool,
+      channelId,
+      sourceReportId,
+      caveat: "A requested deployment didn't start: the folder's deploy target changed after this report.",
+    });
+    await tool("post_message", {
+      channelId,
+      parentId,
+      body: "The folder's deploy target changed after that report. Open the latest report and try again.",
+    });
+    return { status: "deploy-target-changed" };
+  }
+
+  const prior = sourceReportId
+    ? await tool("get_report", { messageId: sourceReportId }).catch(() => null)
+    : null;
+  const priorReport = prior?.found && prior.report ? prior.report : null;
+  const state = folderDeployState(folderPath, deps.git);
+  await tool("post_message", {
+    channelId,
+    parentId,
+    body:
+      `Deploying ${target.prod ? "to production" : "a preview"} on ` +
+      `${target.provider === "vercel" ? "Vercel" : "Netlify"} from \`${folderPath}\`. ` +
+      `${sourceReportId ? "I'll update the report when it finishes." : "I'll post the live link when it finishes."}`,
+  });
+  const result = await deps.deployFolder({ folderPath, target, signal });
+  if (result.aborted || signal?.aborted) {
+    // A stop must stick: settle the report so the pending decision can't
+    // re-trigger this deploy on the next poll or daemon restart.
+    await settleDeploySource({
+      tool,
+      channelId,
+      sourceReportId,
+      caveat: "A deployment was stopped before it finished. Use Deploy on this report to try again.",
+    });
+    await tool("post_message", { channelId, parentId, body: "Deployment was stopped." });
+    return { status: "cancelled" };
+  }
+
+  const folderName = folderPath.split("/").filter(Boolean).pop() || folderPath;
+  const stateLines = [];
+  if (state.commit) stateLines.push(`Deployed from commit \`${state.commit}\`.`);
+  if (state.changed && renderChangedList(state.changed)) {
+    stateLines.push(`Local changes included:\n${renderChangedList(state.changed)}`);
+  }
+  if (state.stat) stateLines.push("```\n" + state.stat + "\n```");
+  const priorSummary = typeof priorReport?.summary === "string" ? priorReport.summary : "";
+  const summary = result.ok
+    ? [
+        priorSummary,
+        `Deployed to ${deployLabel(target)}: ${result.url}`,
+        ...stateLines,
+      ].filter(Boolean).join("\n\n")
+    : [priorSummary, `Deployment to ${deployLabel(target)} did not finish.`, ...stateLines]
+        .filter(Boolean)
+        .join("\n\n");
+  const priorCaveats = Array.isArray(priorReport?.caveats)
+    ? priorReport.caveats.filter((value) => typeof value === "string")
+    : [];
+  const caveats = [...priorCaveats];
+  if (result.ok && !target.prod) {
+    caveats.push("Preview deployment — this is not your production domain.");
+  } else if (!result.ok && result.caveat) {
+    caveats.push(result.caveat);
+  }
+  const priorPreviewUrl =
+    typeof priorReport?.previewUrl === "string" ? priorReport.previewUrl : undefined;
+  if (!result.ok && priorPreviewUrl) {
+    caveats.push("The live link is from the previous successful deployment; this new deploy did not replace it.");
+  }
+  const report = {
+    channelId,
+    ...(sourceReportId ? { messageId: sourceReportId } : { parentId }),
+    broadcast: true,
+    title: result.ok ? `Deployed: ${folderName}` : `Deployment failed: ${folderName}`,
+    summary,
+    caveats: [...new Set(caveats)],
+    todos: Array.isArray(priorReport?.todos) ? priorReport.todos : [],
+    ...(target.available
+      ? { deployment: { provider: target.provider, prod: target.prod } }
+      : {}),
+    ...((result.ok && result.url) || priorPreviewUrl
+      ? { previewUrl: result.ok ? result.url : priorPreviewUrl }
+      : {}),
+  };
+  await tool("post_report", report);
+  return {
+    status: result.ok ? "folder-deployed" : "deploy-failed",
+    previewUrl: result.ok ? result.url : null,
+  };
+}
+
 /**
  * FOLDER MODE (0322). A channel with NO linked GitHub repo but a `folders`
  * mapping runs the coding CLI directly in that folder and applies changes in
@@ -919,6 +1162,12 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
     });
     return { status: "no-path" };
   }
+  const deployTarget = deps.resolveDeployTarget({
+    cfg,
+    channelId,
+    folderPath,
+    pathExists: deps.pathExists,
+  });
 
   // 2. Is it a git repo? If so, snapshot the pre-run status so we can (a) report
   // exactly what the run changed and (b) revert precisely on reject. We NEVER touch
@@ -1028,14 +1277,17 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
       };
     }
     let run;
+    // Model preset (0504): same run-time resolution as the repo path.
+    const modelArgs = await modelArgsFor(cfg, vendor);
     try {
       run = await deps.runCli({
         cmd: parts[0],
-        args: [...parts.slice(1), ...streamArgs, memoryPreamble(workspaceMemory) + promptText],
+        args: [...parts.slice(1), ...modelArgs, ...streamArgs, memoryPreamble(workspaceMemory) + promptText],
         cwd: folderPath,
         timeoutMs: cfg.runTimeoutMs,
         label: "coding",
         signal,
+        env: codingChildEnv(cfg),
         onData: (c) => {
           const lines = String(c).split("\n").map((s) => s.trim()).filter(Boolean);
           if (lines.length) lastLine = lines[lines.length - 1];
@@ -1129,7 +1381,15 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
       caveats.push(`The coding agent didn't exit cleanly${why} — review the changes carefully.`);
     }
     const folderName = folderPath.split("/").filter(Boolean).pop() || folderPath;
-    return { title: `Folder run: ${folderName}`, summary: parts.join("\n\n"), caveats, todos: [] };
+    return {
+      title: `Folder run: ${folderName}`,
+      summary: parts.join("\n\n"),
+      caveats,
+      todos: [],
+      ...(deployTarget.enabled && deployTarget.available
+        ? { deployment: { provider: deployTarget.provider, prod: deployTarget.prod } }
+        : {}),
+    };
   };
 
   // --- Run ---
@@ -1206,6 +1466,27 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
     round += 1;
   }
 
+  if (decision.kind === "deploy") {
+    return await handleFolderDeploy({
+      message: {
+        ...message,
+        deployRequest: {
+          reportMessageId,
+          provider: decision.provider,
+          prod: decision.prod,
+        },
+      },
+      channelId,
+      tool,
+      cfg,
+      deps,
+      signal,
+      parentId: threadRoot,
+      folderPath,
+      sourceReportId: reportMessageId,
+    });
+  }
+
   // --- Terminal ---
   if (decision.kind === "approved") {
     await tool("post_message", {
@@ -1268,7 +1549,10 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
 /** Handle one task. cfg/deps injectable for tests. `opts.signal` (AbortSignal)
  *  cancels an in-flight run — the queue fires it when a human says "stop". */
 export async function handleTask({ message, channelId, tool, me, caps = {} }, cfg, depsOverride, opts = {}) {
-  const deps = depsOverride || defaultDeps();
+  if (message.dispatch?.briefMarkdown) {
+    message = { ...message, body: `${message.body}\n\n${message.dispatch.briefMarkdown}` };
+  }
+  const deps = depsOverride ? { ...defaultDeps(), ...depsOverride } : defaultDeps();
   const git = deps.git;
   const signal = opts.signal;
   // When the mention was a thread reply, keep the whole exchange in that thread.
@@ -1324,15 +1608,102 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   if (!repoLink) {
     const folderPath = resolveFolderPath(cfg, channelId);
     if (folderPath) {
+      // Durable report-card fallback: list_mentions projects a still-pending
+      // in-place decision into the queue. Deploy only while that decision
+      // remains pending; a settled report is a silent no-op, which prevents a
+      // race with the active folder run from deploying twice.
+      if (message.deployRequest && typeof message.deployRequest.reportMessageId === "string") {
+        if (message.authorRole === "guest") {
+          await tool("post_message", {
+            channelId,
+            parentId,
+            body: "A workspace member needs to request that deployment.",
+          });
+          return { status: "chat" };
+        }
+        const sourceReportId = message.deployRequest.reportMessageId;
+        const current = await tool("get_report", { messageId: sourceReportId }).catch(() => null);
+        if (current?.found && current.report?.decision?.kind !== "deploy") {
+          return { status: "deploy-already-handled" };
+        }
+        return await handleFolderDeploy({
+          message,
+          channelId,
+          tool,
+          cfg,
+          deps,
+          signal,
+          parentId,
+          folderPath,
+          sourceReportId,
+        });
+      }
+
       // Same chat-vs-code decision the repo path uses: mode 'ask'/'ship' short-
       // circuit exactly as in the repo flow, otherwise the LLM router judges intent
       // (its CLI call goes through deps.runCli so folder mode is unit-testable).
-      const routed =
-        mode === "ask"
-          ? { code: false, reply: null }
-          : mode === "ship"
-            ? { code: true, task: message.body }
-            : await routeIntent({
+      let routed;
+      if (mode === "ask") {
+        routed = { code: false, reply: null };
+      } else if (mode === "ship") {
+        routed = { code: true, task: message.body };
+      } else if (caps.agentIntent) {
+        const classifierDeployTarget = deps.resolveDeployTarget({
+          cfg,
+          channelId,
+          folderPath,
+          pathExists: deps.pathExists,
+        });
+        const semantic = await tool("classify_agent_intent", {
+          latestMessage: message.body,
+          transcript: context.transcript,
+          project: folderPath,
+          channelId,
+          allowDeploy: classifierDeployTarget.enabled === true,
+        }).catch(() => null);
+        if (semantic?.reason === "execution-disabled") {
+          await tool("post_message", {
+            channelId,
+            parentId,
+            body: "I can chat here, but agent execution is disabled in this channel.",
+          });
+          return { status: "chat" };
+        }
+        if (
+          semantic?.ok &&
+          message.authorRole === "guest" &&
+          (semantic.mode === "ship" || semantic.mode === "deploy")
+        ) {
+          await tool("post_message", {
+            channelId,
+            parentId,
+            body: "A workspace member needs to confirm that request before I can act on it.",
+          });
+          return { status: "chat" };
+        }
+        if (semantic?.ok && semantic.mode === "deploy") {
+          return await handleFolderDeploy({
+            message,
+            channelId,
+            tool,
+            cfg,
+            deps,
+            signal,
+            parentId,
+            folderPath,
+            sourceReportId: null,
+          });
+        }
+        if (semantic?.ok && semantic.mode === "ship") {
+          routed = { code: true, task: semantic.brief || message.body };
+        } else if (semantic?.ok && semantic.mode === "ask") {
+          routed = { code: false, reply: null };
+        }
+      }
+      // Capability or classifier failure: preserve the previous semantic local
+      // CLI router. There is still no keyword/regex intent list.
+      if (!routed) {
+        routed = await routeIntent({
                 name: me?.agentName || "an assistant",
                 repoFullName: folderPath,
                 transcript: context.transcript,
@@ -1341,6 +1712,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
                 signal,
                 runCliFn: deps.runCli,
               });
+      }
       if (routed.aborted || signal?.aborted) {
         await tool("post_message", { channelId, parentId, body: "Stopped." });
         return { status: "chat" };
@@ -1426,7 +1798,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     if (!body) {
       body =
         routed.error?.code === "ENOENT"
-          ? `(my chat command \`${cfg.chatCmd || cfg.codingCmd}\` isn't installed or on PATH.)`
+          ? `(my chat command \`${chatCmdFor(cfg)}\` isn't installed or on PATH.)`
           : `Still thinking on this — it's taking longer than usual. I'll follow up shortly.`;
     }
     await tool("post_message", { channelId, parentId, body });
@@ -1632,8 +2004,28 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   //   new      → record a fresh run, exactly as before.
   // Best-effort throughout — a bookkeeping failure (or an older server without the
   // runs tools) must NEVER break the run, so it proceeds without a runId.
-  let runId = effectiveMode === "iterate" ? activeRun?.runId ?? null : null;
-  if (caps.runs && threadRoot && effectiveMode !== "iterate") {
+  let runId = message.dispatch?.runId ?? (effectiveMode === "iterate" ? activeRun?.runId ?? null : null);
+  if (message.dispatch?.runId && caps.runs) {
+    // Adopt the dispatch's canonical run. If the server already SETTLED it (the
+    // reaper/outbox closed a dispatch we were slow to pick up), leave it alone
+    // and skip the coding run — resurrecting it would ship work no one is
+    // waiting on. Any OTHER failure (network, an older server without the guard)
+    // keeps today's best-effort behavior: proceed with the run.
+    try {
+      await tool("update_run", { runId: message.dispatch.runId, status: "running" });
+    } catch (e) {
+      if (String(e?.message || "").includes("already settled")) {
+        await tool("post_message", {
+          channelId,
+          parentId,
+          body: "This dispatch was already closed on the server, so I left it alone. Approve it again if it's still wanted.",
+        }).catch(() => {});
+        return { status: "dispatch-settled" };
+      }
+      /* older server or a transient error — proceed best-effort */
+    }
+  }
+  if (caps.runs && threadRoot && effectiveMode !== "iterate" && !message.dispatch?.runId) {
     try {
       if (effectiveMode === "redirect" && activeRun?.runId) {
         await tool("update_run", { runId: activeRun.runId, status: "superseded" }).catch(() => {});
@@ -1644,7 +2036,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
         taskText: message.body,
         branch,
         // Map an unrecognized command to null rather than the off-vocabulary
-        // "unknown" — provider is documented as claude_code|codex|cursor|hilos.
+        // "unknown" — provider is documented as
+        // claude_code|codex|cursor|antigravity|hermes|hilos.
         provider: (() => {
           const v = detectVendor(cfg.codingCmd);
           return v === "unknown" ? null : v;
@@ -1657,7 +2050,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   }
   // Keep the inspectable continuation/redirect statement (don't overwrite it with
   // an LLM plan) so a human can correct the routing before code lands.
-  if (ackId && caps.editMessage && cfg.chatCmd && !continuingPrUrl && effectiveMode !== "redirect") {
+  if (ackId && caps.editMessage && chatCmdFor(cfg) && !continuingPrUrl && effectiveMode !== "redirect") {
     // Feed the ack the router's distilled brief AND the conversation — not the raw
     // mention — so it states a real plan instead of "what's the task?".
     const plan = await proposePlanAck({
@@ -1692,9 +2085,9 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   // (get_active_run) with no local match means the session likely lives on another
   // machine/instance — a bad `--resume` id makes claude error → empty diff → a failed
   // run, so we DON'T resume and degrade to today's branch+feedback (never worse).
-  // Only claude_code has a proven resume flag; codex/cursor/unknown → [] anyway.
+  // claude_code + cursor have proven resume flags (0282/0573); codex/unknown → [].
   let resumeSessionId = null;
-  if (effectiveMode === "iterate" && vendor === "claude_code") {
+  if (effectiveMode === "iterate" && (vendor === "claude_code" || vendor === "cursor")) {
     const local = (() => {
       try {
         return readStateEntry(HILOS_DIR, threadRoot);
@@ -1823,9 +2216,13 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     // fallback) suppresses it. buildResumeArgs is [] unless vendor+session make
     // resume safe, so a non-resume run is byte-identical to the pre-0282 ARGV.
     const resumeArgs = resume ? buildResumeArgs(vendor, resumeSessionId) : [];
+    // Model preset (0504): resolved at run time against the CLI's own model
+    // list (cursor only today) — [] when unset/unresolvable, so the tool's
+    // default stands. Inserted before resume/stream flags, after the base.
+    const modelArgs = await modelArgsFor(cfg, vendor);
     const codeArgs = streamOn
-      ? [...parts.slice(1), ...resumeArgs, ...streamArgs]
-      : [...parts.slice(1), ...resumeArgs];
+      ? [...parts.slice(1), ...modelArgs, ...resumeArgs, ...streamArgs]
+      : [...parts.slice(1), ...modelArgs, ...resumeArgs];
     let run;
     try {
       run = await runCli({
@@ -1835,6 +2232,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
         timeoutMs: cfg.runTimeoutMs,
         label: "coding",
         signal,
+        env: codingChildEnv(cfg),
         onData: (c) => {
           // Keep tracking lastLine as a fallback (legacy heartbeat / honesty).
           const lines = String(c).split("\n").map((s) => s.trim()).filter(Boolean);