hilos-agent 0.6.0 → 0.9.0

package/src/agent-events.mjs

@@ -2,7 +2,8 @@
 // alive" epic: coding CLIs each narrate their work in a different, unstable
 // wire format (Claude Code emits `--output-format stream-json` NDJSON, Codex
 // emits `--json` item events, Cursor emits its own `--output-format
-// stream-json` NDJSON — 0573). This module turns any of them into ONE small,
+// stream-json` NDJSON — 0573, opencode emits `--format json` part events —
+// 0608). This module turns any of them into ONE small,
 // typed `AgentEvent` stream the UI can render as a live "what the agent is
 // doing right now" card.
 //
@@ -218,6 +219,15 @@ function parseCodexLine(line) {
  * `shellToolCall`, each with an `args` object), and a terminal `result` with
  * `is_error` + the full text in `result`. `thinking` deltas, the `user` echo,
  * and `tool_call` completions are deliberately not steps.
+ *
+ * LOCKSTEP (0574 phase 2 / 0749): `parseCursorCloudEvent` in
+ * lib/hosted-progress.ts is this function's CLOUD twin — same field knowledge,
+ * same restraint (`started` only, unknown tools skipped, never throws) — for
+ * Cursor's Cloud Agents SSE stream, whose event NAMES differ from this CLI
+ * stream-json (`tool_call` with a flat `name` + `args`, not `<kind>ToolCall`
+ * envelopes). Change one, look at the other. The cloud side's mappings are
+ * WIRE (unconfirmed) until a real cloud transcript is captured; the shapes
+ * below were captured live and are not.
  */
 function parseCursorLine(line) {
   const obj = tryParse(line);
@@ -272,12 +282,119 @@ function cursorToolEvent(toolCall) {
   return null;
 }
 
+/** One opencode `tool_use` part → an AgentEvent, or null. Tool names are
+ *  lowercase (`read`/`write`/`edit`/`patch`/`bash`); the arguments live under
+ *  `state.input` (`filePath` for file tools, `command` for bash). Anything else
+ *  (glob/grep/webfetch/task) carries less "alive" signal and is skipped, mirroring
+ *  toolKind()'s v1 restraint — an unknown tool never crashes the parser. */
+function opencodeToolEvent(part) {
+  if (!part || typeof part !== "object") return null;
+  const tool = typeof part.tool === "string" ? part.tool.toLowerCase() : "";
+  const state = part.state && typeof part.state === "object" ? part.state : {};
+  const input = state.input && typeof state.input === "object" ? state.input : {};
+  if (tool === "bash") {
+    const raw = input.command;
+    const cmd = typeof raw === "string" ? raw.replace(/\s+/g, " ").trim() : "";
+    return { t: "run", cmd: sanitizeText(cmd) };
+  }
+  if (tool === "write" || tool === "edit" || tool === "patch" || tool === "multiedit") {
+    const raw = input.filePath ?? input.file_path ?? input.path;
+    return { t: "edit", path: typeof raw === "string" ? sanitizeText(raw) : "" };
+  }
+  if (tool === "read") {
+    const raw = input.filePath ?? input.file_path ?? input.path;
+    return { t: "read", path: typeof raw === "string" ? sanitizeText(raw) : "" };
+  }
+  return null;
+}
+
+/**
+ * A stateful line parser for opencode `run --format json` NDJSON (0608).
+ *
+ * Shapes captured LIVE against opencode 1.18.5: EVERY event carries a top-level
+ * `sessionID` (`ses_…`) — including the very first `step_start` and the terminal
+ * `error` — which is exactly the id `--session` resumes. `text` events carry a
+ * WHOLE text part (`part.text`), not a delta, so a part is emitted once and a
+ * repeat of the same `part.id` with identical text is dropped (a growing part
+ * re-emits, so the room still sees the latest wording). `tool_use` events carry
+ * the tool + its input; they're deduped by `callID` so a state update can't
+ * double a step. `step_finish` closes an assistant turn (`part.reason`): `stop`
+ * ends the run, so it becomes the `result` carrying the last text as the summary
+ * (opencode has no separate result event, and the folder-run report reads that
+ * summary). `error` (`{ error: { name, data: { message } } }`) → a failed result.
+ *
+ * Stateful (last text, seen part/call ids) — hence a factory, not a bare fn.
+ */
+function makeOpencodeLineParser() {
+  const seenText = new Map(); // part.id → last emitted text
+  const seenCalls = new Set(); // tool callID
+  let sessionSeen = false;
+  let lastText = "";
+  return function parseOpencodeLine(line) {
+    const obj = tryParse(line);
+    if (!obj) return [];
+    const out = [];
+    // The session id rides on every event; emit it once, off whichever lands first.
+    if (!sessionSeen && typeof obj.sessionID === "string" && obj.sessionID) {
+      sessionSeen = true;
+      out.push({ t: "session", sessionId: sanitizeText(obj.sessionID) });
+    }
+    const part = obj.part && typeof obj.part === "object" ? obj.part : {};
+    switch (obj.type) {
+      case "text": {
+        const text = typeof part.text === "string" ? sanitizeText(part.text.replace(/\s+/g, " ").trim()) : "";
+        if (!text) break;
+        const id = typeof part.id === "string" ? part.id : "";
+        if (id && seenText.get(id) === text) break; // same part, same text → not news
+        if (id) {
+          seenText.set(id, text);
+          if (seenText.size > 200) seenText.delete(seenText.keys().next().value); // bound
+        }
+        lastText = text;
+        out.push({ t: "note", text });
+        break;
+      }
+      case "tool_use": {
+        const callId = typeof part.callID === "string" ? part.callID : "";
+        if (callId && seenCalls.has(callId)) break; // status updates repeat the call
+        if (callId) {
+          seenCalls.add(callId);
+          if (seenCalls.size > 500) seenCalls.delete(seenCalls.values().next().value); // bound
+        }
+        const ev = opencodeToolEvent(part);
+        if (ev) out.push(ev);
+        break;
+      }
+      case "step_finish": {
+        // Only the turn that stops ends the RUN; `tool-calls` means another
+        // assistant turn follows.
+        if (part.reason === "stop") {
+          out.push(lastText ? { t: "result", ok: true, summary: lastText } : { t: "result", ok: true });
+        }
+        break;
+      }
+      case "error": {
+        const err = obj.error && typeof obj.error === "object" ? obj.error : {};
+        const data = err.data && typeof err.data === "object" ? err.data : {};
+        const raw = typeof data.message === "string" ? data.message : typeof err.name === "string" ? err.name : "";
+        const summary = sanitizeText(raw);
+        out.push(summary ? { t: "result", ok: false, summary } : { t: "result", ok: false });
+        break;
+      }
+      default:
+        break;
+    }
+    return out;
+  };
+}
+
 /** claude / claude_code / claude-code all mean the Claude parser. */
 function normalizeVendor(vendor) {
   const v = String(vendor || "").toLowerCase();
   if (v === "claude" || v === "claude_code" || v === "claude-code") return "claude";
   if (v === "codex") return "codex";
   if (v === "cursor") return "cursor"; // structured stream-json since 0573
+  if (v === "opencode") return "opencode"; // structured `--format json` since 0608
   return "text"; // ANY unknown vendor → lastLine text-tail fallback
 }
 
@@ -345,7 +462,7 @@ function makeTextTailParser() {
 
 /**
  * Build a stateful stream parser for `vendor`.
- * @param {'claude'|'claude_code'|'codex'|'cursor'|string} vendor
+ * @param {'claude'|'claude_code'|'codex'|'cursor'|'opencode'|string} vendor
  * @returns {{ push: (chunk: string) => AgentEvent[], flush: () => AgentEvent[] }}
  */
 export function makeStreamParser(vendor) {
@@ -353,6 +470,9 @@ export function makeStreamParser(vendor) {
   if (v === "claude") return makeLineBufferedParser(parseClaudeLine);
   if (v === "codex") return makeLineBufferedParser(parseCodexLine);
   if (v === "cursor") return makeLineBufferedParser(parseCursorLine);
+  // opencode's line parser carries per-stream state (dedupe + last text), so
+  // each parser instance gets its own.
+  if (v === "opencode") return makeLineBufferedParser(makeOpencodeLineParser());
   return makeTextTailParser();
 }
 
@@ -437,3 +557,113 @@ export function summarizeSteps(events, limit = 8) {
   for (const ev of events || []) ring.push(ev);
   return ring.labels();
 }
+
+// ── Activity fold (0537/0750) ────────────────────────────────────────────────
+//
+// The step ring's richer sibling: structured feed rows the run card renders as
+// sentences that MUTATE IN PLACE. LOCKSTEP with the server's fold in
+// `lib/hosted-progress.ts` (the hosted lanes) — same tense rule (the sentence
+// is formatted at read time so "Editing lib/x.ts" flips to "Edited lib/x.ts"
+// once the next action starts), same aggregation (repeat edits count up, read
+// sweeps recede into one row), same loud failures. Change one, look at the
+// other. The server re-validates every row (sanitizeProgress), so this side
+// only has to be honest, not paranoid.
+
+const MAX_ACTIVITY = 30;
+
+/** @param {{kind: string, subject: string, status: string, n: number}} row */
+function activitySentence(row) {
+  const running = row.status === "running";
+  switch (row.kind) {
+    case "edit":
+      return `${running ? "Editing" : "Edited"} ${row.subject || "files"}`;
+    case "read":
+      if (row.n > 1) return `${running ? "Reading" : "Read"} ${row.n} files`;
+      return `${running ? "Reading" : "Read"} ${row.subject || "a file"}`;
+    case "run": {
+      const label = describeRun(row.subject);
+      return running ? label : label.replace(/^Running/, "Ran");
+    }
+    default:
+      return row.subject; // note/result carry their own sentence
+  }
+}
+
+/**
+ * A bounded fold of AgentEvents into activity rows. Starts are the only ground
+ * truth a CLI stream carries, so "done" is the sequential-execution inference:
+ * a new action starting settles the one in flight. `settle("failed")` is for a
+ * dying run — leaving "Editing…" forever is the dishonesty this feed exists to
+ * avoid. session/phase events are metadata, not rows (same as stepLabel).
+ * @param {number} [limit]
+ */
+export function createActivityFold(limit = MAX_ACTIVITY) {
+  /** @type {{kind: string, subject: string, status: string, n: number}[]} */
+  const rows = [];
+
+  function settle(as = "done") {
+    const last = rows[rows.length - 1];
+    if (last && last.status === "running") last.status = as;
+  }
+
+  function add(row) {
+    settle();
+    rows.push(row);
+    if (rows.length > limit) rows.shift();
+  }
+
+  /** @param {AgentEvent} event */
+  function push(event) {
+    if (!event || typeof event !== "object") return;
+    const last = rows[rows.length - 1];
+    switch (event.t) {
+      case "edit":
+        if (last && last.status === "running" && last.kind === "edit" && last.subject === event.path) {
+          last.n += 1;
+          return;
+        }
+        add({ kind: "edit", subject: event.path || "", status: "running", n: 1 });
+        return;
+      case "read":
+        if (last && last.status === "running" && last.kind === "read") {
+          last.n += 1;
+          return;
+        }
+        add({ kind: "read", subject: event.path || "", status: "running", n: 1 });
+        return;
+      case "run":
+        add({ kind: "run", subject: event.cmd || "", status: "running", n: 1 });
+        return;
+      case "note":
+        if (!event.text) return;
+        add({ kind: "note", subject: event.text, status: "done", n: 1 });
+        return;
+      case "result":
+        add({
+          kind: "result",
+          subject: event.ok ? "Done" : (event.summary && event.summary.trim()) || "Finished with errors",
+          status: event.ok ? "done" : "failed",
+          n: 1,
+        });
+        return;
+      default:
+        return; // session / phase / unknown — metadata, not activity
+    }
+  }
+
+  /** The wire rows, sentences formatted for the CURRENT statuses, sanitized.
+   *  @returns {{kind: string, text: string, status: string, n?: number}[]} */
+  function list() {
+    const out = [];
+    for (const row of rows) {
+      const text = sanitizeText(activitySentence(row));
+      if (!text) continue;
+      const wire = { kind: row.kind, text, status: row.status };
+      if (row.kind === "edit" && row.n > 1) wire.n = row.n;
+      out.push(wire);
+    }
+    return out;
+  }
+
+  return { push, settle, list };
+}

package/src/cli.mjs

@@ -89,6 +89,33 @@ export function minimalEnv(base = process.env, extraAllow = []) {
   return out;
 }
 
+// ── PWD must match the directory we actually run in (0615) ───────────────────
+// A child spawned with `cwd` still inherits the PARENT's `PWD`, which names
+// wherever the daemon was launched. Most tools call getcwd() and never notice,
+// but some resolve their working project from the environment instead: live-
+// verified on opencode 1.18.5, which read, edited, and shelled in the daemon's
+// launch directory while hilos staged the diff in the repo clone ("no changes
+// produced"). An env that contradicts the real cwd is simply wrong, so every
+// spawn that sets `cwd` also sets `PWD` to it — and drops the inherited
+// `OLDPWD`, which is both meaningless to the child and a leak of where the
+// daemon lives. No cwd means the child inherits ours, so PWD is left alone.
+
+/**
+ * `base` with `PWD` pinned to `cwd` (and any inherited `OLDPWD` removed).
+ * Returns a copy; `base` is never mutated. A missing/blank `cwd` is a no-op.
+ * @param {Record<string, string | undefined>} base
+ * @param {string} [cwd]
+ * @returns {Record<string, string>}
+ */
+export function envForCwd(base, cwd) {
+  const out = { ...(base || {}) };
+  if (typeof cwd === "string" && cwd.trim()) {
+    out.PWD = cwd;
+    delete out.OLDPWD;
+  }
+  return out;
+}
+
 /** Human-readable elapsed time: "45s", "2m 3s". */
 export function fmtElapsed(ms) {
   const total = Math.max(0, Math.round(ms / 1000));
@@ -145,8 +172,9 @@ const MAX_CAPTURE_BYTES = 50 * 1024 * 1024;
  * @property {(chunk: string) => void} [onData] - called with each stdout chunk as
  *   it arrives (lets a caller track the latest output line for a heartbeat)
  * @property {Record<string, string>} [env] - base environment for the child. Any
- *   hilos-owned var (HILOS_*) is stripped from it regardless. Omit to inherit the
- *   daemon's environment minus HILOS_* (the safe default).
+ *   hilos-owned var (HILOS_*) is stripped from it regardless, and `PWD` is pinned
+ *   to `cwd` when one is set (0615). Omit to inherit the daemon's environment
+ *   minus HILOS_* (the safe default).
  */
 
 /**
@@ -188,12 +216,13 @@ function runCliOnce(opts) {
       // `codex exec` appends piped stdin to its prompt and blocks until EOF, so
       // an open pipe hangs it until the run timeout ("Reading additional input
       // from stdin…"). Nothing we spawn is ever fed via stdin.
-      // Always strip hilos's own token from the child's env (see scrubHilosEnv).
+      // Always strip hilos's own token from the child's env (see scrubHilosEnv),
+      // and keep PWD honest about the directory we run in (see envForCwd).
       child = spawn(cmd, args, {
         cwd,
         detached: true,
         stdio: ["ignore", "pipe", "pipe"],
-        env: scrubHilosEnv(env || process.env),
+        env: envForCwd(scrubHilosEnv(env || process.env), cwd),
       });
     } catch (error) {
       resolve({ status: null, stdout: "", stderr: "", error });

package/src/config.mjs

@@ -57,6 +57,12 @@ 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",
+  // ACP transport opt-in (0759): drive the coding CLI over the Agent Client
+  // Protocol (JSON-RPC on stdio) instead of argv + stdout scraping. Covers
+  // opencode (`opencode acp`) and cursor (`cursor-agent acp`), and only for
+  // runs the workspace already gates with runtime permissions; every other
+  // run keeps the existing paths. Also enabled by HILOS_ACP=1.
+  acpTransport: false,
   // Environment handed to the coding/chat CLI. hilos's own token (HILOS_*) is
   // ALWAYS stripped either way. "inherit" (default) passes the rest of your
   // shell env so the coding tool behaves exactly as if you ran it yourself.
@@ -124,6 +130,7 @@ export function resolveConfig({ flags = {}, join: joinPayload } = {}) {
     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,
+    acpTransport: process.env.HILOS_ACP === "1" ? true : undefined,
   };
   const merged = { ...DEFAULTS, ...file };
   for (const [k, v] of Object.entries(env)) if (v !== undefined && v !== "") merged[k] = v;
@@ -155,6 +162,7 @@ export function resolveConfig({ flags = {}, join: joinPayload } = {}) {
 // edited file can NEVER drop the daemon's connection.
 const LIVE_FIELDS = [
   "codingCmd",
+  "acpTransport",
   "codingModel",
   "chatCmd",
   "codingEnv",

package/src/daemon.mjs

@@ -16,6 +16,29 @@ export function branchSlug(text, suffix) {
   return `hilos/${base}-${suffix}`;
 }
 
+/**
+ * How to push work when the coding child committed instead of leaving a diff.
+ *
+ * The daemon owns `intendedBranch`. A child that changes branches must not also
+ * change the PR head: if it switches to the configured base branch, using the
+ * child's current branch would ask GitHub to open `main` against `main`. Push
+ * the current HEAD commit under the daemon-owned branch name instead. Omitting
+ * `-u` on recovery also avoids rewriting the accidental branch's upstream.
+ */
+export function selfDrivenShipPlan(currentBranch, intendedBranch) {
+  const current = String(currentBranch || "").trim();
+  const intended = String(intendedBranch || "").trim();
+  if (!intended) throw new Error("An intended task branch is required");
+  const recovered = !current || current !== intended;
+  return {
+    headBranch: intended,
+    pushArgs: recovered
+      ? ["push", "origin", `HEAD:refs/heads/${intended}`]
+      : ["push", "-u", "origin", intended],
+    recoveredFrom: recovered ? current || "detached HEAD" : null,
+  };
+}
+
 /** Truncate a diff to a byte budget at a line boundary. */
 export function truncateDiff(diff, maxBytes = 12000) {
   if (diff.length <= maxBytes) return { text: diff, truncated: false, omittedLines: 0 };