hilos-agent 0.4.0 → 0.6.0

package/src/model-resolve.mjs

@@ -0,0 +1,99 @@
+// Runtime model-preset resolution (0504). The connect UI offers capability
+// TIERS (Most capable / Balanced / Fastest), but Cursor's model ids are
+// account- and plan-specific and churn weekly — a baked id that works for one
+// user 404s for another, which is why VENDOR_CLI.cursor.model stayed empty for
+// months. So the tier resolves HERE, at run time, against the account's OWN
+// `cursor-agent --list-models` output: we only ever emit an id the CLI itself
+// just listed, and when nothing matches we emit no flag at all (the tool's
+// default — `auto` routing — stands). Never a guessed id, never a wrong flag.
+//
+// Design rules (mirror the .mjs siblings): the parse/resolve transforms are
+// PURE + node-builtins-only; the resolver takes an injected `run` (runCli) so
+// tests drive it with no CLI; a resolution failure NEVER breaks a run ([]).
+//
+// codex stays out: its CLI has no verified model-list command (0504 notes).
+
+/** Strip ANSI SGR color codes (`--list-models` output is colorized). */
+export function stripAnsi(s) {
+  // eslint-disable-next-line no-control-regex
+  return String(s || "").replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+/**
+ * Parse `cursor-agent --list-models` stdout → model ids, in list order.
+ * Wire shape captured live on 2026.07.23: a header line, then one
+ * `<id> - <Label>` line per model, colorized. Anything that doesn't match the
+ * `id - label` shape (headers, blanks) is skipped — a format drift degrades to
+ * [] and the preset silently falls back to the tool default.
+ * @param {string} stdout
+ * @returns {string[]}
+ */
+export function parseCursorModels(stdout) {
+  const ids = [];
+  for (const raw of String(stdout || "").split("\n")) {
+    const m = stripAnsi(raw).trim().match(/^(\S+)\s+-\s+\S/);
+    if (m) ids.push(m[1]);
+  }
+  return ids;
+}
+
+// Ranked preferences per tier, scanned in order — the first pattern with any
+// match wins, then the FIRST id in the account's list-order that matches it.
+// opus = the strongest reasoning family; sonnet ("Balanced") = Cursor's own
+// composer flagship (its default agent model) before a Claude sonnet;
+// haiku ("Fastest") = the -fast variants, composer first. `auto` never
+// matches (tier "default" emits no flag long before this table is consulted).
+const TIER_PREFS = {
+  opus: [/^claude-opus[\w.-]*thinking(?!.*fast)/, /^claude-opus(?!.*fast)/, /opus(?!.*fast)/],
+  sonnet: [/^composer(?!.*fast)/, /^claude-sonnet(?!.*fast)/, /sonnet(?!.*fast)/],
+  haiku: [/^composer.*fast/, /-fast$/],
+};
+
+/**
+ * Pick the account's model id for a tier, or null when nothing fits.
+ * @param {'opus'|'sonnet'|'haiku'|string} tier
+ * @param {string[]} ids
+ * @returns {string|null}
+ */
+export function resolveCursorModel(tier, ids) {
+  const prefs = TIER_PREFS[tier];
+  if (!prefs || !Array.isArray(ids)) return null;
+  for (const re of prefs) {
+    const hit = ids.find((id) => typeof id === "string" && re.test(id));
+    if (hit) return hit;
+  }
+  return null;
+}
+
+/**
+ * Build a memoized `modelArgsFor(cfg, vendor)` → `["--model", id]` or [].
+ * Emits [] (tool default) when: the vendor isn't cursor, no/default tier is
+ * configured, the user already pinned `--model` by hand in codingCmd, the
+ * list command fails, or nothing matches. Successful lookups are cached per
+ * (binary, tier) for the process lifetime; failures are NOT cached so a
+ * transient hiccup (offline, auth) retries on the next run.
+ *
+ * @param {{ run: (opts: object) => Promise<{status: number|null, stdout: string}> }} o
+ */
+export function createModelArgsResolver({ run } = {}) {
+  const cache = new Map();
+  return async function modelArgsFor(cfg, vendor) {
+    try {
+      const tier = String(cfg?.codingModel || "").trim();
+      if (vendor !== "cursor" || !tier || tier === "default") return [];
+      const cmd = String(cfg?.codingCmd || "");
+      if (/(^|\s)--model(\s|=)/.test(cmd + " ")) return []; // hand-pinned wins
+      const bin = cmd.trim().split(/\s+/)[0] || "cursor-agent";
+      const key = `${bin} ${tier}`;
+      if (cache.has(key)) return cache.get(key);
+      const r = await run({ cmd: bin, args: ["--list-models"], timeoutMs: 30000, heartbeatMs: 0 });
+      if (!r || r.status !== 0) return [];
+      const id = resolveCursorModel(tier, parseCursorModels(r.stdout));
+      const args = id ? ["--model", id] : [];
+      cache.set(key, args);
+      return args;
+    } catch {
+      return []; // resolution must never break a run
+    }
+  };
+}

package/src/progress-emitter.mjs

@@ -21,31 +21,64 @@ import { createStepRing, sanitizeText } from "./agent-events.mjs";
 /**
  * Which parser/stream-flags a coding command wants, from its FIRST token.
  * `claude`/`claude-code` → claude_code, `codex` → codex,
- * `cursor`/`cursor-agent` → cursor, everything else → unknown. Handles an
+ * `cursor`/`cursor-agent` → cursor, `agy`/`antigravity` → antigravity,
+ * `hermes` → hermes, everything else → unknown. Handles an
  * absolute path (`/usr/local/bin/claude`) by taking the basename.
  * @param {string} codingCmd
- * @returns {'claude_code'|'codex'|'cursor'|'unknown'}
+ * @returns {'claude_code'|'codex'|'cursor'|'antigravity'|'hermes'|'unknown'}
  */
 export function detectVendor(codingCmd) {
   const first = String(codingCmd || "").trim().split(/\s+/)[0] || "";
   const base = (first.split(/[/\\]/).pop() || "").toLowerCase();
   if (base === "claude" || base === "claude-code" || base === "claude_code") return "claude_code";
   if (base === "codex") return "codex";
-  if (base === "cursor" || base === "cursor-agent") return "cursor";
+  // `agent` is Cursor's canonical binary name since Jan 2026 (the installer
+  // symlinks both; `cursor-agent` remains an alias) — 0572.
+  if (base === "cursor" || base === "cursor-agent" || base === "agent") return "cursor";
+  if (base === "agy" || base === "antigravity") return "antigravity";
+  if (base === "hermes") return "hermes";
   return "unknown";
 }
 
+/**
+ * The FAST one-shot chat command for a coding vendor — used when the user didn't
+ * set chatCmd explicitly, so a Codex/Cursor/Antigravity daemon never needs Claude
+ * Code installed just to answer chat (0521). Every command is the vendor's
+ * verified non-interactive print mode; the daemon appends the prompt as the last
+ * arg. codex carries --skip-git-repo-check because chat (and the read-only
+ * review sandbox) can run outside a git checkout. cursor carries
+ * --output-format text (explicit, so a CLI default change can never post raw
+ * JSONL into the channel) and --trust (its Jan-2026 workspace-trust gate fails
+ * headless runs at spawn in untrusted directories — 0572; pre-2026 CLIs reject
+ * the flag and runCli retries without it). Returns "" for unknown (caller
+ * falls back to codingCmd).
+ * @param {'claude_code'|'codex'|'cursor'|'antigravity'|'hermes'|'unknown'} vendor
+ * @returns {string}
+ */
+export function fastChatCmd(vendor) {
+  if (vendor === "claude_code") return "claude -p --model claude-haiku-4-5";
+  if (vendor === "codex") return "codex exec --skip-git-repo-check";
+  if (vendor === "cursor") return "cursor-agent -p --output-format text --trust";
+  if (vendor === "antigravity") return "agy -p";
+  if (vendor === "hermes") return "hermes -z";
+  return "";
+}
+
 /**
  * Extra args to make the code run EMIT a structured stream, appended to the code
- * run's argv (NOT the display string) and ONLY for the code run. Only claude_code
- * has a proven flag (`--output-format stream-json --verbose`, per lib/agent-cli.ts
- * + scripts/verify-sandbox-mcp.mjs). codex/cursor return [] — their stream flags
+ * run's argv (NOT the display string) and ONLY for the code run. claude_code:
+ * `--output-format stream-json --verbose` (per lib/agent-cli.ts +
+ * scripts/verify-sandbox-mcp.mjs). cursor (0573): `--output-format stream-json`
+ * — appended AFTER the base's `--output-format text`, and live-verified on
+ * cursor-agent 2026.07.23 that the LAST occurrence wins, so the code run
+ * streams NDJSON while chat keeps text. codex returns [] — its stream flags
  * are deferred to 0278 rather than guessed (an unproven flag could break the run).
- * @param {'claude_code'|'codex'|'cursor'|'unknown'} vendor
+ * @param {'claude_code'|'codex'|'cursor'|'antigravity'|'hermes'|'unknown'} vendor
  * @returns {string[]}
  */
 export function codeStreamArgs(vendor) {
   if (vendor === "claude_code") return ["--output-format", "stream-json", "--verbose"];
+  if (vendor === "cursor") return ["--output-format", "stream-json"];
   return [];
 }
 

package/src/redact.mjs

@@ -0,0 +1,54 @@
+// Credential redaction shared by hosted transcript persistence and local deploy
+// output. Keep this dependency-free so the published hilos-agent package can
+// redact CLI output before it is returned, logged, or attached to a report.
+
+const PEM_BLOCK = /-----BEGIN [A-Z0-9 ]*?(?:PRIVATE KEY|PRIVATE KEY BLOCK)-----[\s\S]*?-----END [A-Z0-9 ]*?(?:PRIVATE KEY|PRIVATE KEY BLOCK)-----/g;
+const JWT = /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}(?:\.[A-Za-z0-9_-]{6,})?\b/g;
+const URL_CREDENTIALS = /(\b[a-z][a-z0-9+.-]*:\/\/)([^\/\s:@"']+):([^\/\s@"']+)@/gi;
+const PROVIDER_TOKENS = new RegExp(
+  [
+    "sk-ant-[A-Za-z0-9_-]{8,}",
+    "sk-proj-[A-Za-z0-9_-]{8,}",
+    "sk-ws-[A-Za-z0-9._-]{16,}",
+    "sk-[A-Za-z0-9]{20,}",
+    "gh[pousr]_[A-Za-z0-9]{20,}",
+    "github_pat_[A-Za-z0-9_]{20,}",
+    "xox[baprs]-[A-Za-z0-9-]{10,}",
+    "sbp_[A-Za-z0-9]{20,}",
+    "sb_secret_[A-Za-z0-9_-]{10,}",
+    "AKIA[0-9A-Z]{16}",
+    "ASIA[0-9A-Z]{16}",
+    "AIza[A-Za-z0-9_-]{30,}",
+    "hilos_live_[A-Za-z0-9_-]{8,}",
+    "vercel_[A-Za-z0-9]{20,}",
+    "re_[A-Za-z0-9]{20,}",
+  ].join("|"),
+  "g",
+);
+const BEARER = /(\b[Bb]earer["']?[\s:=]+["']?)[A-Za-z0-9._~+/=-]{12,}/g;
+const ASSIGNMENT =
+  /((?:api[_-]?key|access[_-]?key|secret[_-]?access[_-]?key|client[_-]?secret|private[_-]?key|service[_-]?role[_-]?key|auth[_-]?token|refresh[_-]?token|session[_-]?token|apikey|token|secret|password|passwd|credential)["']?\s*[:=]+\s*["']?)(?!\[redacted:)([A-Za-z0-9_~.+/-]{8,})/gi;
+
+/** Replace credential-shaped content with typed markers. Idempotent. */
+export function redactSecrets(text) {
+  if (!text) return text;
+  return text
+    .replace(PEM_BLOCK, "[redacted:pem]")
+    .replace(JWT, "[redacted:jwt]")
+    .replace(URL_CREDENTIALS, "$1[redacted:url-credentials]@")
+    .replace(PROVIDER_TOKENS, "[redacted:token]")
+    .replace(BEARER, "$1[redacted:token]")
+    .replace(ASSIGNMENT, (match, prefix, _value, offset, source) => {
+      if (source[offset + match.length] === "(") return match;
+      return `${prefix}[redacted:value]`;
+    });
+}
+
+/** Keep the transcript tail at a whole-line boundary. */
+export function truncateTranscriptTail(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const tail = text.slice(text.length - maxChars);
+  const newline = tail.indexOf("\n");
+  const clean = newline >= 0 ? tail.slice(newline + 1) : tail;
+  return `{"type":"hilos_truncated","note":"earlier transcript trimmed to fit the storage cap"}\n${clean}`;
+}

package/src/resume.mjs

@@ -35,18 +35,21 @@ export const STATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 /**
  * The `--resume` flags for a coding vendor, or [] when resume isn't safe/known.
  *
- * ONLY claude_code has a proven, confirmed resume flag (`--resume <id>`, compatible
- * with `--output-format stream-json`). codex/cursor have UNCONFIRMED resume flags,
- * so we emit NOTHING rather than guess — a wrong flag could break the run; they
- * degrade to today's branch+feedback iterate (deferred to 0278/later). A falsy or
- * non-string sessionId also returns [] (nothing to resume).
+ * claude_code: `--resume <id>`, proven and compatible with
+ * `--output-format stream-json`. cursor (0573): `--resume <chatId>` —
+ * live-verified against cursor-agent 2026.07.23 that a resumed `-p` run
+ * answers from the prior session's context; the id is the `session_id` its
+ * stream-json init/result events carry. codex has an UNCONFIRMED resume flag,
+ * so we emit NOTHING rather than guess — a wrong flag could break the run; it
+ * degrades to today's branch+feedback iterate. A falsy or non-string sessionId
+ * also returns [] (nothing to resume).
  *
- * @param {'claude_code'|'codex'|'cursor'|'unknown'} vendor
+ * @param {'claude_code'|'codex'|'cursor'|'hermes'|'unknown'} vendor
  * @param {string|null|undefined} sessionId
  * @returns {string[]}
  */
 export function buildResumeArgs(vendor, sessionId) {
-  if (vendor !== "claude_code") return [];
+  if (vendor !== "claude_code" && vendor !== "cursor") return [];
   if (typeof sessionId !== "string" || !sessionId.trim()) return [];
   return ["--resume", sessionId];
 }

package/src/run.mjs

@@ -78,7 +78,7 @@ export async function run(cfg, { handler = handleTask, log = console, signal, on
 
   const since = cfg.backfill ? 0 : Date.now();
   const toolNames = await listToolNames();
-  const useMentions = !cfg.channelId && toolNames.includes("list_mentions");
+  const useMentions = 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 = {
@@ -96,6 +96,9 @@ export async function run(cfg, { handler = handleTask, log = console, signal, on
     // coding agent has the workspace's conventions and gotchas from the start.
     // Absent on older servers → silently skipped, no change in behavior.
     recall: toolNames.includes("recall"),
+    // Semantic local-folder intent (0515): the server guarantees a forced-tool
+    // ask/ship/deploy decision. Older servers fall back to the local router.
+    agentIntent: toolNames.includes("classify_agent_intent"),
   };
 
   // Register local folders (0324/0325): a folder-mode daemon announces each
@@ -194,7 +197,10 @@ export async function run(cfg, { handler = handleTask, log = console, signal, on
       log.log("  (deduped a repeat of an in-flight/queued ask)");
       return;
     }
-    if (liveCfg.queueAcks && !r.startedImmediately) {
+    // A report-card deploy decision is already visible in place. list_mentions
+    // projects the pending decision into this structured event, so don't add a
+    // misleading "queued" chat line while the active run settles it.
+    if (liveCfg.queueAcks && !r.startedImmediately && !m.deployRequest) {
       await tool("post_message", {
         channelId,
         parentId: m.parentId ?? null,
@@ -204,7 +210,11 @@ export async function run(cfg, { handler = handleTask, log = console, signal, on
   }
 
   async function passViaMentions() {
-    const out = await tool("list_mentions", cursor.value ? { since: cursor.value } : {});
+    const mentionArgs = {
+      ...(cursor.value ? { since: cursor.value } : {}),
+      ...(cfg.channelId ? { channelId: cfg.channelId } : {}),
+    };
+    const out = await tool("list_mentions", mentionArgs);
     const mentions = (out?.mentions ?? []).slice().reverse();
     for (const m of mentions) {
       if (seen.has(m.id)) continue;