@saadnvd1/agent-os 0.3.587 → 0.3.591

package/components/Chat/composer/ComposerBody.tsx

@@ -163,7 +163,8 @@ export function ComposerBody({
     insertMarkdown(editor, content, insert.append);
   }, [insert, editor]);
 
-  const query = slashQuery(text);
+  const slash = slashQuery(caret.before);
+  const query = slash?.query ?? null;
   const mentions = useMentions(editor, caret, query === null, requestFiles);
   const matches = useMemo(() => {
     if (query === null) return [];
@@ -173,8 +174,9 @@ export function ComposerBody({
     ];
     return rankCommands(query, all);
   }, [query, commands, onSetModel]);
-  // One menu at a time: "/" commands at the start, "@" files at the caret.
-  const menuKey = query !== null ? `/${text}` : mentions.key;
+  // One menu at a time: "/" commands or "@" files at the caret.
+  const menuKey =
+    query !== null ? `/${caret.pos}:${caret.before}` : mentions.key;
   const menuOpen = menuKey !== null && dismissed !== menuKey;
   const options: MenuOption[] =
     query !== null
@@ -205,12 +207,18 @@ export function ComposerBody({
   );
 
   const pickCommand = (command: ChatCommand) => {
+    if (!editor || !slash) return;
+    // The "/" and what follows it, up to the caret.
+    const from = caret.pos - (caret.before.length - slash.start);
+    const chain = editor.chain().focus().deleteRange({ from, to: caret.pos });
     if (command === MODEL_COMMAND) {
-      setText("");
+      chain.run();
       setModelOpen(true);
       return;
     }
-    setText(insertCommand(command.name), true);
+    chain
+      .insertContent({ type: "text", text: insertCommand(command.name) })
+      .run();
   };
   const pick = (index: number) => {
     if (query !== null) {

package/lib/bus/format.ts

@@ -15,16 +15,19 @@ export interface BusMessageView {
 }
 
 const INLINE_LIMIT = 600;
+// A relayed line stays under the linked machine's own cap (tasks/[id]/message).
+export const RELAY_LIMIT = 30_000;
 
 // Enough of a session id to address it (aos send takes a unique prefix).
 export const shortId = (id: string) => id.slice(0, 8);
 
-// Typed into the recipient's terminal. Long bodies are left for `aos inbox`.
-export function wakeLine(m: {
-  fromName: string;
-  fromId: string | null;
-  body: string;
-}): string {
+// Typed into the recipient's terminal. Long bodies are left for `aos inbox`,
+// unless `inline`: the recipient's AgentOS is another machine's, whose inbox
+// never held the message, so the whole body goes in the line.
+export function wakeLine(
+  m: { fromName: string; fromId: string | null; body: string },
+  opts: { inline?: boolean } = {}
+): string {
   const short = m.fromId ? shortId(m.fromId) : null;
   const who = short
     ? `"${m.fromName}" (${short})`
@@ -32,8 +35,13 @@ export function wakeLine(m: {
       ? "the user (via AgentOS)"
       : `${m.fromName} (via AgentOS)`;
   const oneLine = m.body.replace(/\s*\n\s*/g, " ").trim();
-  const text =
-    oneLine.length <= INLINE_LIMIT
+  const text = opts.inline
+    ? `: ${
+        oneLine.length <= RELAY_LIMIT
+          ? oneLine
+          : `${oneLine.slice(0, RELAY_LIMIT)} [cut: ${oneLine.length - RELAY_LIMIT} more chars; ask the sender to resend the rest]`
+      }`
+    : oneLine.length <= INLINE_LIMIT
       ? `: ${oneLine}`
       : ` (${m.body.length} chars). Read it with: aos inbox`;
   // By id: a reply can't break when either side is renamed.

package/lib/bus/index.ts

@@ -333,7 +333,12 @@ export async function sendMessage(opts: {
   await statusDetector.refreshCache();
   const delivery = await deliver(
     to,
-    opts.line ?? wakeLine({ fromName, fromId: from?.id ?? null, body }),
+    opts.line ??
+      wakeLine(
+        { fromName, fromId: from?.id ?? null, body },
+        // The linked machine's inbox never held a long body.
+        { inline: isHeldRemote(to) }
+      ),
     {
       name: fromName,
       messageId: id,

package/lib/chat/commands.ts

@@ -1,10 +1,14 @@
 import type { ChatCommand } from "./events";
 
-// The command being typed, if the message is still just "/something".
-// Agents only run a command that opens the message.
-export function slashQuery(text: string): string | null {
-  const m = /^\/(\S*)$/.exec(text);
-  return m ? m[1].toLowerCase() : null;
+// The /command being typed: a "/" at the start of a line or after whitespace,
+// then the partial name, right up to the caret. Not "a/b" or "http://x".
+// `start` is where the "/" sits in the text before the caret.
+export function slashQuery(
+  beforeCaret: string
+): { query: string; start: number } | null {
+  const m = /(^|\s)\/([^\s/]*)$/.exec(beforeCaret);
+  if (!m) return null;
+  return { query: m[2].toLowerCase(), start: m.index + m[1].length };
 }
 
 function isSubsequence(q: string, s: string): boolean {

package/lib/db/migrations.ts

@@ -2325,6 +2325,22 @@ export const migrations: Migration[] = [
       installChangeTriggers(db, TABLES_WATCHED_CHAT_BOOKMARKS);
     },
   },
+  {
+    key: "20261014T2100_gate_failure_ask_held",
+    up: (db) => {
+      // When a failed-twice escalation started holding its ask until the
+      // agent is idle and CI has settled; null is not held. Additive.
+      const has = (
+        db.prepare(`PRAGMA table_info(orchestrator_gate_failures)`).all() as {
+          name: string;
+        }[]
+      ).some((c) => c.name === "ask_held_at");
+      if (!has)
+        db.exec(
+          `ALTER TABLE orchestrator_gate_failures ADD COLUMN ask_held_at TEXT`
+        );
+    },
+  },
 ];
 
 // `upTo`: stop after this legacy id or timestamp key, inclusive (tests that

package/lib/orchestrator/ask-heads.ts

@@ -3,9 +3,13 @@
 // gone; the ask is moved to the head it would merge, with a line on whether
 // the PR's patch changed. The approve button is bound to the commit shown,
 // so an answer from a screen that predates the move is refused (asks.ts).
+// The head is read from GitHub, never taken from the facts (which can be
+// older than the ask), and an ask never moves back to a commit it contains.
 
 import { db, type Session } from "../db";
+import { isAncestor } from "../git-exec";
 import { hostLink } from "../hosts/remote-api";
+import { prFor } from "../tasks/session";
 import { moveAskHead, openAsks, taskSubject } from "./asks";
 import type { SessionFacts } from "./facts";
 import { addNote } from "./notes";
@@ -21,16 +25,24 @@ export async function followAskHeads(
 ): Promise<void> {
   for (const ask of openAsks(workspaceId)) {
     const f = facts.find((x) => taskSubject(x.id) === ask.subject);
-    const pr = f?.task?.pr;
-    if (!ask.sha || pr?.state !== "OPEN" || !pr.head || pr.head === ask.sha)
+    const seen = f?.task?.pr;
+    if (
+      !ask.sha ||
+      seen?.state !== "OPEN" ||
+      !seen.head ||
+      seen.head === ask.sha
+    )
       continue;
     const task = db
       .prepare(`SELECT * FROM sessions WHERE id = ?`)
       .get(f!.id) as Session | undefined;
     if (!task || hostLink(task.host_id)) continue;
     try {
+      const pr = await prFor(task, true);
+      if (pr?.state !== "OPEN" || !pr.head || pr.head === ask.sha) continue;
       const repo = repoOf(task);
       const base = await fetchRefs(repo, task);
+      if (await isAncestor(repo, pr.head, ask.sha)) continue;
       const { same, note } = await comparePatches(repo, base, ask.sha, pr.head);
       const what = same ? `same patch (rebased onto ${base})` : note;
       const line = `Head moved from ${short(ask.sha)} to ${short(pr.head)}: ${what}. Approving merges ${short(pr.head)}.`;

package/lib/orchestrator/escalate.ts

@@ -2,26 +2,25 @@
 // it escalates), one escalation note in the orchestrator's chat, and the
 // task held so the orchestrator doesn't merge it.
 
-import { AskRefused, raiseAsk, workSubject } from "./asks";
+import { AskRefused, EXTERNAL_PREFIX, raiseAsk, workSubject } from "./asks";
 import {
+  failedTwiceWhy,
   failureOf,
+  holdAsk,
   markEscalated,
   recordFailure,
   type GateOutcome,
 } from "./gates";
 import { addNote } from "./notes";
 
-export function escalate(
+// Puts the ask on Saad's list (or notes why it couldn't be).
+export function askSaadAbout(
   workspaceId: string,
   task: { id: string; name: string },
-  gate: string,
   why: string,
   url: string,
-  sha: string | null = null
-): string {
-  if (!failureOf(task.id, gate))
-    recordFailure(workspaceId, task.id, gate, why, sha);
-  markEscalated(task.id, gate);
+  sha: string | null
+): void {
   let created = false;
   try {
     created = raiseAsk({
@@ -47,26 +46,49 @@ export function escalate(
       `Saad must decide on ${task.name} (${url}): ${why}. The orchestrator won't merge it; it's on his asks list to approve, decline, or sign off or drop himself.`,
       "escalation"
     );
+}
+
+// `hold`: the task is held at once, but Saad's ask waits until its agent is
+// idle and CI has settled, so it names the commit he'd merge (held-asks.ts).
+export function escalate(
+  workspaceId: string,
+  task: { id: string; name: string },
+  gate: string,
+  why: string,
+  url: string,
+  sha: string | null = null,
+  opts: { hold?: boolean } = {}
+): string {
+  if (!failureOf(task.id, gate))
+    recordFailure(workspaceId, task.id, gate, why, sha);
+  markEscalated(task.id, gate);
+  if (opts.hold) {
+    holdAsk(task.id, gate);
+    return `Escalated to Saad: ${why}. His ask goes up once ${task.name}'s agent is idle and CI has settled on its latest head, so it names the commit he'd merge; his answer reaches you as an event. Don't retry; say so in your chat.`;
+  }
+  askSaadAbout(workspaceId, task, why, url, sha);
   return `Escalated to Saad: ${why}. It's on his asks list; his answer reaches you as an event. Don't retry; say so in your chat.`;
 }
 
 // Counts a gate's failure on this head against the task; the same gate
-// failing on a second, different head goes to Saad. The same head judged
+// failing on a second, different head goes to Saad (a task's ask held until
+// its agent is done; a PR no task owns has no agent to wait for). The same head judged
 // again, from any path, isn't another failure.
 export function countFailure(
   workspaceId: string,
   task: { id: string; name: string },
   o: GateOutcome,
   url: string,
-  sha: string
+  sha: string,
+  opts: { hold?: boolean } = {}
 ): { line: string; escalated: boolean } {
   const n = recordFailure(workspaceId, task.id, o.gate, o.reason ?? "", sha);
   const line = `- ${o.gate} failed (${n === 1 ? "first" : "again"}): ${o.reason}`;
   if (n < 2 || failureOf(task.id, o.gate)?.escalated_at)
     return { line, escalated: false };
-  const why = `the ${o.gate} gate failed on two different commits: ${o.reason}`;
+  const why = failedTwiceWhy(o.gate, o.reason ?? "");
   return {
-    line: `${line}\n  ${escalate(workspaceId, task, o.gate, why, url, sha)}`,
+    line: `${line}\n  ${escalate(workspaceId, task, o.gate, why, url, sha, { hold: opts.hold ?? !task.id.startsWith(EXTERNAL_PREFIX) })}`,
     escalated: true,
   };
 }

package/lib/orchestrator/gates.ts

@@ -215,6 +215,8 @@ export interface FailureRow {
   last_reason: string | null;
   escalated_at: string | null;
   last_sha: string | null;
+  // Set while the escalation's ask waits for the agent to finish (held-asks.ts).
+  ask_held_at: string | null;
 }
 
 // Counts one failure; returns the count now. With `sha`, a failure is
@@ -277,6 +279,30 @@ export function markEscalated(sessionId: string, gate: string): void {
   markStatusDirty(sessionId);
 }
 
+export function holdAsk(sessionId: string, gate: string): void {
+  db.prepare(
+    `UPDATE orchestrator_gate_failures SET ask_held_at = COALESCE(ask_held_at, datetime('now')) WHERE session_id = ? AND gate = ?`
+  ).run(sessionId, gate);
+}
+
+export function releaseHeldAsks(sessionId: string): void {
+  db.prepare(
+    `UPDATE orchestrator_gate_failures SET ask_held_at = NULL WHERE session_id = ?`
+  ).run(sessionId);
+}
+
+export function heldAskFailures(workspaceId: string): FailureRow[] {
+  return db
+    .prepare(
+      `SELECT * FROM orchestrator_gate_failures
+       WHERE workspace_id = ? AND escalated_at IS NOT NULL AND ask_held_at IS NOT NULL`
+    )
+    .all(workspaceId) as FailureRow[];
+}
+
+export const failedTwiceWhy = (gate: string, reason: string) =>
+  `the ${gate} gate failed on two different commits: ${reason}`;
+
 export function escalations(sessionId: string): FailureRow[] {
   return db
     .prepare(

package/lib/orchestrator/held-asks.ts

@@ -0,0 +1,117 @@
+// A gate that failed twice holds the task at once, but Saad's ask waits
+// until the task's agent is done: idle, nothing sent to it lately, and CI
+// settled on its latest head. Then the ask goes up at that head, the commit
+// he'd merge; if the head moves after that, followAskHeads moves the same ask.
+
+import { db, type Session } from "../db";
+import { prFor } from "../tasks/session";
+import { latestApproval } from "./ask-approvals";
+import { askSaadAbout } from "./escalate";
+import { getCheck } from "./checks";
+import { openBySubject, workSubject } from "./asks";
+import { recentlyMessaged } from "./conditions";
+import type { SessionFacts } from "./facts";
+import {
+  failedTwiceWhy,
+  heldAskFailures,
+  releaseHeldAsks,
+  type FailureRow,
+} from "./gates";
+import { getOrchestrator } from "./home";
+import { commitTime, fetchRefs, repoOf } from "./repo";
+import { ciSettleIn, SETTLE_S } from "./task-state";
+
+// Long enough for the orchestrator to send the findings that caused the
+// escalation; the hour is the most a stuck agent can hide an escalation.
+export const HOLD_MIN_MS = SETTLE_S * 1000;
+export const HOLD_MAX_MS = 60 * 60 * 1000;
+
+const short = (sha: string) => sha.slice(0, 7);
+const sqliteMs = (t: string) => Date.parse(`${t.replace(" ", "T")}Z`);
+
+export async function raiseHeldAsks(
+  workspaceId: string,
+  facts: SessionFacts[],
+  now = Date.now()
+): Promise<void> {
+  const byTask = new Map<string, FailureRow[]>();
+  for (const row of heldAskFailures(workspaceId))
+    byTask.set(row.session_id, [...(byTask.get(row.session_id) ?? []), row]);
+  if (!byTask.size) return;
+  const orch = getOrchestrator(workspaceId);
+  const messaged = orch ? recentlyMessaged(orch.id, now) : new Set<string>();
+  for (const [taskId, rows] of byTask) {
+    try {
+      await raiseFor(workspaceId, taskId, rows, facts, messaged, now);
+    } catch (error) {
+      console.error(`Raising ${taskId}'s held ask:`, error);
+    }
+  }
+}
+
+async function raiseFor(
+  workspaceId: string,
+  taskId: string,
+  rows: FailureRow[],
+  facts: SessionFacts[],
+  messaged: Set<string>,
+  now: number
+): Promise<void> {
+  const f = facts.find((x) => x.id === taskId);
+  const task = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(taskId) as
+    | Session
+    | undefined;
+  // Gone, merged or dropped: nothing left to ask. An open ask or an
+  // unspent approval already covers it (followAskHeads, heldVerdict).
+  if (
+    !task ||
+    task.task_status !== "running" ||
+    openBySubject(workspaceId, workSubject(taskId)) ||
+    latestApproval(workspaceId, workSubject(taskId))
+  )
+    return releaseHeldAsks(taskId);
+  const heldFor =
+    now - Math.min(...rows.map((r) => sqliteMs(r.ask_held_at as string)));
+  const overdue = heldFor >= HOLD_MAX_MS;
+  // No facts yet is a wait, but never past the hour.
+  if (!f && !overdue) return;
+  // A gh failure throws and keeps the hold: only GitHub saying the PR isn't
+  // open releases it.
+  const pr = await prFor(task, true, true);
+  if (pr?.state !== "OPEN" || !pr.head) return releaseHeldAsks(taskId);
+  if (!overdue && f) {
+    if (f.status === "running" || f.compacting) return;
+    if (messaged.has(taskId) || heldFor < HOLD_MIN_MS) return;
+    if (getCheck(taskId, pr.head, "review")?.status === "running") return;
+    const repo = repoOf(task);
+    // The head may be a commit this clone hasn't fetched yet.
+    await fetchRefs(repo, task);
+    const committedAt = await commitTime(repo, pr.head);
+    if (pr.checks === "pending") return;
+    if (pr.checks === "pass") {
+      const left = ciSettleIn({
+        workspaceId,
+        taskId,
+        sha: pr.head,
+        checkCount: pr.checkCount ?? 0,
+        committedAt,
+        now,
+      });
+      if (left > 0) return;
+    } else if (now / 1000 - committedAt < SETTLE_S) return;
+  }
+  const last = rows.find((r) => r.last_sha)?.last_sha;
+  const why = [
+    ...rows.map((r) => failedTwiceWhy(r.gate, r.last_reason ?? "")),
+    ...(last && last !== pr.head
+      ? [
+          `Asked at ${short(pr.head)}, its head after the fixes since ${short(last)}.`,
+        ]
+      : []),
+    ...(overdue
+      ? [`${task.name} was still working after an hour; this is its head now.`]
+      : []),
+  ].join("\n");
+  askSaadAbout(workspaceId, task, why, pr.url, pr.head);
+  releaseHeldAsks(taskId);
+}

package/lib/orchestrator/held.ts

@@ -40,9 +40,12 @@ export function heldVerdict(
       text: `${task.name}: ${why}. Asked him again; don't retry.`,
     };
   }
+  const waiting = held.some((h) => h.ask_held_at)
+    ? " His ask goes up once its agent is idle and CI has settled on its latest head."
+    : "";
   return {
     ok: false,
     wait: false,
-    text: `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}: ${held[0].last_reason}). Only he can merge it now, or approve it on his asks list.`,
+    text: `${task.name} is with Saad (${held.map((h) => h.gate).join(", ")}: ${held[0].last_reason}). Only he can merge it now, or approve it on his asks list.${waiting}`,
   };
 }

package/lib/orchestrator/home.ts

@@ -12,10 +12,13 @@ import path from "path";
 import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { db, type Session } from "../db";
 import { getWorkspace } from "../workspaces";
+import { refuseRealStateUnderTest } from "../test-home-guard";
 
 // It works through tools, not in a repo: a scratch folder of its own.
 export const orchestratorDir = (workspaceId: string) =>
-  path.join(os.homedir(), ".agent-os", "orchestrators", workspaceId);
+  refuseRealStateUnderTest(
+    path.join(os.homedir(), ".agent-os", "orchestrators", workspaceId)
+  );
 
 export function getOrchestrator(workspaceId: string): Session | null {
   return (

package/lib/orchestrator/watcher.ts

@@ -17,6 +17,7 @@ import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { followAskHeads } from "./ask-heads";
+import { raiseHeldAsks } from "./held-asks";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
 import { awayTick } from "../away/run";
@@ -79,6 +80,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await followAskHeads(workspaceId, facts).catch((error) =>
       console.error(`Following ask heads in ${workspaceId}:`, error)
     );
+    await raiseHeldAsks(workspaceId, facts).catch((error) =>
+      console.error(`Raising held asks in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/tasks/held-remote.ts

@@ -113,11 +113,10 @@ export async function flushUndelivered(
       ).run(m.id);
       continue;
     }
-    const line = wakeLine({
-      fromName: m.from_name,
-      fromId: m.from_id,
-      body: m.body,
-    });
+    const line = wakeLine(
+      { fromName: m.from_name, fromId: m.from_id, body: m.body },
+      { inline: true }
+    );
     const res = await relayToHeldTask(task, line, m.from_name, m.id, false);
     if (res.state === "failed") return;
     db.prepare(

package/lib/test-home-guard.ts

@@ -0,0 +1,23 @@
+import os from "os";
+import path from "path";
+
+// Under the test runner, refuse a path inside the real ~/.agent-os: a test
+// that resolves there would leave folders in the owner's state. The real
+// home comes from the account, not $HOME, which the test setup replaces.
+export function refuseRealStateUnderTest(p: string): string {
+  if (!process.env.VITEST) return p;
+  let real: string;
+  try {
+    real = os.userInfo().homedir;
+  } catch {
+    return p;
+  }
+  const state = path.join(real, ".agent-os");
+  const resolved = path.resolve(p);
+  if (resolved === state || resolved.startsWith(state + path.sep)) {
+    throw new Error(
+      `Refusing to use ${state} under the test runner (${resolved}): point HOME at a temp folder`
+    );
+  }
+  return p;
+}

package/lib/worktrees.ts

@@ -12,6 +12,7 @@ import {
   slugify,
   generateBranchName,
 } from "./git";
+import { refuseRealStateUnderTest } from "./test-home-guard";
 import { installWorktreeHooks } from "./worktree-hooks";
 import { gitResult, isGitError, worktreeList } from "./git-exec";
 import { addWorktree } from "./worktree-add";
@@ -43,8 +44,13 @@ export async function mainCheckoutOf(worktreePath: string): Promise<string> {
   }
 }
 
+/** Where task worktrees live: ~/.agent-os/worktrees. */
+export function worktreesRoot(home = os.homedir()): string {
+  return refuseRealStateUnderTest(path.join(home, ".agent-os", "worktrees"));
+}
+
 // Base directory for all worktrees
-export const WORKTREES_DIR = path.join(os.homedir(), ".agent-os", "worktrees");
+export const WORKTREES_DIR = worktreesRoot();
 
 export interface WorktreeInfo {
   worktreePath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.587",
+  "version": "0.3.591",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"