hilos-agent 0.1.7 → 0.1.9

package/README.md

@@ -43,11 +43,27 @@ Running from elsewhere, or want to map several repos explicitly? Use a config:
   "token": "mgo_…",
   "repos": { "your-org/your-repo": "/Users/you/code/your-repo" },
   "codingCmd": "claude -p --permission-mode acceptEdits",  // safe default; see Permissions / autonomy. or "codex exec", "cursor-agent", any command
+  "chatCmd": "claude -p --model claude-haiku-4-5",  // FAST command for chat replies + the plan-ack (set if your stack isn't Claude)
   "defaultBranch": "main",
-  "gate": false                // default: open a PR directly. true = approve-before-push
+  "gate": false,               // default: open a PR directly. true = approve-before-push
+  "heartbeatMs": 180000,       // long runs post one "still working…" thread reply this often (0 = off, min 15s)
+  "chatTimeoutMs": 90000       // cap a chat reply / plan-ack so a stalled model can't go silent
 }
 ```
 
+**Staying responsive.** Every code task posts an **instant acknowledgement**
+(under a second), and — if your server exposes `edit_message` and a `chatCmd` is
+set — a quick **plan** ("On it — I'll do X, then open a PR") edits into it. On a
+run longer than `heartbeatMs` (default 3 min; env `HILOS_HEARTBEAT_MS`, `0`
+disables, clamped to ≥15s) the agent posts **one progress reply** in the thread
+then edits it in place with elapsed time + the CLI's latest line — so the channel
+shows it's alive without thread spam. When the run ends, that message is retired
+to a short "done" line. A run that **times out or errors** says so honestly (with
+a stderr tail) instead of claiming "no changes". Chat replies use the faster
+`chatCmd` (default Haiku; falls back to `codingCmd` if unset) bounded by
+`chatTimeoutMs`. The responsive surface needs a hilos server new enough to expose
+`edit_message`; older servers just skip the live edits.
+
 ```sh
 hilos-agent          # watch every channel the agent is in
 hilos-agent --channel <id>   # scope to one channel
@@ -67,6 +83,16 @@ hilos-agent --channel <id>   # scope to one channel
   card and polls for your decision; **Approve** pushes + opens the PR, **Reject**
   discards the branch, **Request changes** re-runs with your note (bounded rounds).
 
+## Model & permissions
+
+You don't have to hand-write `codingCmd`: the agent's **Connect via MCP** panel in
+hilos has **Model** (Vendor default / Opus / Sonnet / Haiku) and **Permissions**
+(Ask before edits / Auto-approve edits / Skip all prompts) pickers that bake your
+choice into the generated `--coding-cmd`. Change it later by editing `codingCmd` in
+`hilos-agent.json` — the daemon re-reads the file between polls and applies it
+without a restart (your `url`/`token` are never affected). The next section
+explains what each permission level means.
+
 ## Permissions / autonomy
 
 `codingCmd` decides how much the coding agent can do on its own. Three levels,
@@ -107,7 +133,7 @@ or `HILOS_TOKEN`, never in shared shell history.
 ## Flags
 
 `--join <blob>` · `--channel <id>` · `--config <path>` · `--coding-cmd <cmd>` ·
-`--once` · `--backfill` · `--no-gate` · `--help`
+`--chat-cmd <cmd>` · `--once` · `--backfill` · `--no-gate` · `--help`
 
 Env: `HILOS_TOKEN`, `HILOS_URL`, `HILOS_CHANNEL`, `CODING_CMD`, `HILOS_ONCE=1`,
 `HILOS_BACKFILL=1`.

package/bin/hilos-agent.mjs

@@ -12,6 +12,9 @@
 // Config (./hilos-agent.json or ~/.hilos/agent.json), overlaid by env + flags:
 //   { "url", "token", "channelId", "repos": {"owner/name":"/abs/path"},
 //     "codingCmd": "claude -p", "defaultBranch": "main", "gate": true }
+// The connect link bakes your model + permission choice into --coding-cmd; edit
+// codingCmd in hilos-agent.json to change it and the daemon picks it up on its
+// next poll — no restart needed.
 
 import { resolveConfig, decodeJoin, writeStarterConfig, GLOBAL_CONFIG } from "../src/config.mjs";
 import { run } from "../src/run.mjs";
