hilos-agent 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions in channels and threads, makes the change, and opens a PR for review — your code and credentials never leave your machine. (Approve-before-push is available via gate:true.)",
   "type": "module",
   "bin": {

package/src/handler.mjs

@@ -104,12 +104,16 @@ async function linkPrFromUrl({ tool, channelId, url }) {
 async function applyDecision({ decision, repoPath, branch, task, requester, cfg, tool, channelId, deps, parentId }) {
   const tag = requesterTag(requester);
   const lead = tag ? `${tag} — ` : "";
+  // `parentId` here is the run's thread root: every outcome below is terminal, so
+  // it broadcasts back to the channel (visible in both thread and channel) — the
+  // hosted runner's reply_broadcast. A no-op when there's no thread root.
   if (decision.kind === "approved") {
     // Guard: nothing staged → don't push an empty branch and falsely report "shipped".
     if (deps.git(repoPath, ["diff", "--cached", "--quiet"]).status === 0) {
       await tool("post_message", {
         channelId,
         parentId,
+        broadcast: true,
         body: `Approved, but there are no staged changes to commit on \`${branch}\`.`,
       });
       return { status: "nothing-staged", branch };
@@ -119,6 +123,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
       await tool("post_message", {
         channelId,
         parentId,
+        broadcast: true,
         body: `Approved, but the commit failed: ${(commit.stderr || "").trim().slice(0, 300)}`,
       });
       return { status: "commit-failed", branch };
@@ -128,6 +133,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
       await tool("post_message", {
         channelId,
         parentId,
+        broadcast: true,
         body: `Approved, but the push failed: ${(push.stderr || "").trim().slice(0, 300)}`,
       });
       return { status: "push-failed", branch };
@@ -137,6 +143,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
     await tool("post_report", {
       channelId,
       parentId,
+      broadcast: true,
       title: `Shipped: ${title}`,
       summary:
         pr.ok && pr.url
@@ -155,7 +162,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
     deps.git(repoPath, ["clean", "-fd"]);
     deps.git(repoPath, ["switch", "-"]);
     deps.git(repoPath, ["branch", "-D", branch]);
-    await tool("post_message", { channelId, parentId, body: `Rejected — discarded \`${branch}\`.` });
+    await tool("post_message", { channelId, parentId, broadcast: true, body: `Rejected — discarded \`${branch}\`.` });
     return { status: "discarded", branch };
   }
 
@@ -163,6 +170,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
     await tool("post_message", {
       channelId,
       parentId,
+      broadcast: true,
       body: `Got it${decision.note ? `: ${decision.note}` : ""}. Leaving \`${branch}\` for a follow-up.`,
     });
     return { status: "changes", branch, note: decision.note };
@@ -171,6 +179,7 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
   await tool("post_message", {
     channelId,
     parentId,
+    broadcast: true,
     body: `Still awaiting review on \`${branch}\`. Re-mention me once you've decided.`,
   });
   return { status: "timeout", branch };
@@ -201,6 +210,7 @@ async function shipSelfDriven({ repoPath, branch, task, requester, cfg, tool, ch
   await tool("post_report", {
     channelId,
     parentId,
+    broadcast: true,
     title: `Shipped: ${title}`,
     summary: prUrl
       ? `${lead}the coding agent committed on \`${cur}\` and opened a pull request.`
@@ -254,6 +264,8 @@ async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cf
     `Otherwise — a question, a greeting, general discussion, or they explicitly don't want code ` +
     `yet — just reply to them concisely and directly as a single chat message (no preamble, no ` +
     `headings). When unsure, prefer to act (${CODE_SIGNAL}); this is a build channel.\n\n` +
+    `You are only routing here — output ONLY your text response. Do NOT use any tools, do NOT ` +
+    `edit files, do NOT run commands; a separate step does the actual coding.\n\n` +
     `${memoryPreamble(workspaceMemory)}Conversation so far:\n${transcript}`;
   const run = await runCli({
     cmd: parts[0],
@@ -265,9 +277,16 @@ async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cf
   if (run.aborted || signal?.aborted) return { aborted: true };
   const out = (run.stdout || "").trim();
   if (!out) return { code: false, reply: null, error: run.error || new Error("no output") };
-  if (new RegExp(`^${CODE_SIGNAL}\\b`).test(out)) {
-    const nl = out.indexOf("\n");
-    return { code: true, task: nl >= 0 ? out.slice(nl + 1).trim() : "" };
+  // Accept the sentinel ANYWHERE, not just the first line — models sometimes add a
+  // line of preamble before it ("Got it, …\n__CODE__\n<brief>"). If it appears,
+  // it's a code run; the brief is whatever follows the sentinel's line and any
+  // preamble before it is discarded. This is also what keeps the raw sentinel out
+  // of a chat message (markdown would render `__CODE__` as a bold "CODE").
+  const idx = out.indexOf(CODE_SIGNAL);
+  if (idx >= 0) {
+    const after = out.slice(idx + CODE_SIGNAL.length);
+    const nl = after.indexOf("\n");
+    return { code: true, task: (nl >= 0 ? after.slice(nl + 1) : after).trim() };
   }
   return { code: false, reply: out };
 }
@@ -559,23 +578,55 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     await tool("post_message", { channelId, parentId, body: `Can't read git status in ${repoPath}.` });
     return { status: "git-error" };
   }
+  // Remember where we started so cancel/cleanup/stash-restore can switch back
+  // explicitly (relying on `git switch -` breaks from a detached HEAD).
+  const symref = git(repoPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const startRef =
+    symref.status === 0 && symref.stdout.trim()
+      ? { kind: "branch", ref: symref.stdout.trim() }
+      : { kind: "detached", ref: (git(repoPath, ["rev-parse", "HEAD"]).stdout || "").trim() };
+
+  // A dirty tree used to be a hard stop ("commit or stash first"). But the daemon
+  // runs in the user's own checkout, so that was a constant wall — and the user
+  // can't make the agent clear it. Instead: stash the uncommitted work, run on a
+  // clean branch, and restore it (git stash pop) on the original branch when done.
+  let stashed = false;
   if (status.stdout.trim()) {
+    const st = git(repoPath, ["stash", "push", "-u", "-m", "hilos: auto-stash before agent run"]);
+    if (st.status !== 0) {
+      await tool("post_message", {
+        channelId,
+        parentId,
+        body: `Working tree at ${repoPath} is dirty and I couldn't stash it (${(st.stderr || "").trim().slice(0, 200)}). Commit or stash, then mention me again.`,
+      });
+      return { status: "dirty" };
+    }
+    stashed = true;
     await tool("post_message", {
       channelId,
       parentId,
-      body: `Working tree at ${repoPath} is dirty — commit or stash first.`,
+      body: `Your working tree was dirty — I stashed your uncommitted changes so I can work on a clean branch, and I'll restore them when I'm done.`,
     });
-    return { status: "dirty" };
   }
+  // Restore the stash onto the original branch. Best-effort: a pop conflict (rare —
+  // the daemon's work lands on its own branch, not here) leaves the stash for the
+  // user. Called from `finally` so every exit path restores.
+  const restoreStash = async () => {
+    if (!stashed) return;
+    if (startRef.ref) {
+      git(repoPath, startRef.kind === "branch" ? ["switch", "--force", startRef.ref] : ["switch", "--detach", startRef.ref]);
+    }
+    const pop = git(repoPath, ["stash", "pop"]);
+    if (pop.status !== 0) {
+      await tool("post_message", {
+        channelId,
+        parentId,
+        body: `Heads up: I couldn't auto-restore your stashed changes (conflict). They're safe — run \`git stash pop\` in ${repoPath} when you're ready.`,
+      }).catch(() => {});
+    }
+  };
 
-  // Remember where we started so cancel/cleanup can switch back explicitly
-  // (relying on `git switch -` breaks from a detached HEAD).
-  const symref = git(repoPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-  const startRef =
-    symref.status === 0 && symref.stdout.trim()
-      ? { kind: "branch", ref: symref.stdout.trim() }
-      : { kind: "detached", ref: (git(repoPath, ["rev-parse", "HEAD"]).stdout || "").trim() };
-
+  try {
   const branch = branchSlug(message.body, randomBytes(3).toString("hex"));
   git(repoPath, ["fetch", "origin", cfg.defaultBranch]);
   const co = git(repoPath, ["switch", "-c", branch]);
@@ -594,6 +645,13 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   // Best-effort — a slow or failed ack just leaves the template, never blocks.
   const ack = await tool("post_message", { channelId, parentId, body: ackText(repoFullName) });
   const ackId = ack?.messageId ?? null;
+  // Where the run streams + reports. When the mention was already in a thread,
+  // stay in it. When it was top-level, the ack becomes the thread anchor so the
+  // progress worklog and the report card live UNDER it — one tidy thread instead
+  // of three separate top-level posts — exactly like the hosted/native runner.
+  // The ack itself stays top-level (the channel-visible "on it"); terminal
+  // outcomes + report cards broadcast back to the channel from the thread.
+  const threadRoot = parentId ?? ackId;
   if (ackId && caps.editMessage && cfg.chatCmd) {
     // 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?".
@@ -625,7 +683,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
       const body = buildHeartbeat({ repoFullName, branch, elapsedMs: deps.now() - start, lastLine });
       try {
         if (!progressId) {
-          const r = await tool("post_message", { channelId, parentId, body });
+          // Progress is the worklog — it streams in the thread only (no broadcast).
+          const r = await tool("post_message", { channelId, parentId: threadRoot, body });
           progressId = r?.messageId ?? null;
         } else {
           await tool("edit_message", { messageId: progressId, body });
@@ -733,7 +792,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
       stat: staged.stat,
       runFailed: staged.runFailed,
     });
-    const res = await tool("post_report", { channelId, parentId, ...report });
+    const res = await tool("post_report", { channelId, parentId: threadRoot, broadcast: true, ...report });
     return { reportMessageId: res?.messageId ?? null, stat: staged.stat };
   };
 
@@ -764,7 +823,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     const clean = discardBranch();
     await tool("post_message", {
       channelId,
-      parentId,
+      parentId: threadRoot,
+      broadcast: true,
       body: clean
         ? `Stopped — discarded \`${branch}\`.`
         : `Stopped, but couldn't fully clean \`${branch}\` — run \`git reset --hard && git switch ${startRef.ref || cfg.defaultBranch}\` in ${repoPath}.`,
@@ -782,7 +842,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
       // honest and let the human review instead of auto-shipping. Leave the branch.
       await tool("post_message", {
         channelId,
-        parentId,
+        parentId: threadRoot,
+        broadcast: true,
         body:
           `The coding agent committed on \`${branch}\` itself (I asked it to only edit files). ` +
           `Under approve-before-push I won't auto-push it — review \`${branch}\` locally, then ` +
@@ -801,7 +862,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
       tool,
       channelId,
       deps,
-      parentId,
+      parentId: threadRoot,
     });
   }
   if (staged.empty) {
@@ -819,7 +880,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     } else {
       body = `No changes were produced. Cleaning up \`${branch}\`.`;
     }
-    await tool("post_message", { channelId, parentId, body });
+    await tool("post_message", { channelId, parentId: threadRoot, broadcast: true, body });
     await finalizeProgress(
       staged.failed ? `Run ended early on \`${branch}\` — see the note below.` : `No changes needed on \`${branch}\`.`,
     );
@@ -844,7 +905,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
       tool,
       channelId,
       deps,
-      parentId,
+      parentId: threadRoot,
     });
     await finalizeProgress(`Done on \`${branch}\` — see the report below.`);
     return { ...result, stat: staged.stat };
@@ -852,14 +913,14 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
 
   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, signal });
+  let decision = await awaitDecision({ tool, channelId, reportMessageId: proposal.reportMessageId, cfg, deps, parentId: threadRoot, signal });
   if (decision.kind === "cancelled") return await postStopped();
   const maxRounds = cfg.maxRounds || 3;
   let round = 1;
   while (decision.kind === "changes" && round < maxRounds) {
     await tool("post_message", {
       channelId,
-      parentId,
+      parentId: threadRoot,
       body: `Revising with your feedback${decision.note ? `: ${decision.note}` : ""} (round ${round + 1}/${maxRounds}).`,
     });
     const refined = await runAndStage(
@@ -869,13 +930,14 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     if (refined.empty) {
       await tool("post_message", {
         channelId,
-        parentId,
+        parentId: threadRoot,
+        broadcast: true,
         body: `That feedback produced no further changes — leaving \`${branch}\` as proposed.`,
       });
       break;
     }
     proposal = await postProposal(refined);
-    decision = await awaitDecision({ tool, channelId, reportMessageId: proposal.reportMessageId, cfg, deps, parentId, signal });
+    decision = await awaitDecision({ tool, channelId, reportMessageId: proposal.reportMessageId, cfg, deps, parentId: threadRoot, signal });
     if (decision.kind === "cancelled") return await postStopped();
     round += 1;
   }
@@ -892,8 +954,12 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     tool,
     channelId,
     deps,
-    parentId,
+    parentId: threadRoot,
   });
   await finalizeProgress(`Done on \`${branch}\` — see the report below.`);
   return { ...result, reportMessageId: proposal.reportMessageId, stat: proposal.stat, rounds: round };
+  } finally {
+    // Whatever happened, give the user their uncommitted work back.
+    await restoreStash();
+  }
 }