@saadnvd1/agent-os 0.3.697 → 0.3.700

package/lib/bus/index.ts

@@ -5,16 +5,20 @@
  */
 
 import { db, type Session } from "../db";
-import { getProject } from "../projects";
 import { statusDetector } from "../status-detector";
 import { chatState, sendChatConfirmed } from "../chat/runner";
 import { chatActivityLine } from "../chat/activity";
 import { getWorkspace } from "../workspaces";
 import type { ChatOrigin, PeerMessage } from "../chat/events";
 import { sessionRowInfo } from "../session-meta";
-import { previousNames } from "../session-names";
 import { deliverToPane, type Delivery } from "./delivery";
-import { resolveRef, wasNames, type Candidate } from "./resolve";
+import { wasNames } from "./resolve";
+import {
+  candidates,
+  liveSessions,
+  sessionById,
+  tryResolveTarget,
+} from "./targets";
 import { tmuxPane } from "./tmux-pane";
 import { pauseHoldOf, pausedNote } from "../tasks/pause-hold";
 import { isHeldRemote, relayToHeldTask } from "../tasks/contract/held-calls";
@@ -25,9 +29,22 @@ import {
   type QueuedTarget,
 } from "../tasks/queue-held";
 import { heldOrchestrator, heldTarget } from "./held-reply";
+import {
+  cantWaitOn,
+  claimClose,
+  excerpt,
+  openWait,
+  replyWaitsFor,
+  waitBadges,
+} from "./waits/store";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
 
 export * from "./format";
