hilos-agent 0.1.10 → 0.1.12

package/package.json

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

@@ -171,14 +171,19 @@ const CODE_SIGNAL = "__CODE__";
 
 /**
  * Decide — with the LLM, not a word list — whether the latest message wants a
- * code change or a conversational reply, and (for chat) produce that reply in the
- * SAME call. The model reads the whole conversation, so it judges by intent and
+ * code change or a conversational reply, and produce the payload in the SAME
+ * call. The model reads the whole conversation, so it judges by intent and
  * context, in any language: "just code it", "dale, hazlo", "yeah go for it" after
  * a request → code; "how does this work?", "thoughts?", "thanks" → chat.
  *
+ * For a code request it ALSO distills an imperative task brief — resolving
+ * references like "this" / "keep working on it" against the conversation — so the
+ * coding agent gets a clean spec instead of a noisy transcript (which, with the
+ * agent's own past "no changes" messages in it, made it reply instead of edit).
+ *
  * Returns one of:
  *   { aborted: true }
- *   { code: true }                 → run the coding flow
+ *   { code: true, task }           → run the coding flow with `task` as the spec
  *   { code: false, reply, error }  → post `reply` as a chat message
  *
  * `error` is set when the model produced nothing (so the caller can be honest
@@ -192,8 +197,11 @@ async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cf
     `${repoFullName}. Read the conversation and judge what the LATEST message wants from you.\n\n` +
     `If it is asking you to make a code or repository change — implement/fix/refactor/adjust ` +
     `something, continue or finish work discussed above, or give a go-ahead to act ("yeah, do ` +
-    `it", "go for it", "just code it", "approved", "dale", in ANY language) — respond with ` +
-    `EXACTLY this and nothing else:\n${CODE_SIGNAL}\n\n` +
+    `it", "go for it", "just code it", "approved", "dale", in ANY language) — respond with the ` +
+    `token ${CODE_SIGNAL} on the FIRST line, then on the next lines a short, imperative spec of ` +
+    `exactly what to build or change, resolving any references ("this", "keep working on it") ` +
+    `using the conversation. Example:\n${CODE_SIGNAL}\nAdd a hover popover to message reactions ` +
+    `that lists who reacted with each emoji.\n\n` +
     `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` +
@@ -208,30 +216,35 @@ 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)) return { code: true };
+  if (new RegExp(`^${CODE_SIGNAL}\\b`).test(out)) {
+    const nl = out.indexOf("\n");
+    return { code: true, task: nl >= 0 ? out.slice(nl + 1).trim() : "" };
+  }
   return { code: false, reply: out };
 }
 
 /**
- * The task text handed to the coding CLI. The mention is always the instruction,
- * but it's almost never self-contained: a reply like "yeah, do it" only means
- * something against what was just said, and even a direct request is clearer with
- * the surrounding discussion. So we ALWAYS prepend the recent conversation when we
- * have it — the same context the chat path already gets. Falls back to the bare
- * mention only when there's no transcript at all.
+ * 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 } | null, context?: { transcript?: string } | null, brief?: string, repoFullName?: string }} [o]
  */
-export function codeTaskPrompt({ message, context }) {
-  const body = String(message?.body || "").trim();
+export function codeTaskPrompt(o) {
+  const { message, context, brief, repoFullName } = o || {};
+  const task = (brief && brief.trim()) || String(message?.body || "").trim();
   const transcript = context?.transcript?.trim();
-  if (!transcript) return body;
-  return (
-    `You're acting on a request in a team chat. Recent conversation (oldest first):\n` +
-    `${transcript}\n\n` +
-    `The latest message is your instruction: "${body}". Do what it asks, using the ` +
-    `conversation above for context — it often carries the actual spec (e.g. a reply ` +
-    `like "go for it" refers to what was just discussed). Make the change directly; ` +
-    `it will be opened as a PR for review.`
-  );
+  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}`;
+  if (transcript) {
+    p += `\n\nBackground from the team's discussion (context only — the task above is what to do):\n${transcript}`;
+  }
+  return p;
 }
 
 /** owner/name from a GitHub remote URL (https or ssh), or null. */
@@ -267,20 +280,38 @@ async function fetchContext({ channelId, tool, parentId }) {
   return { rows, transcript: rows.map((m) => `${m.author}: ${m.body}`).join("\n").slice(-6000) };
 }
 
+/**
+ * Prompt for the fast "here's my plan" ack. Carries the distilled task AND the
+ * conversation as background, so the ack is specific ("On it — I'll add X…")
+ * instead of asking for context it was already handed. (The old bug: fed only the
+ * bare mention, it replied "can't see the channel message yet.")
+ * @param {{ task?: string, transcript?: string, repoFullName?: string }} [o]
+ */
+export function planAckPrompt(o) {
+  const { task, transcript, repoFullName } = o || {};
+  const where = repoFullName ? ` in the repo ${repoFullName}` : "";
+  let p =
+    `A teammate asked you to do this${where}:\n"${(task || "").trim()}"\n\n` +
+    `Reply with ONE or TWO short sentences, first person: acknowledge, state your ` +
+    `plan, and say you'll open a PR and report back. No preamble, no lists, no code. ` +
+    `Tone: "On it — I'll add X by doing Y. I'll open a PR and report back."`;
+  const t = (transcript || "").trim();
+  if (t) {
+    p += `\n\nConversation so far (background — resolve references like "this" against it):\n${t}`;
+  }
+  return p;
+}
+
 /**
  * A 1–2 sentence "here's my plan" line for the instant ack, via the FAST chat
  * CLI. Bounded (≤45s) + best-effort: returns trimmed text, or null on
  * empty/timeout/error so the run keeps the instant template and never stalls.
  */
-async function proposePlanAck({ task, repoFullName, cfg, signal }) {
+async function proposePlanAck({ task, transcript, repoFullName, cfg, signal }) {
   const cmd = cfg.chatCmd;
   if (!cmd) return null;
   const parts = cmd.split(" ").filter(Boolean);
-  const prompt =
-    `A teammate asked you to do this in the repo ${repoFullName}:\n"${task}"\n\n` +
-    `Reply with ONE or TWO short sentences, first person: acknowledge, state your ` +
-    `plan, and say you'll open a PR and report back. No preamble, no lists, no code. ` +
-    `Tone: "On it — I'll add X by doing Y. I'll open a PR and report back."`;
+  const prompt = planAckPrompt({ task, transcript, repoFullName });
   const run = await runCli({
     cmd: parts[0],
     args: [...parts.slice(1), prompt],
@@ -505,7 +536,15 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   const ack = await tool("post_message", { channelId, parentId, body: ackText(repoFullName) });
   const ackId = ack?.messageId ?? null;
   if (ackId && caps.editMessage && cfg.chatCmd) {
-    const plan = await proposePlanAck({ task: message.body, repoFullName, cfg, signal }).catch(() => null);
+    // 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({
+      task: routed.task || message.body,
+      transcript: context.transcript,
+      repoFullName,
+      cfg,
+      signal,
+    }).catch(() => null);
     if (plan && !signal?.aborted) await tool("edit_message", { messageId: ackId, body: plan }).catch(() => {});
   }
 
@@ -663,7 +702,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     return { status: "cancelled", branch };
   };
 
-  const staged = await runAndStage(codeTaskPrompt({ message, context }));
+  const staged = await runAndStage(codeTaskPrompt({ message, context, brief: routed.task, repoFullName }));
   if (staged.aborted) return await postStopped();
   if (staged.empty) {
     let body;