@@ -27,6 +30,7 @@ function parseArgs(argv) {
     else if (a === "--url") flags.url = argv[++i];
     else if (a === "--token") flags.token = argv[++i];
     else if (a === "--coding-cmd") flags.codingCmd = argv[++i];
+    else if (a === "--chat-cmd") flags.chatCmd = argv[++i];
     else if (a === "--once") flags.once = true;
     else if (a === "--backfill") flags.backfill = true;
     else if (a === "--no-gate") flags.gate = false;
@@ -46,6 +50,8 @@ Options:
   --channel <id>     watch only one channel (per-channel override)
   --config <path>    use a specific config file
   --coding-cmd <cmd> the coding agent to run (default: "claude -p")
+  --chat-cmd <cmd>   fast command for chat replies + the plan-ack
+                     (default: "claude -p --model claude-haiku-4-5")
   --once             one poll then exit (cron-friendly)
   --backfill         also act on mentions that predate startup
   --no-gate          propose only; don't wait for approval / push

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.7",
+  "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/cli.mjs

@@ -15,6 +15,36 @@ export function fmtElapsed(ms) {
   return m > 0 ? `${m}m ${s}s` : `${s}s`;
 }
 
+/** Collapse to one trimmed, length-capped line (for a heartbeat's "Latest:" tail). */
+export function oneLine(s, max = 140) {
+  const t = String(s || "").replace(/\s+/g, " ").trim();
+  return t.length > max ? t.slice(0, max - 1) + "…" : t;
+}
+
+/**
+ * Low-noise "still working…" status body for a long run (pure; used by the
+ * daemon's chat-facing heartbeat). Appends the CLI's latest output line when one
+ * is available, else stays generic.
+ * @param {{ branch: string, elapsedMs: number, repoFullName?: string, lastLine?: string }} o
+ */
+export function buildHeartbeat(o) {
+  const { repoFullName, branch, elapsedMs, lastLine } = o;
+  const where = repoFullName ? ` in ${repoFullName}` : "";
+  const base = `Still working on \`${branch}\`${where} — ${fmtElapsed(elapsedMs)} elapsed. I'll post a report when it's done.`;
+  const tail = oneLine(lastLine);
+  return tail ? `${base}\n\nLatest: ${tail}` : base;
+}
+
+/**
+ * The instant, template acknowledgement posted the moment a code task starts —
+ * so the channel shows life in <1s, before any model call. A bounded plan-ack
+ * may later edit this message in place with a sentence of specifics.
+ */
+export function ackText(repoFullName) {
+  const where = repoFullName ? ` in ${repoFullName}` : "";
+  return `On it — taking a look${where} now. I'll open a PR and report back.`;
+}
+
 // Guard against a pathological run flooding memory; the CLI's result is small.
 const MAX_CAPTURE_BYTES = 50 * 1024 * 1024;
 
@@ -30,6 +60,8 @@ const MAX_CAPTURE_BYTES = 50 * 1024 * 1024;
  * @property {{ log: (m: string) => void }} [log] - logger, injectable for tests
  * @property {AbortSignal} [signal] - abort to cancel the run (kills the child's
  *   whole process group: SIGTERM, then SIGKILL after a short grace)
+ * @property {(chunk: string) => void} [onData] - called with each stdout chunk as
+ *   it arrives (lets a caller track the latest output line for a heartbeat)
  */
 
 /**
@@ -53,6 +85,7 @@ export function runCli(opts) {
     now = Date.now,
     log = console,
     signal,
+    onData,
   } = opts || {};
   return new Promise((resolve) => {
     // Already cancelled before we even start.
@@ -79,7 +112,16 @@ export function runCli(opts) {
     child.stderr?.setEncoding("utf8");
     const append = (buf, chunk) =>
       buf.length >= MAX_CAPTURE_BYTES ? buf : buf + chunk;
-    child.stdout?.on("data", (c) => (stdout = append(stdout, c)));
+    child.stdout?.on("data", (c) => {
+      stdout = append(stdout, c);
+      if (onData) {
+        try {
+          onData(c);
+        } catch {
+          /* a heartbeat tracker must never break the run */
+        }
+      }
+    });
     child.stderr?.on("data", (c) => (stderr = append(stderr, c)));
 
     const start = now();

package/src/config.mjs

