hilos-agent 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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

@@ -254,6 +254,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 +267,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 +568,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]);
@@ -896,4 +937,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   });
   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();
+  }
 }