hilos-agent 0.1.8 → 0.1.9

package/package.json

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

@@ -226,6 +226,28 @@ export function agentProposedWork(rows, agentName) {
   );
 }
 
+/**
+ * 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.
+ */
+export function codeTaskPrompt({ message, context }) {
+  const body = 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.`
+  );
+}
+
 /** owner/name from a GitHub remote URL (https or ssh), or null. */
 export function normalizeRemote(url) {
   const m = String(url || "")
@@ -393,16 +415,20 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   const { memory: workspaceMemory = null } = await tool("get_workspace_memory", {}).catch(() => ({
     memory: null,
   }));
+  // The conversation the agent is replying within — fetched ONCE and handed to
+  // BOTH the chat reply and the coding prompt. Context is always crucial: 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. The chat path
+  // always had this; the code path used to run on the bare mention alone (so
+  // "go for it" reached the agent with no spec → nothing built). Now both share it.
+  const context = await fetchContext({ channelId, tool, parentId });
   // Chat vs code. A clear action verb → code. With a repo linked, a bare
   // affirmation ("go", "ship it") that follows a plan the agent just proposed
   // ALSO means "execute it" → code path. Otherwise (greeting/question/no repo) →
-  // a conversational reply. We fetch context once here and hand it to the chat
-  // reply so it isn't fetched twice.
+  // a conversational reply.
   let isCode = looksLikeCodeTask(message.body);
-  let context = null;
-  if (!isCode && repoLink && isAffirmation(message.body)) {
-    context = await fetchContext({ channelId, tool, parentId });
-    if (agentProposedWork(context.rows, me?.agentName)) isCode = true;
+  if (!isCode && repoLink && isAffirmation(message.body) && agentProposedWork(context.rows, me?.agentName)) {
+    isCode = true;
   }
   if (!repoLink || !isCode) {
     await respondConversationally({ message, channelId, tool, me, cfg, repoLink, parentId, workspaceMemory, signal, context, caps });
@@ -630,7 +656,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     return { status: "cancelled", branch };
   };
 
-  const staged = await runAndStage(message.body);
+  const staged = await runAndStage(codeTaskPrompt({ message, context }));
   if (staged.aborted) return await postStopped();
   if (staged.empty) {
     let body;