+export {
+  resolveHeldOrchestrator,
+  resolveSession,
+  resolveTarget,
+} from "./targets";
 export type { Delivery } from "./delivery";
 
 export interface Peer {
@@ -44,35 +61,11 @@ export interface Peer {
   orchestratorOf: string | null;
   // The asking session's own workspace orchestrator.
   yours?: boolean;
+  // Names of the sessions it waits on, and of those waiting on it.
+  waitingOn: string[];
+  waitedBy: string[];
 }
 
-function liveSessions(): Session[] {
-  return db
-    .prepare(
-      `SELECT * FROM session_rows WHERE (task_status IS NULL OR task_status = 'running')
-         AND archived_at IS NULL
-       ORDER BY updated_at DESC`
-    )
-    .all() as Session[];
-}
-
-function candidates(sessions: Session[]): Candidate[] {
-  const old = previousNames();
-  return sessions.map((s) => ({
-    id: s.id,
-    name: s.name,
-    projectName: s.project_id ? (getProject(s.project_id)?.name ?? null) : null,
-    tmuxName: s.tmux_name,
-    previousNames: old.get(s.id) ?? [],
-  }));
-}
-
-const sessionById = (id: string | null | undefined) =>
-  id
-    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
-        Session | undefined)
-    : undefined;
-
 // A chat has no pane: its worker is the state, and it can always take a
 // message (queued as its next prompt), so it is never "not running".
 async function peerState(
@@ -105,6 +98,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
   const named = candidates(sessions);
   const caller = sessionById(callerId);
   const orchestrator = heldOrchestrator(caller);
+  const badges = waitBadges();
   const listed = await Promise.all(
     sessions.map(async (s, i) => {
       const info = await peerState(s);
@@ -118,6 +112,8 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         running: info.running,
         doing: info.subtitle,
         orchestratorOf: orchestratorOf(s),
+        waitingOn: badges.get(s.id)?.on.map((w) => w.name) ?? [],
+        waitedBy: badges.get(s.id)?.by.map((w) => w.name) ?? [],
         ...(caller?.workspace_id &&
           s.role === "orchestrator" &&
           s.workspace_id === caller.workspace_id && { yours: true }),
@@ -137,84 +133,15 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
       running: true,
       doing: `your orchestrator, on ${orchestrator.heldFrom}`,
       orchestratorOf: null,
+      waitingOn: [],
+      waitedBy: [],
       yours: true,
     },
   ];
 }
 
-// The orchestrator a held caller's ref names, if it names it.
-export function resolveHeldOrchestrator(callerId: string, ref: string) {
-  return heldTarget(sessionById(callerId), ref);
-}
-
-// A live session by name, old name, project/name, id or id prefix. The note
-// says when the name meant something other than its current owner.
-export function resolveTarget(
-  ref: string,
-  callerId?: string | null
-): {
-  session: Session;
-  note?: string;
-} {
-  const found = tryResolveTarget(ref, callerId);
-  if (!found.ok) throw new Error(found.error);
-  return found;
-}
-
-// "orchestrator" / "my orchestrator": the caller's own workspace orchestrator.
-function ownOrchestrator(
-  ref: string,
-  sessions: Session[],
-  callerId?: string | null
-): Session | undefined {
-  if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
-  const workspace = sessionById(callerId)?.workspace_id;
-  if (!workspace) return undefined;
-  return sessions.find(
-    (s) => s.role === "orchestrator" && s.workspace_id === workspace
-  );
-}
-
-function tryResolveTarget(
-  ref: string,
-  callerId?: string | null
-):
-  | { ok: true; session: Session; note?: string }
-  | { ok: false; none: boolean; error: string } {
-  const sessions = liveSessions();
-  const own = ownOrchestrator(ref, sessions, callerId);
-  if (own) return { ok: true, session: own };
-  const r = resolveRef(ref, candidates(sessions));
-  if (!r.ok) {
-    const orchestrators = /^(my )?orchestrator$/i.test(ref.trim())
-      ? sessions.filter((s) => s.role === "orchestrator")
-      : [];
-    if (orchestrators.length)
-      return {
-        ok: false,
-        none: true,
-        error: `You are in no workspace, so "${ref}" is ambiguous. Orchestrators: ${orchestrators
-          .map((s) => `${s.name} (id ${s.id.slice(0, 8)})`)
-          .join(", ")}`,
-      };
-    return {
-      ok: false,
-      none: r.reason === "none",
-      error: r.reason === "none" ? `${r.error}. Run: aos peers` : r.error,
-    };
-  }
-  return {
-    ok: true,
-    session: sessions.find((s) => s.id === r.id)!,
-    note: r.note,
-  };
-}
-
-export function resolveSession(ref: string): Session {
-  return resolveTarget(ref).session;
-}
-
 type Row = {
+  reply_to: number | null;
   id: number;
   from_id: string | null;
   from_name: string;
@@ -234,11 +161,12 @@ const toView = (r: Row): BusMessageView => ({
   body: r.body,
   createdAt: r.created_at,
   readAt: r.read_at,
+  replyTo: r.reply_to,
 });
 
 // Messages are kept by id; names shown are the sessions' names now, the
 // stored ones only for a session that's gone.
-const SELECT = `SELECT m.id, m.from_id, m.to_id, m.body, m.created_at, m.read_at,
+const SELECT = `SELECT m.id, m.from_id, m.to_id, m.body, m.created_at, m.read_at, m.reply_to,
     CASE WHEN m.from_id IS NULL THEN m.from_name
          ELSE COALESCE(f.name, m.from_name) END AS from_name,
     COALESCE(t.name, m.to_name) AS to_name
@@ -338,10 +266,17 @@ export async function sendMessage(opts: {
   // A message pulled from a linked machine, by its key there: one already
   // stored is not stored or delivered again.
   relayKey?: string;
+  // Answers this message (one the recipient sent the sender). Without it a
+  // message answers the recipient's oldest open wait on the sender.
+  replyTo?: number;
+  // The sender waits for the recipient's reply; ms until it gives up.
+  awaitMs?: number;
 }): Promise<{
   message: BusMessageView;
   delivery: Delivery;
   note?: string;
+  // The wait recorded for --await, or why none was.
+  wait?: { id: number; deadline: number } | { notWaiting: string };
   // The task it was held for, when that task is still in the start queue.
   heldForQueued?: boolean;
 }> {
@@ -380,10 +315,13 @@ export async function sendMessage(opts: {
       };
   }
 
+  const reply = from ? replyTarget(from, to, opts.replyTo) : null;
+  if (opts.awaitMs && !from) throw new Error("Only a session can wait");
+
   const fromName = from?.name ?? opts.fromLabel ?? HUMAN;
   const { lastInsertRowid } = db
     .prepare(
-      `INSERT INTO bus_messages (from_id, from_name, to_id, to_name, body, relay_key) VALUES (?, ?, ?, ?, ?, ?)`
+      `INSERT INTO bus_messages (from_id, from_name, to_id, to_name, body, relay_key, reply_to) VALUES (?, ?, ?, ?, ?, ?, ?)`
     )
     .run(
       from?.id ?? null,
@@ -391,9 +329,13 @@ export async function sendMessage(opts: {
       to.id,
       to.name,
       body,
-      opts.relayKey ?? null
+      opts.relayKey ?? null,
+      reply?.id ?? null
     );
   const id = Number(lastInsertRowid);
+  // The reply is stored: whatever it answers is settled, whether or not
+  // the wake line gets through.
+  if (from) settleReplyWaits(to.id, from.id, id);
 
   await statusDetector.refreshCache();
   const delivery = await deliver(
@@ -402,7 +344,12 @@ export async function sendMessage(opts: {
       wakeLine(
         { fromName, fromId: from?.id ?? null, body },
         // The linked machine's inbox never held a long body.
-        { inline: isHeldRemote(to) }
+        {
+          inline: isHeldRemote(to),
+          replyTo: reply
+            ? { id: reply.id, excerpt: excerpt(reply.body, 60) }
+            : undefined,
+        }
       ),
     {
       name: fromName,
@@ -427,13 +374,73 @@ export async function sendMessage(opts: {
     ).run(id);
   const message = toView(db.prepare(`${SELECT} WHERE m.id = ?`).get(id) as Row);
   const heldNote = hold ? pausedNote(to.name, hold) : null;
+  const wait =
+    opts.awaitMs && from
+      ? keepWait(from, to, id, body, delivery, opts.awaitMs)
+      : undefined;
   return {
     message,
     delivery,
     note: [note, heldNote].filter(Boolean).join("; ") || undefined,
+    wait,
   };
 }
 
+// The message `replyTo` names, or the oldest request `from` was waited on
+// for by `to`: the one this message answers.
+function replyTarget(
+  from: Session,
+  to: Session,
+  replyTo?: number
+): { id: number; body: string } | null {
+  if (replyTo !== undefined) {
+    const m = db
+      .prepare(
+        `SELECT id, body FROM bus_messages WHERE id = ? AND from_id = ? AND to_id = ?`
+      )
+      .get(replyTo, to.id, from.id) as { id: number; body: string } | undefined;
+    if (!m)
+      throw new Error(`Message #${replyTo} wasn't sent to you by ${to.name}`);
+    return m;
+  }
+  const wait = replyWaitsFor(to.id, from.id).find((w) => w.message_id);
+  if (!wait) return null;
+  return (
+    (db
+      .prepare(`SELECT id, body FROM bus_messages WHERE id = ?`)
+      .get(wait.message_id) as { id: number; body: string } | undefined) ?? null
+  );
+}
+
+// `from` answered `waiter`: every reply wait it had on `from` is settled.
+function settleReplyWaits(waiter: string, from: string, replyId: number) {
+  for (const w of replyWaitsFor(waiter, from))
+    claimClose(w.id, "replied", replyId);
+}
+
+function keepWait(
+  from: Session,
+  to: Session,
+  messageId: number,
+  body: string,
+  delivery: Delivery,
+  ms: number
+): { id: number; deadline: number } | { notWaiting: string } {
+  if (delivery.state === "failed") return { notWaiting: "it wasn't delivered" };
+  const why = cantWaitOn(to);
+  if (why) return { notWaiting: why };
+  const deadline = Date.now() + ms;
+  const id = openWait({
+    waiterId: from.id,
+    targetId: to.id,
+    kind: "reply",
+    messageId,
+    request: excerpt(body),
+    deadline,
+  });
+  return { id, deadline };
+}
+
 function storeForHolder(
   from: Session,
   to: { id: string; name: string; heldFrom: string },

package/lib/bus/resolve.ts

@@ -11,6 +11,8 @@ export interface Candidate {
   tmuxName: string;
   // Newest first.
   previousNames: string[];
+  workspaceName?: string | null;
+  orchestrator?: boolean;
 }
 
 export type Resolution =
@@ -20,7 +22,13 @@ export type Resolution =
 export const MIN_ID_PREFIX = 4;
 
 const label = (c: Candidate) =>
-  `${c.projectName ? `${c.projectName}/` : ""}${c.name} (id ${c.id.slice(0, 8)})`;
+  `${
+    c.orchestrator && c.workspaceName
+      ? `${c.workspaceName}/`
+      : c.projectName
+        ? `${c.projectName}/`
+        : ""
+  }${c.name} (id ${c.id.slice(0, 8)})`;
 
 function ambiguous(ref: string, matches: Candidate[]): Resolution {
   return {
@@ -32,7 +40,13 @@ function ambiguous(ref: string, matches: Candidate[]): Resolution {
 
 const matchesOld = (r: string, c: Candidate) =>
   c.previousNames.some((old) =>
-    matchesRef(r, { ...c, id: "", tmuxName: "", name: old })
+    matchesRef(r, {
+      ...c,
+      id: "",
+      tmuxName: "",
+      name: old,
+      orchestrator: false,
+    })
   );
 
 export function resolveRef(ref: string, candidates: Candidate[]): Resolution {

package/lib/bus/targets.ts

@@ -0,0 +1,122 @@
+/**
+ * Which live session a name someone typed reaches, across workspaces.
+ */
+
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { previousNames } from "../session-names";
+import { sessionWorkspace } from "../schedules/store";
+import { heldTarget } from "./held-reply";
+import { resolveRef, type Candidate } from "./resolve";
+
+export function liveSessions(): Session[] {
+  return db
+    .prepare(
+      `SELECT * FROM session_rows WHERE (task_status IS NULL OR task_status = 'running')
+         AND archived_at IS NULL
+       ORDER BY updated_at DESC`
+    )
+    .all() as Session[];
+}
+
+export function candidates(sessions: Session[]): Candidate[] {
+  const old = previousNames();
+  const workspaces = new Map<string | null, string | null>();
+  const workspaceName = (s: Session) => {
+    const id = sessionWorkspace(s);
+    if (!workspaces.has(id))
+      workspaces.set(id, id ? (getWorkspace(id)?.name ?? null) : null);
+    return workspaces.get(id) ?? null;
+  };
+  return sessions.map((s) => ({
+    id: s.id,
+    name: s.name,
+    projectName: s.project_id ? (getProject(s.project_id)?.name ?? null) : null,
+    tmuxName: s.tmux_name,
+    previousNames: old.get(s.id) ?? [],
+    workspaceName: workspaceName(s),
+    orchestrator: s.role === "orchestrator",
+  }));
+}
+
+export const sessionById = (id: string | null | undefined) =>
+  id
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+        Session | undefined)
+    : undefined;
+
+// The orchestrator a held caller's ref names, if it names it.
+export function resolveHeldOrchestrator(callerId: string, ref: string) {
+  return heldTarget(sessionById(callerId), ref);
+}
+
+// A live session by name, old name, project/name, id or id prefix. The note
+// says when the name meant something other than its current owner.
+export function resolveTarget(
+  ref: string,
+  callerId?: string | null
+): {
+  session: Session;
+  note?: string;
+} {
+  const found = tryResolveTarget(ref, callerId);
+  if (!found.ok) throw new Error(found.error);
+  return found;
+}
+
+// "orchestrator" / "my orchestrator": the caller's own workspace orchestrator.
+function ownOrchestrator(
+  ref: string,
+  sessions: Session[],
+  callerId?: string | null
+): Session | undefined {
+  if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
+  const workspace = sessionById(callerId)?.workspace_id;
+  if (!workspace) return undefined;
+  return sessions.find(
+    (s) => s.role === "orchestrator" && s.workspace_id === workspace
+  );
+}
+
+export function tryResolveTarget(
+  ref: string,
+  callerId?: string | null
+):
+  | { ok: true; session: Session; note?: string }
+  | { ok: false; none: boolean; error: string } {
+  const sessions = liveSessions();
+  const own = ownOrchestrator(ref, sessions, callerId);
+  if (own) return { ok: true, session: own };
+  const r = resolveRef(ref, candidates(sessions));
+  if (!r.ok) {
+    const orchestrators = /^(my )?orchestrator$/i.test(ref.trim())
+      ? sessions.filter((s) => s.role === "orchestrator")
+      : [];
+    if (orchestrators.length)
+      return {
+        ok: false,
+        none: true,
+        error: `You are in no workspace, so "${ref}" is ambiguous. Use <workspace>/orchestrator: ${orchestrators
+          .map(
+            (s) =>
+              `${getWorkspace(s.workspace_id ?? "")?.name ?? "?"}/orchestrator (${s.name}, id ${s.id.slice(0, 8)})`
+          )
+          .join(", ")}`,
+      };
+    return {
+      ok: false,
+      none: r.reason === "none",
+      error: r.reason === "none" ? `${r.error}. Run: aos peers` : r.error,
+    };
+  }
+  return {
+    ok: true,
+    session: sessions.find((s) => s.id === r.id)!,
+    note: r.note,
+  };
+}
+
+export function resolveSession(ref: string): Session {
+  return resolveTarget(ref).session;
+}

package/lib/bus/waits/kick.ts

@@ -0,0 +1,12 @@
+// Lets the places where a session ends ask for a look at open waits now,
+// without importing the bus. The watcher registers itself here.
+
+let kick: (() => void) | null = null;
+
+export function onKick(fn: () => void): void {
+  kick = fn;
+}
+
+export function kickWaits(): void {
+  kick?.();
+}

package/lib/bus/waits/lines.ts

@@ -0,0 +1,69 @@
+// Every text an agent reads about a wait. Each starts the way a bus message
+// does, so a line left unsent in a terminal's input is recognised as ours.
+
+import { shortId } from "../format";
+
+const from = "[AgentOS message from AgentOS]";
+const who = (name: string, id: string) => `"${name}" (${shortId(id)})`;
+
+export const minutes = (ms: number) =>
+  ms >= 3_600_000
+    ? `${Math.round(ms / 360_000) / 10}h`
+    : `${Math.max(1, Math.round(ms / 60_000))}m`;
+
+export function nudgeLine(
+  waiter: { id: string; name: string },
+  request: string | null,
+  messageId: number | null
+): string {
+  const reply = messageId ? ` --reply ${messageId}` : "";
+  return `${from} ${who(waiter.name, waiter.id)} is waiting on your reply${request ? ` to: "${request}"` : ""}. Reply with: aos send ${shortId(waiter.id)}${reply} "<message>"`;
+}
+
+export function timeoutLine(
+  target: { id: string; name: string },
+  kind: "reply" | "idle" | "merged",
+  waitedMs: number,
+  request: string | null,
+  targetIs: string
+): string {
+  const what =
+    kind === "reply"
+      ? `No reply from ${who(target.name, target.id)}${request ? ` to: "${request}"` : ""}`
+      : kind === "idle"
+        ? `${who(target.name, target.id)} didn't go idle`
+        : `${who(target.name, target.id)}'s PR didn't merge`;
+  return `${from} ${what} within ${minutes(waitedMs)}. The wait is closed; it is ${targetIs}. See what it did: aos read ${shortId(target.id)}`;
+}
+
+export const satisfiedLine = (
+  target: { id: string; name: string },
+  kind: "idle" | "merged",
+  pr?: number | null
+): string =>
+  `${from} ${
+    kind === "idle"
+      ? `${who(target.name, target.id)} is idle now`
+      : `${who(target.name, target.id)}'s PR${pr ? ` #${pr}` : ""} merged`
+  } (you waited for that). See what it did: aos read ${shortId(target.id)}`;
+
+export const endedLine = (
+  target: { id: string; name: string },
+  how: string,
+  request: string | null
+): string =>
+  `${from} ${who(target.name, target.id)} ended (${how}) with your wait still open${request ? ` on: "${request}"` : ""}. It won't answer.`;
+
+export const closedPrLine = (
+  target: { id: string; name: string },
+  pr: number | null
+): string =>
+  `${from} ${who(target.name, target.id)}'s PR${pr ? ` #${pr}` : ""} was closed without merging. The wait is closed.`;
+
+export const orchestratorTimeoutLine = (
+  waiter: string,
+  target: string,
+  waitedMs: number,
+  request: string | null
+): string =>
+  `session ${waiter} waited ${minutes(waitedMs)} on ${target} with no ${request ? `reply to "${request}"` : "result"}; it has been told`;

package/lib/bus/waits/register.ts

@@ -0,0 +1,83 @@
+// Registering a wait: `aos send --await` (in sendMessage) and `aos wait`.
+
+import { statusDetector } from "../../status-detector";
+import { statusOf } from "../../orchestrator/facts";
+import { duration } from "../../schedules/when";
+import { sessionById, tryResolveTarget } from "../targets";
+import {
+  DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS,
+  MIN_TIMEOUT_MS,
+  cantWaitOn,
+  openWait,
+  type WaitKind,
+} from "./store";
+
+// "30m", "2h", "1h30m"; empty is the default.
+export function parseTimeout(text: string | null | undefined): number {
+  const t = String(text ?? "").trim();
+  if (!t) return DEFAULT_TIMEOUT_MS;
+  const ms = duration(t.toLowerCase().replace(/([a-z])(?=\d)/g, "$1 "));
+  if (ms === null)
+    throw new Error(`Can't read the timeout "${t}": try 30m, 2h or 1h30m`);
+  if (ms < MIN_TIMEOUT_MS || ms > MAX_TIMEOUT_MS)
+    throw new Error("The timeout is between 1m and 24h");
+  return ms;
+}
+
+export const UNTILS = ["idle", "merged", "reply"] as const;
+export type Until = (typeof UNTILS)[number];
+
+export async function registerWait(opts: {
+  fromId: string;
+  to: string;
+  until: string;
+  timeout?: string | null;
+}): Promise<{
+  id?: number;
+  deadline?: number;
+  already?: string;
+  target: string;
+}> {
+  if (!(UNTILS as readonly string[]).includes(opts.until))
+    throw new Error("--until is idle, merged or reply");
+  const kind: WaitKind = opts.until as Until;
+  const timeoutMs = parseTimeout(opts.timeout);
+  const from = sessionById(opts.fromId);
+  if (!from) throw new Error("Unknown sender session");
+  const found = tryResolveTarget(opts.to, opts.fromId);
+  if (!found.ok) throw new Error(found.error);
+  const target = found.session;
+  if (target.id === from.id) throw new Error("A session can't wait on itself");
+  const why = cantWaitOn(target);
+  if (why) throw new Error(`Can't wait on ${target.name}: ${why}`);
+
+  if (kind === "merged") {
+    if (target.pr_status === "merged" || target.task_status === "merged")
+      return {
+        already: `${target.name}'s PR is already merged`,
+        target: target.name,
+      };
+    if (target.pr_status === "closed")
+      throw new Error(`${target.name}'s PR was closed without merging`);
+    if (!target.task_status && !target.pr_number && !target.branch_name)
+      throw new Error(
+        `${target.name} isn't a task and has no PR, so there is nothing to merge`
+      );
+  }
+  if (kind === "idle") {
+    await statusDetector.refreshCache();
+    if ((await statusOf(target)).status === "idle")
+      return { already: `${target.name} is idle now`, target: target.name };
+  }
+  const now = Date.now();
+  const deadline = now + timeoutMs;
+  const id = openWait({
+    waiterId: from.id,
+    targetId: target.id,
+    kind,
+    deadline,
+    now,
+  });
+  return { id, deadline, target: target.name };
+}