hilos-agent 0.11.12 → 0.11.13

package/src/handler.mjs

@@ -1,7 +1,7 @@
-// CANONICAL HANDLER — this is what the published `hilos-agent` package ships and
-// runs. Bias-to-PR by default (gate:false opens a PR; gate:true falls back to
-// approve-before-push). The legacy, propose-only reference lives at
-// scripts/examples/coding-agent-handler.mjs and is NOT what users run.
+import { githubArtifactPatch } from "./github-artifacts.mjs";
+import { AGENT_CODE_RESULT_RULE, AGENT_REPLY_STYLE_RULE, agentResultText } from "./agent-result.mjs";
+// The handler the published `hilos-agent` package ships and runs. Bias-to-PR by
+// default (gate:false opens a PR; gate:true falls back to approve-before-push).
 //
 // Turn an @mention in a git-linked channel into a branch + a coding-agent run.
 // By default it opens a PR for review; with gate:true it posts a proposed diff
@@ -106,6 +106,7 @@ import {
 import { createUngatedRunNotice } from "./permission-gate.mjs";
 import { repoEditAllowance } from "./permission-gate.mjs";
 import { webMcpAgentPrompt } from "./webmcp-bridge.mjs";
+import { truncate } from "./util.mjs";
 import {
   conflictCommitTitle,
   conflictPromptBlock,
@@ -281,6 +282,18 @@ function defaultDeps() {
       const url = (r.stdout || "").trim().split("\n").filter(Boolean).pop() || null;
       return { ok: r.status === 0, url, stdout: r.stdout || "", stderr: r.stderr || "" };
     },
+    updatePRCopy: (cwd, url, provenance) => {
+      const options = { cwd, env: cwdEnv(cwd), encoding: "utf8" };
+      const read = spawnSync("gh", ["pr", "view", url, "--json", "title,body"], options);
+      if (read.status !== 0) return;
+      try {
+        const patch = githubArtifactPatch(JSON.parse(read.stdout), provenance);
+        const args = ["pr", "edit", url];
+        if (patch.title) args.push("--title", patch.title);
+        if (patch.body) args.push("--body", patch.body);
+        if (args.length > 3) spawnSync("gh", args, options);
+      } catch { /* Leave existing copy intact when it cannot be read. */ }
+    },
     closePR: (cwd, url) =>
       spawnSync("gh", ["pr", "close", url], {
         cwd,
@@ -828,33 +841,15 @@ async function runCodexGatedSession({
   return { ...fallback, permissionGateDropped: true };
 }
 
-async function awaitDecision({ tool, channelId, reportMessageId, cfg, deps, parentId, signal }) {
+async function awaitDecision({ tool, reportMessageId, cfg, deps, signal }) {
   if (!reportMessageId) return { kind: "timeout" };
   const deadline = deps.now() + cfg.decisionTimeoutMs;
   while (deps.now() < deadline) {
     // A "stop" while we wait for review must end the wait — otherwise a later
     // Approve would still commit/push/open a PR despite the cancel.
     if (signal?.aborted) return { kind: "cancelled" };
-    let report = null;
     const gr = await tool("get_report", { messageId: reportMessageId }).catch(() => null);
-    if (gr && gr.found && gr.report) report = gr.report;
-    if (!report) {
-      // Fallback for servers without get_report. In a thread the report lives
-      // under the thread root (read_channel only returns top-level), so scan the
-      // thread there; otherwise scan the channel tail.
-      let candidates = [];
-      if (parentId) {
-        const t = await tool("get_thread", { parentId }).catch(() => null);
-        candidates = t && t.found ? [t.root, ...(t.replies ?? [])].filter(Boolean) : [];
-      } else {
-        const { messages = [] } = await tool("read_channel", { channelId, limit: 200 }).catch(
-          () => ({ messages: [] }),
-        );
-        candidates = messages;
-      }
-      const m = candidates.find((x) => x.id === reportMessageId);
-      report = m && m.report ? m.report : null;
-    }
+    const report = gr && gr.found && gr.report ? gr.report : null;
     const kind = report ? decisionKind(report) : null;
     if (kind === "deploy") {
       const provider = report.decision?.provider;
@@ -1131,9 +1126,81 @@ async function postFinalReportWithReplay({
   }
 }
 
+/**
+ * 1290 — the one settle used by both shipping paths (the approved gated diff and
+ * the self-driven run). Seamless single card (0289): settle onto the live status
+ * message when one was streaming this run — the workspace setting decides
+ * channel visibility — otherwise post a fresh final report. The two Stop fences
+ * around the post and the PR link are part of the settle: a Stop that lands here
+ * must compensate the push rather than publish a card.
+ * Returns `{ stopped }` when Stop won, else `{ reportMsgId }` (0792 — the card
+ * this run settled onto, for the transcript stamp).
+ * `finishReason` is passed as `undefined` when there is nothing to report.
+ */
+async function settleShippedReport({
+  tool,
+  channelId,
+  parentId,
+  settleId,
+  runId,
+  iterateTurn = 0,
+  finishStatus,
+  finishBranch,
+  finishReason,
+  title,
+  summary,
+  prUrl,
+  caveats,
+  usageArgs = {},
+  rollbackIfStopped,
+  linkUrl = null,
+}) {
+  const reportArgs = {
+    channelId,
+    ...(runId ? { runId } : {}),
+    ...(runId ? { iterateTurn } : {}),
+    ...(runId ? { reportRequestId: randomUUID() } : {}),
+    ...(runId
+      ? {
+          finishStatus,
+          finishBranch,
+          ...(finishReason === undefined ? {} : { finishReason }),
+        }
+      : {}),
+    title,
+    summary,
+    prUrl,
+    caveats,
+    // 0787 — what the run cost, when the caller had a receipt to hand over.
+    // A gated run already spent it on the proposal card and passes {}.
+    ...usageArgs,
+  };
+  const stoppedBeforeReport = await rollbackIfStopped();
+  if (stoppedBeforeReport) return { stopped: stoppedBeforeReport };
+  const finalReportArgs = settleId
+    ? { ...reportArgs, messageId: settleId, broadcast: true }
+    : { ...reportArgs, parentId, broadcast: true };
+  const reportAttempt = await postFinalReportWithReplay({
+    tool,
+    args: finalReportArgs,
+    runId,
+    finishStatus: reportArgs.finishStatus,
+    rollbackIfStopped,
+  });
+  if (reportAttempt.stopped) return { stopped: reportAttempt.stopped };
+  const stoppedAfterReport = await rollbackIfStopped();
+  if (stoppedAfterReport) return { stopped: stoppedAfterReport };
+  const reportMsgId = settleId || reportAttempt.result?.messageId || null;
+  // Work produced a PR → attach it to the channel so its live pill shows up.
+  await linkPrFromUrl({ tool, channelId, url: linkUrl });
+  // post_report atomically bound this card, the branch/PR receipt, and the final
+  // run gate under one run-row lock; nothing else may update the run here.
+  return { reportMsgId };
+}
+
 /**
  * @param {{ tool: Function, runId: string, expectedIterateTurn: number,
- *   claimId?: string, recoveryStore?: {
+ *   claimId?: string, recoveryStore: {
  *     persist: (record: { runId: string, expectedIterateTurn: number, claimId: string }) => boolean,
  *     remove: (claimId: string) => boolean
  *   } }} options
@@ -1153,17 +1220,6 @@ export async function claimDaemonIterate({
     expectedIterateTurn,
     claimId,
   };
-  // Rolling upgrade compatibility: the preceding server supported the
-  // idempotent claim token but not exact confirm/release. Without a recovery
-  // store (created only when the full schema is advertised), preserve that
-  // bounded same-token replay byte-for-byte and do not enable later guards.
-  if (!recoveryStore) {
-    try {
-      return await tool("update_run", args);
-    } catch {
-      return await tool("update_run", args);
-    }
-  }
   if (!recoveryStore.persist(record)) {
     throw new Error("the Iterate claim recovery record could not be persisted");
   }
@@ -1310,6 +1366,7 @@ export async function applyDecision({ decision, repoPath, branch, task, requeste
     // Continuing an existing PR (request-changes rework): the push already
     // updated it — reuse its URL instead of opening a duplicate. Otherwise open
     // a fresh PR.
+    if (existingPrUrl) deps.updatePRCopy?.(repoPath, existingPrUrl, provenance);
     const pr = existingPrUrl
       ? { ok: true, url: existingPrUrl }
       : deps.openPR(repoPath, { title, body, branch, base: cfg.defaultBranch });
@@ -1323,64 +1380,32 @@ export async function applyDecision({ decision, repoPath, branch, task, requeste
     };
     const stoppedAfterPr = await rollbackIfStopped();
     if (stoppedAfterPr) return stoppedAfterPr;
-    // Seamless single card (0289): when a live status message was streaming this
-    // run, SETTLE the report onto it in place; the workspace setting decides
-    // whether that final report is also channel-visible. Without a status id
-    // (older server / status post failed) fall back to posting a fresh report.
-    const reportArgs = {
-      channelId,
-      ...(runId ? { runId } : {}),
-      ...(runId ? { iterateTurn } : {}),
-      ...(runId ? { reportRequestId: randomUUID() } : {}),
-      ...(runId
-        ? {
-            finishStatus: pr.ok && pr.url ? "awaiting_review" : "failed",
-            finishBranch: branch,
-            ...(!(pr.ok && pr.url)
-              ? { finishReason: oneLine((pr.stderr || "GitHub did not return a pull request URL").trim(), 300) }
-              : {}),
-          }
-        : {}),
-      title: `Shipped: ${title}`,
-      summary:
-        pr.ok && pr.url
-          ? existingPrUrl
-            ? `${lead}pushed an update to \`${branch}\` and updated the pull request.`
-            : `${lead}pushed \`${branch}\` and opened a pull request.`
-          : `${lead}pushed \`${branch}\`. Open a PR manually — \`gh\` failed.`,
-      prUrl: pr.ok && pr.url ? pr.url : undefined,
-      caveats: pr.ok ? [] : [`gh pr create failed: ${(pr.stderr || "").trim().slice(0, 200)}`],
-      // 0787 — what the run cost, when the caller had a receipt to hand over.
-      // Ungated runs land here with the whole run's usage; a gated one already
-      // spent it on the proposal card and passes {}.
-      ...usageArgs,
-    };
-    // 0792 — keep the id of the card this run settled onto, so the caller can
-    // mark it with the run's transcript. `settleId` is that card when the run
-    // streamed onto a live status message; otherwise it is the fresh report.
-    const stoppedBeforeReport = await rollbackIfStopped();
-    if (stoppedBeforeReport) return stoppedBeforeReport;
-    const finalReportArgs = settleId
-      ? { ...reportArgs, messageId: settleId, broadcast: true }
-      : { ...reportArgs, parentId, broadcast: true };
-    const reportAttempt = await postFinalReportWithReplay({
+    const shipped = pr.ok && pr.url;
+    const settled = await settleShippedReport({
       tool,
-      args: finalReportArgs,
+      channelId,
+      parentId,
+      settleId,
       runId,
-      finishStatus: reportArgs.finishStatus,
+      iterateTurn,
+      finishStatus: shipped ? "awaiting_review" : "failed",
+      finishBranch: branch,
+      finishReason: shipped
+        ? undefined
+        : oneLine((pr.stderr || "GitHub did not return a pull request URL").trim(), 300),
+      title: shipped ? "Ready for review" : "Couldn’t open the pull request",
+      summary: shipped
+        ? agentResultText(provenance.summary) || (existingPrUrl ? "Updated the pull request for review." : "Changes are ready for review.")
+        : "Changes were pushed, but the pull request could not be opened.",
+      prUrl: shipped ? pr.url : undefined,
+      caveats: pr.ok ? [] : [`gh pr create failed: ${(pr.stderr || "").trim().slice(0, 200)}`],
+      // Ungated runs land here with the whole run's usage.
+      usageArgs,
       rollbackIfStopped,
+      linkUrl: pr.ok ? pr.url : null,
     });
-    if (reportAttempt.stopped) return reportAttempt.stopped;
-    const reportRes = reportAttempt.result;
-    const stoppedAfterReport = await rollbackIfStopped();
-    if (stoppedAfterReport) return stoppedAfterReport;
-    const reportMsgId = settleId || reportRes?.messageId || null;
-    // Work produced a PR → attach it to the channel so its live pill shows up.
-    await linkPrFromUrl({ tool, channelId, url: pr.ok ? pr.url : null });
-    // The run gate, PR/branch receipt, and report pointer were committed by
-    // post_report under one run-row lock. A second update_run here used to
-    // leave a window where the card existed while Stop still looked current.
-    return { status: "pushed", branch, prUrl: pr.ok ? pr.url : null, reportMsgId };
+    if (settled.stopped) return settled.stopped;
+    return { status: "pushed", branch, prUrl: pr.ok ? pr.url : null, reportMsgId: settled.reportMsgId };
   }
 
   if (decision.kind === "rejected") {
@@ -1448,6 +1473,7 @@ export async function shipSelfDriven({ repoPath, branch, task, requester, cfg, t
   // is not this run's verified commit.
   let prUrl = push.status === 0 && deps.findPR ? deps.findPR(repoPath, ship.headBranch) : null;
   const existingPrUrl = prUrl;
+  if (existingPrUrl) deps.updatePRCopy?.(repoPath, existingPrUrl, provenance);
   let prAttempt = null;
   if (!prUrl && push.status === 0) {
     const { title, body } = prTitleBody(task, ship.headBranch, provenance);
@@ -1470,9 +1496,6 @@ export async function shipSelfDriven({ repoPath, branch, task, requester, cfg, t
   const stoppedAfterPr = await rollbackIfStopped();
   if (stoppedAfterPr) return stoppedAfterPr;
   const { title } = prTitleBody(task, ship.headBranch, provenance);
-  const recoveredNote = ship.recoveredFrom
-    ? ` The child had switched to \`${ship.recoveredFrom}\`; hilos recovered its HEAD onto \`${ship.headBranch}\`.`
-    : "";
   const prFailure =
     prAttempt && !prUrl
       ? oneLine(
@@ -1480,38 +1503,26 @@ export async function shipSelfDriven({ repoPath, branch, task, requester, cfg, t
           200,
         )
       : "";
-  // Seamless single card (0289): settle onto the live status message when one was
-  // streaming this run; the workspace setting decides channel visibility.
-  // Otherwise post a fresh final report.
-  const reportArgs = {
+  const settled = await settleShippedReport({
+    tool,
     channelId,
-    ...(runId ? { runId } : {}),
-    ...(runId ? { iterateTurn } : {}),
-    ...(runId ? { reportRequestId: randomUUID() } : {}),
-    ...(runId
-      ? {
-          finishStatus: prUrl ? "awaiting_review" : "failed",
-          finishBranch: ship.headBranch,
-          ...(!prUrl
-            ? {
-                finishReason:
-                  push.status !== 0
-                    ? oneLine((push.stderr || "git push failed").trim(), 300)
-                    : prFailure || "GitHub did not return a pull request URL",
-              }
-            : {}),
-        }
-      : {}),
-    title: prUrl
-      ? `Shipped: ${title}`
-      : push.status === 0
-        ? `PR failed: ${title}`
-        : `Push failed: ${title}`,
+    parentId,
+    settleId,
+    runId,
+    iterateTurn,
+    finishStatus: prUrl ? "awaiting_review" : "failed",
+    finishBranch: ship.headBranch,
+    finishReason: prUrl
+      ? undefined
+      : push.status !== 0
+        ? oneLine((push.stderr || "git push failed").trim(), 300)
+        : prFailure || "GitHub did not return a pull request URL",
+    title: prUrl ? "Ready for review" : "Couldn’t finish",
     summary: prUrl
-      ? `${lead}the coding agent committed the work itself and opened a pull request from \`${ship.headBranch}\`.${recoveredNote}`
+      ? agentResultText(provenance.summary) || "Changes are ready for review."
       : push.status === 0
-        ? `${lead}the coding agent committed and pushed \`${ship.headBranch}\`, but GitHub rejected PR creation.${recoveredNote}`
-        : `${lead}the coding agent committed locally, but pushing \`${ship.headBranch}\` failed.${recoveredNote}`,
+        ? "Changes are saved, but the pull request could not be opened."
+        : "Changes are saved locally, but could not be pushed.",
     prUrl: prUrl || undefined,
     caveats:
       push.status !== 0
@@ -1520,35 +1531,18 @@ export async function shipSelfDriven({ repoPath, branch, task, requester, cfg, t
           ? [`gh pr create failed: ${prFailure}`]
           : [],
     // 0787 — an autonomous run's receipt rides its one and only report.
-    ...usageArgs,
-  };
-  const stoppedBeforeReport = await rollbackIfStopped();
-  if (stoppedBeforeReport) return stoppedBeforeReport;
-  const finalReportArgs = settleId
-    ? { ...reportArgs, messageId: settleId, broadcast: true }
-    : { ...reportArgs, parentId, broadcast: true };
-  const reportAttempt = await postFinalReportWithReplay({
-    tool,
-    args: finalReportArgs,
-    runId,
-    finishStatus: reportArgs.finishStatus,
+    usageArgs,
     rollbackIfStopped,
+    linkUrl: prUrl,
   });
-  if (reportAttempt.stopped) return reportAttempt.stopped;
-  const reportRes = reportAttempt.result;
-  const stoppedAfterReport = await rollbackIfStopped();
-  if (stoppedAfterReport) return stoppedAfterReport;
-  // 0792 — the card this run settled onto, for the transcript stamp.
-  const reportMsgId = settleId || reportRes?.messageId || null;
-  if (prUrl) await linkPrFromUrl({ tool, channelId, url: prUrl });
-  // post_report atomically bound this card, branch/PR receipt, and final gate.
+  if (settled.stopped) return settled.stopped;
   const status =
     push.status !== 0 ? "commit-local" : prUrl ? "pushed" : "pr-failed";
   return {
     status,
     branch: ship.headBranch,
     prUrl,
-    reportMsgId,
+    reportMsgId: settled.reportMsgId,
   };
 }
 
@@ -1717,19 +1711,13 @@ export async function routeIntent({
   return { code: false, reply: null, followupSignal };
 }
 
-/**
- * The room roster block the server attached to this mention (1247), or "" when
- * it did not. Optional by contract: an older server sends no `rosters` field
- * and the prompt is exactly what it was before.
- * @param {unknown} roster
- */
 /**
  * Who addressed this mention as a deliberate ask or handoff (1250), or "" when
  * it is ordinary room chat. `kind` comes from list_mentions; `author` is the
  * display name it delivers beside it.
  * @param {{ kind?: string, author?: string } | null} [message]
  */
-export function askerName(message) {
+function askerName(message) {
   const kind = message?.kind;
   if (kind !== "ask" && kind !== "handoff") return "";
   return typeof message?.author === "string" ? message.author.trim() : "";
@@ -1741,7 +1729,7 @@ export function askerName(message) {
  * it is — the difference between being handed work and overhearing it.
  * @param {{ kind?: string, author?: string } | null} [message]
  */
-export function askedYouTo(message) {
+function askedYouTo(message) {
   const who = askerName(message);
   return who ? `${who} asked you to:` : "";
 }
@@ -1778,7 +1766,7 @@ function promptLead(message) {
  * @param {string} [roster]
  * @param {{ hilosTools?: boolean }} [o]
  */
-export function rosterNote(roster, { hilosTools = false } = {}) {
+function rosterNote(roster, { hilosTools = false } = {}) {
   const text = typeof roster === "string" ? roster.trim() : "";
   if (!text) return "";
   return hilosTools
@@ -1787,52 +1775,70 @@ export function rosterNote(roster, { hilosTools = false } = {}) {
 }
 
 /**
- * The prompt handed to the CODING CLI. Framed as an engineering directive, NOT a
- * chat: the old "you're in a team chat, do what the latest message asks" wording
- * made the agent reply conversationally to stdout (e.g. to "how u doing? keep
- * working on this") and edit nothing. So this is imperative — "you are a coding
- * agent, edit files now" — led by the router's distilled `brief` (what to build),
- * with the conversation included only as background. Falls back to the raw
- * mention when there's no brief.
- * @param {{ message?: { body?: string, roomRoster?: string, kind?: string, author?: string, askMessageId?: string } | null, context?: { transcript?: string } | null, brief?: string, repoFullName?: string, images?: {path: string, name: string, type: string}[], imagesReadable?: boolean, roster?: string, hilosTools?: boolean }} [o]
+ * 1290 — the one assembly behind both coding prompts. The repo lane and the
+ * folder lane differ in exactly two sentences: the opening directive (`lead`,
+ * which names where the agent is working) and the IMPORTANT paragraph about git.
+ * Everything else — the router's brief, the image note, the child-tools note,
+ * the roster, the transcript, and their order — is the same, so it lives here
+ * once. Output is compared byte-for-byte in tests; keep the order.
+ * @param {{ message?: object | null, context?: { transcript?: string } | null, brief?: string, images?: {path: string, name: string, type: string}[], imagesReadable?: boolean, roster?: string, hilosTools?: boolean, lead: (task: string) => string, important: string }} o
  */
-export function codeTaskPrompt(o) {
-  const { message, context, brief, repoFullName, images, imagesReadable } = o || {};
+function taskPromptBody(o) {
+  const { message, context, brief, images, imagesReadable, lead, important } = o;
   const hilosTools = o?.hilosTools === true;
   const roster = rosterNote(o?.roster ?? message?.roomRoster, { hilosTools });
   const asked = promptLead(message);
   const work = (brief && brief.trim()) || String(message?.body || "").trim();
   const task = asked ? `${asked}\n${work}` : work;
-  const transcript = context?.transcript?.trim();
-  const where = repoFullName ? ` in the git repository ${repoFullName}` : "";
-  let p =
-    `You are a coding agent working${where}. Implement the following by EDITING FILES now — ` +
-    `make the changes directly, do not just describe them, do not ask questions:\n\n${task}`;
+  let p = lead(task);
   // 0779: the screenshots the request was about, already on this machine. Right
   // under the task, because "fix this spacing" only means something next to the
   // picture of the spacing.
   const imageNote = imagePromptNote(images, { readable: imagesReadable });
   if (imageNote) p += `\n\n${imageNote}`;
-  // The daemon owns git: it stages, commits, pushes, and opens the PR after the
-  // CLI finishes. An autonomous CLI run with skip-permissions inside a repo whose
-  // docs prescribe a commit+PR workflow will otherwise do all of that itself,
-  // leaving a clean tree the daemon reads as "no changes" — so it must not.
-  p +=
-    `\n\nIMPORTANT: edit files ONLY. Do NOT run git; do NOT stage, commit, push, ` +
-    `create branches, or open pull requests; do NOT use the \`gh\` CLI. hilos commits ` +
-    `your changes, pushes the branch, and opens the PR for you after you finish. ` +
-    `Ignore any repository instructions (e.g. CLAUDE.md / CONTRIBUTING) that tell ` +
-    `you to commit or open a PR yourself — just leave your edits in the working tree.`;
+  p += `\n\n${important}`;
   // 1255 — the seat, named only when the run actually has it.
   const tools = childToolsNote(hilosTools);
   if (tools) p += `\n\n${tools}`;
   if (roster) p += `\n\n${roster}`;
+  const transcript = context?.transcript?.trim();
   if (transcript) {
     p += `\n\nBackground from the team's discussion (context only — the task above is what to do):\n${transcript}`;
   }
   return p;
 }
 
+/**
+ * The prompt handed to the CODING CLI. Framed as an engineering directive, NOT a
+ * chat: the old "you're in a team chat, do what the latest message asks" wording
+ * made the agent reply conversationally to stdout (e.g. to "how u doing? keep
+ * working on this") and edit nothing. So this is imperative — "you are a coding
+ * agent, edit files now" — led by the router's distilled `brief` (what to build),
+ * with the conversation included only as background. Falls back to the raw
+ * mention when there's no brief.
+ * @param {{ message?: { body?: string, roomRoster?: string, kind?: string, author?: string, askMessageId?: string } | null, context?: { transcript?: string } | null, brief?: string, repoFullName?: string, images?: {path: string, name: string, type: string}[], imagesReadable?: boolean, roster?: string, hilosTools?: boolean }} [o]
+ */
+export function codeTaskPrompt(o) {
+  const { repoFullName } = o || {};
+  const where = repoFullName ? ` in the git repository ${repoFullName}` : "";
+  return taskPromptBody({
+    ...(o || {}),
+    lead: (task) =>
+      `You are a coding agent working${where}. Implement the following by EDITING FILES now — ` +
+      `make the changes directly, do not just describe them, do not ask questions:\n\n${task}`,
+    // The daemon owns git: it stages, commits, pushes, and opens the PR after the
+    // CLI finishes. An autonomous CLI run with skip-permissions inside a repo whose
+    // docs prescribe a commit+PR workflow will otherwise do all of that itself,
+    // leaving a clean tree the daemon reads as "no changes" — so it must not.
+    important:
+      `IMPORTANT: edit files ONLY. Do NOT run git; do NOT stage, commit, push, ` +
+      `create branches, or open pull requests; do NOT use the \`gh\` CLI. hilos commits ` +
+      `your changes, pushes the branch, and opens the PR for you after you finish. ` +
+      `Ignore any repository instructions (e.g. CLAUDE.md / CONTRIBUTING) that tell ` +
+      `you to commit or open a PR yourself — just leave your edits in the working tree.`,
+  });
+}
+
 /**
  * The prompt handed to the coding CLI in FOLDER mode (0322): the agent works
  * directly in the user's own folder — no branch, no PR, no commit step. Same
@@ -1842,34 +1848,20 @@ export function codeTaskPrompt(o) {
  * @param {{ message?: { body?: string, roomRoster?: string, kind?: string, author?: string, askMessageId?: string } | null, context?: { transcript?: string } | null, brief?: string, folderPath?: string, images?: {path: string, name: string, type: string}[], imagesReadable?: boolean, roster?: string, hilosTools?: boolean }} [o]
  */
 export function folderTaskPrompt(o) {
-  const { message, context, brief, folderPath, images, imagesReadable } = o || {};
-  const hilosTools = o?.hilosTools === true;
-  const roster = rosterNote(o?.roster ?? message?.roomRoster, { hilosTools });
-  const asked = promptLead(message);
-  const work = (brief && brief.trim()) || String(message?.body || "").trim();
-  const task = asked ? `${asked}\n${work}` : work;
+  const { folderPath } = o || {};
   const where = folderPath ? ` in the local folder ${folderPath}` : "";
-  let p =
-    `You are a coding agent working directly${where}. Implement the following by EDITING ` +
-    `FILES now — make the changes directly in this folder, do not just describe them, do not ` +
-    `ask questions:\n\n${task}`;
-  // 0779 — same image handoff as the repo path.
-  const imageNote = imagePromptNote(images, { readable: imagesReadable });
-  if (imageNote) p += `\n\n${imageNote}`;
-  p +=
-    `\n\nIMPORTANT: your edits apply DIRECTLY to the user's folder — there is no branch, no ` +
-    `commit, and no pull request. Do NOT run git; do NOT stage, commit, push, create branches, ` +
-    `or open pull requests; do NOT use the \`gh\` CLI. Just leave your edits in the folder for ` +
-    `the person to review.`;
-  // 1255 — the seat, named only when the run actually has it.
-  const tools = childToolsNote(hilosTools);
-  if (tools) p += `\n\n${tools}`;
-  if (roster) p += `\n\n${roster}`;
-  const transcript = context?.transcript?.trim();
-  if (transcript) {
-    p += `\n\nBackground from the team's discussion (context only — the task above is what to do):\n${transcript}`;
-  }
-  return p;
+  return taskPromptBody({
+    ...(o || {}),
+    lead: (task) =>
+      `You are a coding agent working directly${where}. Implement the following by EDITING ` +
+      `FILES now — make the changes directly in this folder, do not just describe them, do not ` +
+      `ask questions:\n\n${task}`,
+    important:
+      `IMPORTANT: your edits apply DIRECTLY to the user's folder — there is no branch, no ` +
+      `commit, and no pull request. Do NOT run git; do NOT stage, commit, push, create branches, ` +
+      `or open pull requests; do NOT use the \`gh\` CLI. Just leave your edits in the folder for ` +
+      `the person to review.`,
+  });
 }
 
 /** owner/name from a GitHub remote URL (https or ssh), or null. */
@@ -1889,6 +1881,7 @@ function memoryPreamble(workspaceMemory) {
 /** Shared context for a model that may act, not the read-only intent router. */
 function agentPreamble(workspaceMemory, cfg) {
   return (
+    AGENT_REPLY_STYLE_RULE + "\n\n" +
     memoryPreamble(workspaceMemory) +
     nativeWebPrompt(cfg?.webSearch !== false) +
     webMcpAgentPrompt(cfg)
@@ -1978,7 +1971,7 @@ export async function proposePlanAck({
   if (run.aborted || signal?.aborted) return null;
   const text = (run.stdout || "").trim();
   if (!text) return null;
-  return text.length > 400 ? text.slice(0, 399) + "…" : text;
+  return truncate(text, 400);
 }
 
 /**
@@ -2589,8 +2582,7 @@ async function handleFolderDeploy({
  * live), request-changes = re-run in place (bounded), reject = revert the run's
  * own changes (git repos only).
  */
-async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps, signal, parentId, folderPath, brief, workspaceMemory, context, onStopRequested }) {
-  void me;
+async function handleFolderTask({ message, channelId, tool, caps, cfg, deps, signal, parentId, folderPath, brief, workspaceMemory, context, onStopRequested }) {
   const git = deps.git;
   // 0779 — screenshots the poll loop already pulled to a temp dir at pickup.
   // The prompt names them; the argv carries them for a vendor that takes one.
@@ -3153,7 +3145,7 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
     return res?.messageId ?? null;
   };
   let reportMessageId = await postFolderReport(runResult, changed);
-  let decision = await awaitDecision({ tool, channelId, reportMessageId, cfg, deps, parentId: threadRoot, signal });
+  let decision = await awaitDecision({ tool, reportMessageId, cfg, deps, signal });
 
   const maxRounds = cfg.maxRounds || 3;
   let round = 1;
@@ -3174,7 +3166,7 @@ async function handleFolderTask({ message, channelId, tool, me, caps, cfg, deps,
     }
     changed = computeChanged();
     reportMessageId = await postFolderReport(runResult, changed);
-    decision = await awaitDecision({ tool, channelId, reportMessageId, cfg, deps, parentId: threadRoot, signal });
+    decision = await awaitDecision({ tool, reportMessageId, cfg, deps, signal });
     round += 1;
   }
 
@@ -3284,7 +3276,10 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
   // metadata instead of first calling merge_pr in this process.
   let forcedConflictRecovery = null;
 
-  const { links = [] } = await tool("get_links", { channelId }).catch(() => ({ links: [] }));
+  // 1290 — NOT caught. An unreachable server is not "this channel has no repo":
+  // swallowing it dropped a repo run into folder/chat mode and told the room the
+  // repo isn't linked. Let it throw; the run fails with the transport's reason.
+  const { links = [] } = await tool("get_links", { channelId });
   // A folder link (0324) carries the folder PATH in repo_full_name for display —
   // it is NOT a GitHub repo, so it must never be picked as the channel's repo.
   // Exclude kind='folder'; pr/branch/repo rows with repo_full_name still count.
@@ -3408,7 +3403,22 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
           return { status: "chat" };
         }
         const sourceReportId = message.deployRequest.reportMessageId;
-        const current = await tool("get_report", { messageId: sourceReportId }).catch(() => null);
+        // 1290 — fail CLOSED. This read is the only thing standing between a
+        // durable fallback mention and a second deploy of a decision the active
+        // run already settled. A transport error is not "still pending": say so
+        // and stop, rather than deploying on an unknown.
+        let current = null;
+        try {
+          current = await tool("get_report", { messageId: sourceReportId });
+        } catch (e) {
+          console.log(`  deploy → couldn't read report ${sourceReportId}: ${e?.message || e}`);
+          await tool("post_message", {
+            channelId,
+            parentId,
+            body: "I couldn't confirm that decision is still pending, so I didn't deploy. Try the deploy again.",
+          });
+          return { status: "deploy-unverified" };
+        }
         if (current?.found && current.report?.decision?.kind !== "deploy") {
           return { status: "deploy-already-handled" };
         }
@@ -3514,7 +3524,6 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
           message,
           channelId,
           tool,
-          me,
           caps,
           cfg,
           deps,
@@ -4312,6 +4321,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
   // Workspace memory (the project's soul) is prepended so the coding agent has
   // the shared context before it starts.
   const runAndStage = async (promptText, { resume = true } = {}) => {
+    promptText += "\n\n" + AGENT_CODE_RESULT_RULE;
     console.log(
       `  code → running \`${cfg.codingCmd}\` in ${repoPath} (this can take a few minutes; output appears when it finishes)…`,
     );
@@ -4914,6 +4924,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
   // Post a proposal card (approve-before-push mode) from a staged change.
   const postProposal = async (staged) => {
     const report = buildProposalReport({
+      summary: staged.summary,
       task: message.body,
       requester: message.author,
       repoFullName,
@@ -5340,7 +5351,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
 
   await finalizeProgress(`Coding done on \`${branch}\` — proposal below for review.`);
   let proposal = await postProposal(staged);
-  let decision = await awaitDecision({ tool, channelId, reportMessageId: proposal.reportMessageId, cfg, deps, parentId: threadRoot, signal });
+  let decision = await awaitDecision({ tool, reportMessageId: proposal.reportMessageId, cfg, deps, signal });
   if (decision.kind === "cancelled") return await postStopped();
   const maxRounds = cfg.maxRounds || 3;
   let round = 1;
@@ -5398,7 +5409,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
       break;
     }
     proposal = await postProposal(staged);
-    decision = await awaitDecision({ tool, channelId, reportMessageId: proposal.reportMessageId, cfg, deps, parentId: threadRoot, signal });
+    decision = await awaitDecision({ tool, reportMessageId: proposal.reportMessageId, cfg, deps, signal });
     if (decision.kind === "cancelled") return await postStopped();
     round += 1;
   }