@saadnvd1/agent-os 0.3.715 → 0.3.728

package/lib/chat/drivers/turn-items.ts

@@ -1,5 +1,11 @@
 import { randomUUID } from "crypto";
-import type { ChatItem, DriverEvent, FileDiff, ToolStatus } from "../events";
+import type {
+  ChatItem,
+  DriverEvent,
+  FileDiff,
+  ToolStatus,
+  TurnEndReason,
+} from "../events";
 import { clipOutput } from "../tools";
 
 type Tool = Extract<ChatItem, { kind: "tool" }>;
@@ -41,6 +47,8 @@ export function readableError(text: string): string {
 export class TurnItems {
   private texts = new Map<string, Text>();
   private tools = new Map<string, Tool>();
+  // Texts that finished in this turn, so one can be corrected afterwards.
+  private done = new Map<string, Text>();
   private startedAt = 0;
   inTurn = false;
 
@@ -81,15 +89,23 @@ export class TurnItems {
     this.texts.delete(key);
     const text = full ?? current?.text ?? "";
     if (!text.trim()) return;
-    this.emit({
-      type: "item",
-      item: {
-        id: current?.id ?? randomUUID(),
-        kind,
-        text,
-        createdAt: current?.createdAt ?? Date.now(),
-      },
-    });
+    const item: Text = {
+      id: current?.id ?? randomUUID(),
+      kind,
+      text,
+      createdAt: current?.createdAt ?? Date.now(),
+    };
+    this.done.set(key, item);
+    this.emit({ type: "item", item });
+  }
+
+  // A finished text replaced by `text` (blank hides it): the agent's final
+  // message differs from what streamed.
+  retext(key: string, text: string): void {
+    const item = this.done.get(key);
+    if (!item) return;
+    this.done.set(key, { ...item, text });
+    this.emit({ type: "item", item: { ...item, text } });
   }
 
   tool(id: string, start: ToolStart): void {
@@ -158,7 +174,13 @@ export class TurnItems {
 
   // Closes the turn: text still streaming settles, tools still running
   // were cut off.
-  endTurn(end: { interrupted?: boolean; error?: string; costUsd?: number }) {
+  endTurn(end: {
+    interrupted?: boolean;
+    error?: string;
+    costUsd?: number;
+    finishReason?: string;
+    ended?: { reason: TurnEndReason; notice: string };
+  }) {
     if (!this.inTurn) return;
     this.inTurn = false;
     for (const [key, text] of [...this.texts]) this.finishText(key, text.kind);
@@ -172,9 +194,12 @@ export class TurnItems {
         durationMs: Date.now() - this.startedAt,
         costUsd: end.costUsd,
         interrupted: end.interrupted,
+        finishReason: end.finishReason,
+        ended: end.interrupted ? undefined : end.ended,
         createdAt: Date.now(),
       },
     });
+    this.done.clear();
     this.emit({ type: "state", state: "idle" });
   }
 }

package/lib/chat/drivers/turn-outcome.ts

@@ -0,0 +1,108 @@
+import { redact } from "../../orchestrator/untrusted";
+import type { TurnEndReason } from "../events";
+
+export interface TurnEnded {
+  reason: TurnEndReason;
+  notice: string;
+}
+
+// Said where a reply stopped short, so the fix is in the notice itself.
+const SERVER_HINT =
+  "If you run the model yourself, start its server with tool calling on (llama.cpp: --jinja; vLLM: --enable-auto-tool-choice --tool-call-parser; LM Studio: a model with tool use).";
+
+const TAIL = 300;
+const LOG_TAIL = 240;
+
+const CLOSERS =
+  /\b(let me know|i'?ll (wait|leave|stop|hold)|i will (wait|leave|stop)|if you'?d like|feel free|hope (this|that)|want me to)\b/i;
+const ANNOUNCE =
+  /\b(let me|let'?s|i'?ll|i will|i'?m going to|i am going to|going to|i need to|i should|now i|first,? i|next,? i|then i)\s+(\w+)/i;
+
+// Whether the end of a reply says the model is about to do something.
+export function announcesAction(text: string): boolean {
+  const tail = text.trim().slice(-TAIL);
+  if (!tail) return false;
+  if (tail.endsWith("?")) return false;
+  const last =
+    tail
+      .split(/(?<=[.!:])\s+|\n+/)
+      .filter((s) => s.trim())
+      .slice(-2)
+      .join(" ") || tail;
+  if (CLOSERS.test(last)) return false;
+  return ANNOUNCE.test(last) || /:\s*$/.test(tail);
+}
+
+// Tool-call markup left in a reply: a call that was written, not made.
+export function hasToolMarkup(text: string): boolean {
+  return (
+    /<tool_call>|<function=|<\|tool_call\|>/.test(text) ||
+    /\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"(arguments|parameters)"\s*:\s*\{[\s\S]*\}\s*$/.test(
+      text
+    )
+  );
+}
+
+export function turnOutcome(r: {
+  finishReason?: string;
+  text: string;
+  toolCalls: number;
+  error?: string;
+}): TurnEnded | undefined {
+  if (r.finishReason === "length")
+    return {
+      reason: "length",
+      notice:
+        "The model hit its output limit (finish reason: length) before it finished. Raise maxTokens for this model.",
+    };
+  if (r.error)
+    return {
+      reason: "error",
+      notice: "The model's server returned an error, shown above.",
+    };
+  if (r.toolCalls > 0) return undefined;
+  if (hasToolMarkup(r.text))
+    return {
+      reason: "parse_failure",
+      notice: `The model wrote a tool call as text that AgentOS couldn't run. ${SERVER_HINT}`,
+    };
+  if (!r.text.trim())
+    return {
+      reason: "empty",
+      notice: `The model ended its turn with an empty reply. ${SERVER_HINT}`,
+    };
+  if (announcesAction(r.text))
+    return {
+      reason: "no_tool_call",
+      notice: `The model ended its turn without calling a tool. ${SERVER_HINT}`,
+    };
+  return undefined;
+}
+
+// One line to diagnose a turn that ended early: where, why and how the
+// reply ended. Never the prompt, and the reply's tail is scrubbed and cut.
+export function logTurnEnd(o: {
+  driver: string;
+  provider?: string;
+  model?: string;
+  api?: string;
+  finishReason?: string;
+  reason: TurnEndReason;
+  text: string;
+}): void {
+  const tail = redact(
+    o.text.slice(-LOG_TAIL).replace(/[\u0000-\u001f\u007f]/g, " ")
+  );
+  console.warn(
+    "[chat] turn ended early",
+    JSON.stringify({
+      driver: o.driver,
+      provider: o.provider,
+      model: o.model,
+      api: o.api,
+      finishReason: o.finishReason,
+      reason: o.reason,
+      tail,
+    })
+  );
+}

package/lib/chat/events.ts

@@ -150,6 +150,9 @@ interface Base {
   createdAt: number;
 }
 
+export type TurnEndReason =
+  "no_tool_call" | "length" | "parse_failure" | "empty" | "error";
+
 export type ChatItem =
   | (Base & {
       kind: "user";
@@ -205,6 +208,11 @@ export type ChatItem =
       durationMs?: number;
       costUsd?: number;
       interrupted?: boolean;
+      // The model's last finish reason, as its agent reported it.
+      finishReason?: string;
+      // Set when the turn stopped short of finished work: the reader sees
+      // why instead of a plain "Done".
+      ended?: { reason: TurnEndReason; notice: string };
     })
   | (Base & { kind: "command_output"; text: string })
   // The conversation's MCP servers, as /mcp reports them.

package/lib/chat/registry.ts

@@ -78,6 +78,17 @@ interface Registry {
   listeners: Map<string, Set<Listener>>;
   // What each agent offers per folder: commands, skills, models.
   caps: Map<string, Capabilities>;
+  // Told of every finished turn (lib/analyst), set by the server.
+  turnEndHook?: TurnEndHook;
+}
+
+export type TurnEndHook = (
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+) => void;
+
+export function setTurnEndHook(fn: TurnEndHook): void {
+  registry.turnEndHook = fn;
 }
 
 // Shared across every module instance in the process (custom server and the
@@ -102,6 +113,8 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
     (m.type === "item" && m.item.kind === "turn_end")
   )
     touchActive(sessionId);
+  if (m.type === "item" && m.item.kind === "turn_end")
+    registry.turnEndHook?.(sessionId, m.item);
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/store.ts

@@ -153,6 +153,25 @@ export function lastItems(
   return rows.reverse().map((r) => JSON.parse(r.data) as ChatItem);
 }
 
+// The items after `afterItemId`, oldest first, at most the latest `limit`;
+// with no item given (or one since deleted), just the latest `limit`.
+export function itemsAfter(
+  sessionId: string,
+  afterItemId: string | null,
+  limit = 400
+): ChatItem[] {
+  flushItems();
+  const rows = db
+    .prepare(
+      `SELECT data FROM chat_items WHERE session_id = ?
+         AND seq > COALESCE((SELECT seq FROM chat_items
+           WHERE session_id = ? AND item_id = ?), -1)
+       ORDER BY seq DESC LIMIT ?`
+    )
+    .all(sessionId, sessionId, afterItemId, limit) as { data: string }[];
+  return rows.reverse().map((r) => JSON.parse(r.data) as ChatItem);
+}
+
 // What the agent has said since the last message to it, as text: where a
 // chat task's BLOCKED: line stays until someone answers it.
 export function saidSinceLastMessage(sessionId: string, n = 20): string {

package/lib/chat/turns.ts

@@ -107,6 +107,7 @@ export function eventTurnAt(
     (i) =>
       i.kind === "plan" ||
       i.kind === "error" ||
+      (i.kind === "turn_end" && !!i.ended) ||
       isQuestionTool(i) ||
       isAskTool(i) ||
       (i.kind === "approval" && i.status === "pending")

package/lib/chat/worker/extras.ts

@@ -38,11 +38,13 @@ async function ownExtras(session: Session): Promise<RoleExtras> {
     return (await import("../../orchestrator/worker")).orchestratorExtras(
       session
     );
-  if (!session.task_brief) return {};
+  // A role's brief (and an analyst's) is the session's own system prompt.
+  const own = session.system_prompt?.trim();
+  if (!session.task_brief) return own ? { systemAppend: own } : {};
   const atTokens =
     session.task_status === "running" ? refreshSettings().taskTokens : 0;
   return {
-    systemAppend: session.task_brief,
+    systemAppend: [session.task_brief, own].filter(Boolean).join("\n\n"),
     ...(atTokens > 0 && { refresh: { atTokens, role: "task" as const } }),
   };
 }

package/lib/claims/collectLocal.ts

@@ -46,7 +46,9 @@ export async function changedFiles(
       : git(dir, ["diff", "--name-only", "-z", "HEAD"], OPTS).catch(() => ""),
     git(dir, ["ls-files", "--others", "--exclude-standard", "-z"], OPTS),
   ]);
-  return [...new Set([...paths(committed), ...paths(untracked)])];
+  return [...new Set([...paths(committed), ...paths(untracked)])].filter(
+    (p) => !p.split("/").some((seg) => seg.endsWith(".aos-partial"))
+  );
 }
 
 // Sessions that can hold a claim: local, not a mirror of another machine's.

package/lib/db/changes.ts

@@ -49,6 +49,17 @@ export const TABLES_WATCHED_SESSION_GROUPS = ["session_groups"] as const;
 
 export const TABLES_WATCHED_WORK_CLAIMS = ["work_claims"] as const;
 
+export const TABLES_WATCHED_ANALYST = [
+  "analyst_links",
+  "analyst_recommendations",
+] as const;
+
+export const TABLES_WATCHED_LOOPS = [
+  "task_loops",
+  "task_loop_criteria",
+  "task_loop_cycles",
+] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -61,6 +72,8 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_LEARNING_CARDS,
   ...TABLES_WATCHED_SESSION_GROUPS,
   ...TABLES_WATCHED_WORK_CLAIMS,
+  ...TABLES_WATCHED_ANALYST,
+  ...TABLES_WATCHED_LOOPS,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations/20261021T1400_session_agent_roles.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+import { createSessionRowsView } from "../session-parts/view";
+
+export default {
+  key: "20261021T1400_session_agent_roles",
+  up: (db) => {
+    // The role a session was started in (developer, analyst, reviewer,
+    // supervisor) and the crew it works with: the id of the session that
+    // began it. Additive.
+    const cols = (
+      db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+    ).map((c) => c.name);
+    if (!cols.includes("agent_role"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN agent_role TEXT`);
+    if (!cols.includes("crew_id"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN crew_id TEXT`);
+    db.exec(`CREATE INDEX IF NOT EXISTS sessions_crew ON sessions(crew_id)`);
+    createSessionRowsView(db);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261021T1430_analyst_links.ts

@@ -0,0 +1,52 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_ANALYST } from "../changes";
+
+export default {
+  key: "20261021T1430_analyst_links",
+  up: (db) => {
+    // A coding chat paired with an analyst chat that reviews each of its
+    // turns (lib/analyst). Rows are kept after unlinking.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS analyst_links (
+        id TEXT PRIMARY KEY,
+        coder_session_id TEXT NOT NULL,
+        analyst_session_id TEXT NOT NULL,
+        paused INTEGER NOT NULL DEFAULT 0,
+        reviewed_through TEXT,
+        pending_digest_id TEXT,
+        pending_through TEXT,
+        digest_signals TEXT,
+        created_at INTEGER NOT NULL,
+        ended_at INTEGER
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS analyst_links_coder_live
+        ON analyst_links(coder_session_id) WHERE ended_at IS NULL;
+      CREATE UNIQUE INDEX IF NOT EXISTS analyst_links_analyst
+        ON analyst_links(analyst_session_id);
+      CREATE TABLE IF NOT EXISTS analyst_recommendations (
+        id TEXT PRIMARY KEY,
+        link_id TEXT NOT NULL,
+        analyst_item_id TEXT NOT NULL,
+        coder_through TEXT,
+        verdict TEXT,
+        summary TEXT NOT NULL DEFAULT '',
+        issues TEXT NOT NULL DEFAULT '[]',
+        signals TEXT,
+        prompt TEXT,
+        state TEXT NOT NULL DEFAULT 'open',
+        error TEXT,
+        sent_text TEXT,
+        sent_item_id TEXT,
+        edited INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        decided_at INTEGER
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS analyst_recs_item
+        ON analyst_recommendations(link_id, analyst_item_id);
+      CREATE INDEX IF NOT EXISTS analyst_recs_link
+        ON analyst_recommendations(link_id, created_at);
+    `);
+    // The pane's card and the sidebar refetch when either changes.
+    installChangeTriggers(db, TABLES_WATCHED_ANALYST);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261021T1600_task_loops.ts

@@ -0,0 +1,81 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_LOOPS } from "../changes";
+
+export default {
+  key: "20261021T1600_task_loops",
+  up: (db) => {
+    // The developer-analyst loop (lib/loops): one loop per run on a task, its
+    // acceptance checklist, and one row per cycle. Rows are kept for good.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS task_loops (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        workspace_id TEXT,
+        state TEXT NOT NULL DEFAULT 'running',
+        stop_reason TEXT,
+        stop_detail TEXT,
+        goal TEXT NOT NULL DEFAULT '',
+        max_cycles INTEGER NOT NULL,
+        max_cost_usd REAL NOT NULL,
+        max_minutes INTEGER NOT NULL,
+        grace_seconds INTEGER NOT NULL,
+        stall_cycles INTEGER NOT NULL,
+        repeat_cycles INTEGER NOT NULL,
+        cost_base_usd REAL NOT NULL DEFAULT 0,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        last_cycle_at INTEGER,
+        run_now INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS task_loops_live
+        ON task_loops(session_id) WHERE state = 'running';
+      CREATE INDEX IF NOT EXISTS task_loops_session
+        ON task_loops(session_id, started_at);
+      CREATE TABLE IF NOT EXISTS task_loop_criteria (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        loop_id TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        text TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'user',
+        evidence_kind TEXT,
+        status TEXT NOT NULL DEFAULT 'open',
+        evidence TEXT,
+        verified INTEGER NOT NULL DEFAULT 1,
+        met_cycle INTEGER,
+        waived_by TEXT,
+        removed INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS task_loop_criteria_loop
+        ON task_loop_criteria(loop_id, position);
+      CREATE TABLE IF NOT EXISTS task_loop_cycles (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        loop_id TEXT NOT NULL,
+        n INTEGER NOT NULL,
+        trigger TEXT NOT NULL,
+        state TEXT NOT NULL DEFAULT 'claimed',
+        snapshot_sha TEXT,
+        tree TEXT,
+        changed INTEGER NOT NULL DEFAULT 1,
+        evidence TEXT,
+        log_path TEXT,
+        analysis TEXT,
+        signature TEXT,
+        score TEXT,
+        instruction TEXT,
+        instruction_sent TEXT,
+        sender TEXT,
+        delivery TEXT,
+        send_at INTEGER,
+        input TEXT,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        error TEXT,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS task_loop_cycles_n
+        ON task_loop_cycles(loop_id, n);
+    `);
+    // The loop view refetches when any of them changes.
+    installChangeTriggers(db, TABLES_WATCHED_LOOPS);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261021T1800_health_reports.ts

@@ -0,0 +1,38 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261021T1800_health_reports",
+  up: (db) => {
+    // Plain-English health reports (lib/reports): one row per report, the
+    // report itself as JSON, and the next-prompt draft of a task with no
+    // analyst. Rows are kept for good.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS health_reports (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        workspace_id TEXT,
+        head TEXT,
+        trigger TEXT NOT NULL,
+        evidence_hash TEXT NOT NULL,
+        data TEXT NOT NULL,
+        model TEXT,
+        cost_usd REAL,
+        draft_text TEXT,
+        draft_status TEXT,
+        draft_decided_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS health_reports_session
+        ON health_reports(session_id, id);
+      -- The operating mode (manual / assisted / autonomous) of a workspace
+      -- (the default) or of one task (the override).
+      CREATE TABLE IF NOT EXISTS operating_modes (
+        scope TEXT NOT NULL,
+        scope_id TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (scope, scope_id)
+      );
+    `);
+  },
+} satisfies Migration;

package/lib/db/session-parts/columns.ts

@@ -184,4 +184,6 @@ export const SESSION_ROW_COLUMNS: readonly string[] = [
   "plan_waits_for_caller",
   "plan_handoff_message",
   "session_group_id",
+  "agent_role",
+  "crew_id",
 ];

package/lib/db/types.ts

@@ -111,6 +111,9 @@ export interface Session {
   pinned: boolean;
   // The user's group it sits in (session_groups), or null.
   session_group_id?: string | null;
+  // The agent role it was started in (lib/models/agent-roles) and its crew.
+  agent_role?: string | null;
+  crew_id?: string | null;
   // A workspace's standing orchestrator chat (and that workspace), or null.
   role: "orchestrator" | null;
   // An orchestrator's tool-call secret.

package/lib/done/archive.ts

@@ -6,6 +6,7 @@ import { db, queries, type Session } from "../db";
 import { statusOf } from "../orchestrator/facts";
 import { kickWaits } from "../bus/waits/kick";
 import { peerSessionLink } from "../hosts/peer-actions";
+import { endLinkOf } from "../analyst/endLink";
 
 export interface ArchivedView {
   id: string;
@@ -27,6 +28,7 @@ export function archiveSession(id: string): void {
   db.prepare(
     `UPDATE sessions SET archived_at = datetime('now') WHERE id = ? AND archived_at IS NULL`
   ).run(id);
+  endLinkOf(id);
   kickWaits();
 }
 

package/lib/done/index.ts

@@ -33,6 +33,7 @@ import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { hostLink } from "../hosts/remote-api";
 import { doneHeldTask, isHeldRemote } from "../tasks/contract/held-calls";
 import { captureMergedTask } from "../session-logs";
+import { taskEnded } from "../reports/end-hook";
 import { sessionEnded } from "../experiments/hooks";
 import { pushMerged } from "../notify/push/events";
 import { setPr, setTask } from "../db/session-parts";
@@ -119,6 +120,7 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
   if (status === "merged") {
     pushMerged(s.id);
     void captureMergedTask(s.id, { head: pr?.head });
+    taskEnded(s.id);
   }
 }
 

package/lib/drafts.ts

@@ -29,6 +29,12 @@ export interface Draft {
   // A task's own model, "provider/model"; unset, its roles' models
   // (lib/models).
   taskModel?: string | null;
+  // Start in an agent role (Developer, Analyst, Reviewer, Supervisor): its
+  // binding picks the model; roleModel overrides it for this session.
+  agentRole?: string | null;
+  roleModel?: string | null;
+  // Pair it with an analyst that reviews each turn (a local chat only).
+  withAnalyst?: boolean;
   // A task's priority in the queue; unset: normal.
   taskPriority?: Priority;
   createdAt: number;