@@ -47,12 +47,25 @@ const DEFAULTS = {
   // it still won't run arbitrary commands. Override in hilos-agent.json if you
   // want a stricter (or `--dangerously-skip-permissions`) command.
   codingCmd: "claude -p --permission-mode acceptEdits",
+  // Chat replies + the code-task plan-ack use a FAST one-shot model so a casual
+  // reply (or "I see it, here's my plan") comes back in seconds, not minutes.
+  // Bounded by chatTimeoutMs with a template fallback so it can never dead-air.
+  // If your coding stack isn't Claude, set this to your own fast reply command.
+  chatCmd: "claude -p --model claude-haiku-4-5",
   defaultBranch: "main",
   // Bias to action: open a PR directly for review (approve = merge on the card).
   // Set gate:true for the older approve-before-push flow (propose a diff, wait).
   gate: false,
   maxRounds: 3,
   pollMs: 5000,
+  // On a long code run, post ONE thread progress reply at the first beat then
+  // edit it on later beats, so a human sees the agent is alive without thread
+  // spam. 0 disables. Clamped to >=15s so a misconfig can't spam realtime
+  // UPDATEs. (Distinct from cli.mjs's 15s LOCAL terminal heartbeat.)
+  heartbeatMs: 180000,
+  // Cap a chat reply / plan-ack so a stalled model can't dead-air the channel;
+  // on timeout we post an honest "taking longer than expected" line.
+  chatTimeoutMs: 90000,
   // Work queue: run mentions one at a time (concurrency 1 — parallel CLI runs on
   // one checkout would collide on git state). queueAcks posts "queued behind the
   // current task" when a mention lands during a run; set false to keep it quiet.
@@ -73,11 +86,16 @@ export function resolveConfig({ flags = {}, join: joinPayload } = {}) {
     token: process.env.HILOS_TOKEN,
     channelId: process.env.HILOS_CHANNEL,
     codingCmd: process.env.CODING_CMD,
+    chatCmd: process.env.HILOS_CHAT_CMD,
+    heartbeatMs: process.env.HILOS_HEARTBEAT_MS ? Number(process.env.HILOS_HEARTBEAT_MS) : undefined,
+    chatTimeoutMs: process.env.HILOS_CHAT_TIMEOUT_MS ? Number(process.env.HILOS_CHAT_TIMEOUT_MS) : undefined,
     backfill: process.env.HILOS_BACKFILL === "1" ? true : undefined,
     once: process.env.HILOS_ONCE === "1" ? true : undefined,
   };
   const merged = { ...DEFAULTS, ...file };
   for (const [k, v] of Object.entries(env)) if (v !== undefined && v !== "") merged[k] = v;
+  // Clamp the chat heartbeat: 0 (off) stays off, otherwise never below 15s.
+  if (merged.heartbeatMs > 0) merged.heartbeatMs = Math.max(15000, Number(merged.heartbeatMs) || 0);
   if (joinPayload) {
     merged.url = joinPayload.url;
     merged.token = joinPayload.token;
@@ -85,9 +103,55 @@ export function resolveConfig({ flags = {}, join: joinPayload } = {}) {
   }
   for (const [k, v] of Object.entries(flags)) if (v !== undefined) merged[k] = v;
   merged.repos = { ...DEFAULTS.repos, ...(file.repos || {}) };
+  // Remember where the file lives so reloadConfig can re-read it live.
+  merged.configPath = findConfigPath(flags.config) || null;
   return merged;
 }
 
+// Run-behavior fields that may change live (edit hilos-agent.json, no restart).
+// Connection identity (url/token/channelId) is deliberately excluded so a bad or
+// edited file can NEVER drop the daemon's connection.
+const LIVE_FIELDS = [
+  "codingCmd",
+  "chatCmd",
+  "defaultBranch",
+  "gate",
+  "maxRounds",
+  "pollMs",
+  "runTimeoutMs",
+  "decisionTimeoutMs",
+  "decisionPollMs",
+  "heartbeatMs",
+  "chatTimeoutMs",
+  // NOT queueConcurrency: the queue is built once at startup, so it can't change
+  // live. queueAcks IS live (intake() reads it per-mention from liveCfg).
+  "queueAcks",
+];
+
+/**
+ * Re-read the config file and overlay ONLY the run-behavior fields onto the
+ * previous config, so a running daemon picks up model/permission/codingCmd edits
+ * without a restart. Identity (url/token/channelId) is pinned from `prev`. Env
+ * still overrides (operator wins). On any read error, returns `prev` unchanged.
+ */
+export function reloadConfig(prev) {
+  // Only ever re-read the file CHOSEN AT LAUNCH. A daemon started without a config
+  // file (e.g. `--join` + env) stays file-free — we don't re-discover cwd each
+  // poll, so a hilos-agent.json dropped in later can't start steering which binary
+  // the daemon spawns. (Restart to adopt a newly-created file.)
+  const path = prev.configPath;
+  const file = (path && readJson(path)) || {};
+  const next = { ...prev };
+  for (const k of LIVE_FIELDS) if (file[k] !== undefined) next[k] = file[k];
+  if (process.env.CODING_CMD) next.codingCmd = process.env.CODING_CMD;
+  if (process.env.HILOS_CHAT_CMD) next.chatCmd = process.env.HILOS_CHAT_CMD;
+  if (process.env.HILOS_HEARTBEAT_MS) next.heartbeatMs = Number(process.env.HILOS_HEARTBEAT_MS);
+  if (process.env.HILOS_CHAT_TIMEOUT_MS) next.chatTimeoutMs = Number(process.env.HILOS_CHAT_TIMEOUT_MS);
+  if (next.heartbeatMs > 0) next.heartbeatMs = Math.max(15000, Number(next.heartbeatMs) || 0);
+  if (file.repos) next.repos = { ...DEFAULTS.repos, ...file.repos };
+  return next;
+}
+
 /** Write a starter config file (used by `hilos-agent init`). */
 export function writeStarterConfig(path, partial = {}) {
   const target = path || GLOBAL_CONFIG;

package/src/handler.mjs

@@ -22,7 +22,7 @@ import {
   prTitleBody,
   mentionHandle,
 } from "./daemon.mjs";
-import { runCli } from "./cli.mjs";
+import { runCli, buildHeartbeat, ackText, oneLine } from "./cli.mjs";
 
 /** `@handle` for the person who asked, so the report tags them. */
 function requesterTag(author) {
@@ -186,10 +186,68 @@ export function looksLikeCodeTask(text) {
     return false;
   }
   const verb =
-    /\b(fix|add|implement|refactor|change|update|create|remove|delete|rename|write|build|bump|migrate|wire|patch|optimi[sz]e|debug|revert|rebase|configure|improve|replace|extract|split|move|generate|scaffold|make|set up|hook up|adjust|tweak)\b/;
+    /\b(fix|add|implement|refactor|change|update|create|remove|delete|rename|write|build|bump|migrate|wire|patch|optimi[sz]e|debug|revert|rebase|configure|improve|replace|extract|split|move|generate|scaffold|make|set up|hook up|adjust|tweak|ship|commit|push|merge)\b/;
   return verb.test(t);
 }
 
+/**
+ * A short go-ahead that approves whatever was just discussed — "go", "ship it",
+ * "do it", "lfg", "send a PR". On its own this isn't a code task (no verb), but
+ * after the agent has proposed a plan it MEANS "execute it". handleTask treats
+ * an affirmation as code only when a repo is linked AND the agent's last message
+ * looked like a plan — so casual "yes"/"cool" in a repo channel stays chat.
+ */
+export function isAffirmation(text) {
+  const t = String(text || "")
+    .toLowerCase()
+    .replace(/@[a-z0-9-]+/g, " ")
+    .replace(/[^a-z0-9'\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!t) return false;
+  // A strong go-ahead phrase ANYWHERE means "execute it" even inside a longer,
+  // excited message ("…so it's safe to start. go for it, babyyyy"). Safe because
+  // handleTask only treats it as code when the agent had just proposed a plan.
+  if (/\b(go for it|go ahead|ship it|send it|send a pr|open a pr|make it so|lfg|let'?s go|fire away)\b/.test(t)) {
+    return true;
+  }
+  // Otherwise only a SHORT message counts — a long one carries its own intent.
+  if (t.length > 40) return false;
+  return /^(go|do it|do that|yes|yep|yeah|yup|sure|ship|proceed|sounds good|sgtm|please do|please)\b/.test(t);
+}
+
+/** Does the agent's most recent message read like a plan/proposal it offered? */
+export function agentProposedWork(rows, agentName) {
+  const mine = (rows || []).filter((m) => m && m.author === agentName);
+  const last = mine[mine.length - 1];
+  if (!last) return false;
+  return /\b(i'?ll|i will|plan|propose|pr\b|pull request|branch|here'?s|let me|on it|i'?d|i can)\b/i.test(
+    String(last.body || ""),
+  );
+}
+
+/**
+ * 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 || "")
@@ -204,23 +262,56 @@ function memoryPreamble(workspaceMemory) {
   return m ? `Workspace context (the project's soul):\n${m}\n\n` : "";
 }
 
-/** Run the configured CLI to produce a chat reply, using recent channel context. */
-async function respondConversationally({ message, channelId, tool, me, cfg, repoLink, parentId, workspaceMemory, signal }) {
-  void message;
-  // In a thread, use the thread's own messages as context (and reply there);
-  // otherwise the recent channel tail. Threads are where conversations live, so
-  // the agent must follow the thread it was pinged in, not the whole channel.
-  let transcript;
+/**
+ * Recent conversation the agent should reply within: the thread it was pinged in
+ * (threads are where conversations live), else the channel tail. Returns the raw
+ * rows (for intent routing) and a transcript string (for the prompt).
+ */
+async function fetchContext({ channelId, tool, parentId }) {
+  let rows = [];
   if (parentId) {
     const t = await tool("get_thread", { parentId }).catch(() => null);
-    const rows = t && t.found ? [t.root, ...(t.replies ?? [])].filter(Boolean) : [];
-    transcript = rows.map((m) => `${m.author}: ${m.body}`).join("\n").slice(-6000);
+    rows = t && t.found ? [t.root, ...(t.replies ?? [])].filter(Boolean) : [];
   } else {
     const { messages = [] } = await tool("read_channel", { channelId, limit: 20 }).catch(() => ({
       messages: [],
     }));
-    transcript = messages.map((m) => `${m.author}: ${m.body}`).join("\n").slice(-6000);
+    rows = messages;
   }
+  return { rows, transcript: rows.map((m) => `${m.author}: ${m.body}`).join("\n").slice(-6000) };
+}
+
+/**
+ * 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 }) {
+  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 run = await runCli({
+    cmd: parts[0],
+    args: [...parts.slice(1), prompt],
+    timeoutMs: Math.min(cfg.chatTimeoutMs || 90000, 45000),
+    label: "thinking",
+    signal,
+  });
+  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;
+}
+
+/** Run the FAST chat CLI to produce a reply, using recent channel context. */
+async function respondConversationally({ message, channelId, tool, me, cfg, repoLink, parentId, workspaceMemory, signal, context, caps = {} }) {
+  void message;
+  const { transcript } = context || (await fetchContext({ channelId, tool, parentId }));
   const name = me?.agentName || "an assistant";
   // Tell the agent what the room is connected to so it doesn't ask "which repo?".
   const repoLine = repoLink
@@ -233,32 +324,85 @@ async function respondConversationally({ message, channelId, tool, me, cfg, repo
     `${memoryPreamble(workspaceMemory)}` +
     `Conversation so far:\n${transcript}`;
 
-  const parts = cfg.codingCmd.split(" ").filter(Boolean);
-  console.log(`  chat → running \`${cfg.codingCmd}\` (output appears when it finishes)…`);
-  const run = await runCli({
-    cmd: parts[0],
-    args: [...parts.slice(1), prompt],
-    timeoutMs: cfg.runTimeoutMs,
-    label: "thinking",
-    signal,
-  });
+  // Chat uses the FAST one-shot command (fall back to codingCmd if unset) bounded
+  // by chatTimeoutMs, so a casual reply lands in seconds and a stalled model can't
+  // dead-air the channel for the full coding timeout.
+  const cmd = cfg.chatCmd || cfg.codingCmd;
+  const parts = cmd.split(" ").filter(Boolean);
+  console.log(`  chat → running \`${cmd}\` (output appears when it finishes)…`);
+
+  // If the reply is slow, post ONE "still thinking…" ping and then edit it into
+  // the answer (single message, no dead air). Needs edit_message; otherwise we
+  // just post the reply when it's ready. A fast reply never trips the timer.
+  let thinkingId = null;
+  let beatStopped = false;
+  let beatBusy = false;
+  const beatMs = Math.min(cfg.chatTimeoutMs || 90000, 30000);
+  const beat =
+    caps.editMessage && beatMs > 0
+      ? setInterval(async () => {
+          if (beatStopped || beatBusy || thinkingId) return;
+          beatBusy = true;
+          try {
+            const r = await tool("post_message", { channelId, parentId: parentId ?? null, body: "Still thinking…" });
+            thinkingId = r?.messageId ?? null;
+          } catch {
+            /* a heartbeat must never break the reply */
+          } finally {
+            beatBusy = false;
+          }
+        }, beatMs)
+      : null;
+  if (beat?.unref) beat.unref();
+
+  let run;
+  try {
+    run = await runCli({
+      cmd: parts[0],
+      args: [...parts.slice(1), prompt],
+      timeoutMs: cfg.chatTimeoutMs || cfg.runTimeoutMs,
+      label: "thinking",
+      signal,
+    });
+  } finally {
+    beatStopped = true;
+    if (beat) clearInterval(beat);
+  }
+
+  // Deliver the final text: edit the "still thinking…" ping if we posted one, else
+  // post fresh. Keeps a slow reply to a single, in-place message.
+  const deliver = (body) =>
+    thinkingId
+      ? tool("edit_message", { messageId: thinkingId, body }).catch(() =>
+          tool("post_message", { channelId, parentId: parentId ?? null, body }),
+        )
+      : tool("post_message", { channelId, parentId: parentId ?? null, body });
+
   if (run.aborted || signal?.aborted) {
-    await tool("post_message", { channelId, parentId: parentId ?? null, body: "Stopped." });
+    await deliver("Stopped.");
     return;
   }
   const reply = (run.stdout || "").trim();
-  if (run.error) console.log(`  ! ${parts[0]} failed to start: ${run.error.message}`);
+  if (run.error) console.log(`  ! ${parts[0]}: ${run.error.message}`);
   console.log(`  chat → ${reply ? `replied (${reply.length} chars)` : "no output"}; posting`);
-  await tool("post_message", {
-    channelId,
-    parentId: parentId ?? null,
-    body: reply || `(my CLI returned nothing — is \`${cfg.codingCmd}\` installed and on PATH?)`,
-  });
+  // Honest fallback: a timeout is NOT a missing binary. Only a real spawn failure
+  // (ENOENT) means the command isn't on PATH.
+  let body = reply;
+  if (!body) {
+    if (run.error?.code === "ENOENT") {
+      body = `(my chat command \`${cmd}\` isn't installed or on PATH.)`;
+    } else if (run.error) {
+      body = `Still thinking on this — it's taking longer than usual. I'll follow up shortly.`;
+    } else {
+      body = `(I didn't get a reply out of \`${cmd}\` that time — mention me again?)`;
+    }
+  }
+  await deliver(body);
 }
 
 /** Handle one task. cfg/deps injectable for tests. `opts.signal` (AbortSignal)
  *  cancels an in-flight run — the queue fires it when a human says "stop". */
-export async function handleTask({ message, channelId, tool, me }, cfg, depsOverride, opts = {}) {
+export async function handleTask({ message, channelId, tool, me, caps = {} }, cfg, depsOverride, opts = {}) {
   const deps = depsOverride || defaultDeps();
   const git = deps.git;
   const signal = opts.signal;
@@ -271,10 +415,23 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
   const { memory: workspaceMemory = null } = await tool("get_workspace_memory", {}).catch(() => ({
     memory: null,
   }));
-  // Chat (no repo linked, OR a greeting/question even in a repo channel) →
-  // reply via the CLI. Only an actual code request runs the branch/diff/PR flow.
-  if (!repoLink || !looksLikeCodeTask(message.body)) {
-    await respondConversationally({ message, channelId, tool, me, cfg, repoLink, parentId, workspaceMemory, signal });
+  // 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.
+  let isCode = looksLikeCodeTask(message.body);
+  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 });
     return { status: "chat" };
   }
   const repoFullName = repoLink.repo_full_name;
@@ -334,11 +491,60 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     return { status: "branch-error" };
   }
 
-  await tool("post_message", {
-    channelId,
-    parentId,
-    body: `On it — working in ${repoFullName} on \`${branch}\`.`,
-  });
+  // Instant acknowledgement: post a template in <1s so the channel shows life
+  // before any model call. If the server supports edit_message and a fast chatCmd
+  // is set, a bounded plan-ack edits in a sentence of specifics ("I'll do X…").
+  // 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;
+  if (ackId && caps.editMessage && cfg.chatCmd) {
+    const plan = await proposePlanAck({ task: message.body, repoFullName, cfg, signal }).catch(() => null);
+    if (plan && !signal?.aborted) await tool("edit_message", { messageId: ackId, body: plan }).catch(() => {});
+  }
+
+  // Long-run progress: post ONE thread reply at the first beat (a visible ping)
+  // then EDIT it on later beats — alive without thread spam. Needs edit_message;
+  // without it we skip rather than post a fresh message every beat. lastLine
+  // carries the CLI's latest output into the beat.
+  const heartbeatOn = Boolean(caps.editMessage) && cfg.heartbeatMs > 0;
+  let lastLine = "";
+  let progressId = null; // the thread progress reply, once a beat has posted it
+  const startHeartbeat = () => {
+    if (!heartbeatOn) return () => {};
+    const start = deps.now();
+    let stopped = false;
+    let busy = false;
+    const beat = setInterval(async () => {
+      if (stopped || busy) return;
+      busy = true;
+      const body = buildHeartbeat({ repoFullName, branch, elapsedMs: deps.now() - start, lastLine });
+      try {
+        if (!progressId) {
+          const r = await tool("post_message", { channelId, parentId, body });
+          progressId = r?.messageId ?? null;
+        } else {
+          await tool("edit_message", { messageId: progressId, body });
+        }
+      } catch {
+        /* a heartbeat must never break the run */
+      } finally {
+        busy = false;
+      }
+    }, cfg.heartbeatMs);
+    if (beat.unref) beat.unref();
+    return () => {
+      stopped = true;
+      clearInterval(beat);
+    };
+  };
+  // Once the run ends, retire the "still working…" progress reply so it doesn't
+  // sit there claiming the agent is alive. No-op when no beat ever fired (short
+  // run) or without edit_message. Best-effort.
+  const finalizeProgress = async (text) => {
+    if (progressId && caps.editMessage) {
+      await tool("edit_message", { messageId: progressId, body: text }).catch(() => {});
+    }
+  };
 
   const parts = cfg.codingCmd.split(" ").filter(Boolean);
   // Run the CLI and stage everything it changed; return the diff stats (no post).
@@ -348,14 +554,24 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     console.log(
       `  code → running \`${cfg.codingCmd}\` in ${repoPath} (this can take a few minutes; output appears when it finishes)…`,
     );
-    const run = await runCli({
-      cmd: parts[0],
-      args: [...parts.slice(1), memoryPreamble(workspaceMemory) + promptText],
-      cwd: repoPath,
-      timeoutMs: cfg.runTimeoutMs,
-      label: "coding",
-      signal,
-    });
+    const stopHeartbeat = startHeartbeat();
+    let run;
+    try {
+      run = await runCli({
+        cmd: parts[0],
+        args: [...parts.slice(1), memoryPreamble(workspaceMemory) + promptText],
+        cwd: repoPath,
+        timeoutMs: cfg.runTimeoutMs,
+        label: "coding",
+        signal,
+        onData: (c) => {
+          const lines = String(c).split("\n").map((s) => s.trim()).filter(Boolean);
+          if (lines.length) lastLine = lines[lines.length - 1];
+        },
+      });
+    } finally {
+      stopHeartbeat();
+    }
     if (run.aborted || signal?.aborted) {
       console.log("  code → cancelled");
       return { aborted: true };
@@ -364,8 +580,23 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     git(repoPath, ["add", "-A"]);
     const diff = git(repoPath, ["diff", "--cached"]).stdout || "";
     if (!diff.trim()) {
+      // An empty diff after a FAILED run (timeout / non-zero exit / spawn error)
+      // is not "no changes were needed" — be honest about it instead of claiming
+      // the agent decided nothing was required.
+      const failed = Boolean(run.error) || run.status !== 0;
+      if (failed) {
+        console.log(`  code → run failed, no diff (status=${run.status}, err=${run.error?.message || "—"})`);
+        return {
+          empty: true,
+          failed: true,
+          errCode: run.error?.code || null,
+          errMessage: run.error?.message || null,
+          status: run.status,
+          stderrTail: oneLine((run.stderr || "").trim().split("\n").slice(-3).join(" "), 300),
+        };
+      }
       console.log("  code → no changes produced");
-      return { empty: true };
+      return { empty: true, failed: false };
     }
     console.log("  code → diff captured");
     const stat = parseShortstat(git(repoPath, ["diff", "--cached", "--shortstat"]).stdout);
@@ -425,17 +656,30 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     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) {
-    await tool("post_message", {
-      channelId,
-      parentId,
-      body: `No changes were produced. Cleaning up \`${branch}\`.`,
-    });
+    let body;
+    if (staged.failed && staged.errCode === "ENOENT") {
+      body = `I couldn't start \`${cfg.codingCmd}\` — is it installed and on PATH? Cleaning up \`${branch}\`.`;
+    } else if (staged.failed) {
+      const why = staged.errMessage
+        ? ` (${staged.errMessage})`
+        : staged.status != null
+          ? ` (the CLI exited ${staged.status})`
+          : "";
+      const tail = staged.stderrTail ? `: ${staged.stderrTail}` : "";
+      body = `The run didn't finish${why}${tail}. Cleaning up \`${branch}\` — mention me to retry.`;
+    } else {
+      body = `No changes were produced. Cleaning up \`${branch}\`.`;
+    }
+    await tool("post_message", { channelId, parentId, body });
+    await finalizeProgress(
+      staged.failed ? `Run ended early on \`${branch}\` — see the note below.` : `No changes needed on \`${branch}\`.`,
+    );
     git(repoPath, ["switch", "-"]);
     git(repoPath, ["branch", "-D", branch]);
-    return { status: "no-changes" };
+    return { status: staged.failed ? "run-failed" : "no-changes" };
   }
 
   // Bias to action (default): commit, push, and open a PR for review now — the
@@ -456,9 +700,11 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
       deps,
       parentId,
     });
+    await finalizeProgress(`Done on \`${branch}\` — see the report below.`);
     return { ...result, stat: staged.stat };
   }
 
+  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 });
   if (decision.kind === "cancelled") return await postStopped();
@@ -502,5 +748,6 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     deps,
     parentId,
   });
+  await finalizeProgress(`Done on \`${branch}\` — see the report below.`);
   return { ...result, reportMessageId: proposal.reportMessageId, stat: proposal.stat, rounds: round };
 }

package/src/run.mjs

@@ -6,6 +6,7 @@ import { makeClient } from "./mcp.mjs";
 import { mentionHandle } from "./daemon.mjs";
 import { handleTask } from "./handler.mjs";
 import { createQueue, looksLikeCancel, dedupeKey } from "./queue.mjs";
+import { reloadConfig } from "./config.mjs";
 
 export async function run(cfg, { handler = handleTask, log = console } = {}) {
   if (!cfg.token) {
@@ -28,6 +29,9 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   const since = cfg.backfill ? 0 : Date.now();
   const toolNames = await listToolNames();
   const useMentions = !cfg.channelId && toolNames.includes("list_mentions");
+  // Capabilities of THIS server, so the handler degrades gracefully on older
+  // deploys (e.g. no edit_message → no live heartbeat, rather than erroring).
+  const caps = { editMessage: toolNames.includes("edit_message") };
 
   let channelIds = [];
   if (!useMentions) {
@@ -39,6 +43,10 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   const seen = new Set();
   const cursor = { value: since ? new Date(since).toISOString() : null };
 
+  // Live config: re-read between polls so model/permission/codingCmd edits to
+  // hilos-agent.json take effect without a restart. Identity stays pinned.
+  let liveCfg = cfg;
+
   // One-at-a-time worker so the poll loop NEVER blocks on a multi-minute run.
   // The loop only fetches + enqueues; the queue runs jobs in order. This is what
   // lets a "stop" (and new mentions) be picked up while a task is still running.
@@ -50,7 +58,8 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   async function safeHandle(message, channelId, signal) {
     try {
       log.log(`→ task in ${channelId}: "${(message.body || "").slice(0, 80)}"`);
-      await handler({ message, channelId, tool, me }, cfg, undefined, { signal });
+      // liveCfg so a job uses the latest model/permission/codingCmd at run time.
+      await handler({ message, channelId, tool, me, caps }, liveCfg, undefined, { signal });
     } catch (e) {
       log.error(`handler error: ${e.message}`);
       await tool("post_message", {
@@ -78,7 +87,7 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
       log.log("  (deduped a repeat of an in-flight/queued ask)");
       return;
     }
-    if (cfg.queueAcks && !r.startedImmediately) {
+    if (liveCfg.queueAcks && !r.startedImmediately) {
       await tool("post_message", {
         channelId,
         parentId: m.parentId ?? null,
@@ -116,6 +125,15 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   }
 
   do {
+    // Pick up live edits to hilos-agent.json (model/permission/codingCmd/etc.)
+    // before each pass. Guarded: a bad file leaves liveCfg untouched.
+    try {
+      const next = reloadConfig(liveCfg);
+      if (next.codingCmd !== liveCfg.codingCmd) log.log(`daemon: coding command → ${next.codingCmd}`);
+      liveCfg = next;
+    } catch (e) {
+      log.error(`config reload error (keeping previous): ${e.message}`);
+    }
     try {
       if (useMentions) await passViaMentions();
       else await passViaScan();
@@ -127,6 +145,6 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
       await queue.idle();
       break;
     }
-    await new Promise((r) => setTimeout(r, cfg.pollMs));
+    await new Promise((r) => setTimeout(r, liveCfg.pollMs));
   } while (true);
 }