@saadnvd1/agent-os 0.3.821 → 0.3.825

package/lib/fork/view.ts

@@ -0,0 +1,116 @@
+/** What clients and `aos children` show, and the numbers behind them. */
+
+import { childrenOf, getGroup } from "./ledger";
+import type { ChildRow, ChildView, GroupView } from "./types";
+
+export const childView = (c: ChildRow): ChildView => ({
+  id: c.child_session_id,
+  n: 0,
+  group: c.group_id,
+  label: c.label,
+  instruction: c.instruction,
+  state: c.state,
+  hold: c.hold,
+  outcome: c.outcome,
+  summary: c.summary,
+  resultKind: c.result_kind,
+  worktree: !!c.worktree,
+  fellBack: !!c.fell_back,
+  startedAt: c.started_at,
+  settledAt: c.settled_at,
+  delivered: c.delivered_at != null,
+  asks: c.state === "needs_input" ? c.hold : null,
+});
+
+export function childrenView(parentId: string): {
+  children: ChildView[];
+  groups: GroupView[];
+} {
+  const rows = childrenOf(parentId);
+  const seen = new Set<string>();
+  const groups: GroupView[] = [];
+  for (const c of rows) {
+    if (seen.has(c.group_id)) continue;
+    seen.add(c.group_id);
+    const g = getGroup(c.group_id);
+    if (g)
+      groups.push({
+        id: g.id,
+        delivery: g.delivery,
+        context: g.context,
+        startedBy: g.started_by,
+        createdAt: g.created_at,
+        stats: null,
+      });
+  }
+  return {
+    children: rows.map((c, i) => ({ ...childView(c), n: i + 1 })),
+    groups,
+  };
+}
+
+const median = (xs: number[]): number | null => {
+  if (!xs.length) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+};
+
+export interface ForkStats {
+  children: number;
+  settled: number;
+  ok: number;
+  failed: number;
+  cancelled: number;
+  implicit: number;
+  fellBack: number;
+  medianSeconds: number | null;
+  tokensIn: number;
+  tokensOut: number;
+  cacheRead: number;
+  heavyRuns: number;
+  delivered: number;
+  opened: number;
+  mentioned: number;
+}
+
+export function statsOf(rows: ChildRow[]): ForkStats {
+  const done = rows.filter((c) => c.state === "settled");
+  const sum = (f: (c: ChildRow) => number | null) =>
+    rows.reduce((n, c) => n + (f(c) ?? 0), 0);
+  return {
+    children: rows.length,
+    settled: done.length,
+    ok: done.filter((c) => c.outcome === "ok").length,
+    failed: done.filter((c) => c.outcome === "failed").length,
+    cancelled: done.filter((c) => c.outcome === "cancelled").length,
+    implicit: done.filter(
+      (c) => c.result_kind === "implicit" && c.outcome === "ok"
+    ).length,
+    fellBack: rows.filter((c) => c.fell_back).length,
+    medianSeconds: median(
+      done
+        .filter((c) => c.started_at && c.settled_at)
+        .map((c) => Math.round((c.settled_at! - c.started_at!) / 1000))
+    ),
+    tokensIn: sum((c) => c.tokens_in),
+    tokensOut: sum((c) => c.tokens_out),
+    cacheRead: sum((c) => c.cache_read),
+    heavyRuns: sum((c) => c.heavy_runs),
+    delivered: rows.filter((c) => c.delivered_at != null).length,
+    opened: rows.filter((c) => c.used === "opened").length,
+    mentioned: rows.filter((c) => c.used === "mentioned").length,
+  };
+}
+
+export function statsText(s: ForkStats): string {
+  const pct = (n: number) =>
+    s.settled ? `${Math.round((n / s.settled) * 100)}%` : "-";
+  return [
+    `${s.children} children, ${s.settled} settled (${s.ok} ok, ${s.failed} failed, ${s.cancelled} cancelled)`,
+    `returned without aos return: ${s.implicit} (${pct(s.implicit)}); started from a brief, not a fork: ${s.fellBack}`,
+    `median time to settle: ${s.medianSeconds ?? "-"}s`,
+    `tokens: ${s.tokensIn} in, ${s.tokensOut} out, ${s.cacheRead} cache read`,
+    `heavy runs queued: ${s.heavyRuns}`,
+    `results delivered: ${s.delivered}; opened in full: ${s.opened}; mentioned later: ${s.mentioned}`,
+  ].join("\n");
+}

package/lib/fork/waits.ts

@@ -0,0 +1,83 @@
+/** `aos wait children`: the parent ends its turn and is woken with results. */
+
+import { db } from "../db";
+import { numberOf, openChildren, childrenOf, undelivered } from "./ledger";
+import { deliverNow } from "./deliver";
+
+interface WaitRow {
+  id: number;
+  parent_session_id: string;
+  mode: "all" | "any";
+  created_at: number;
+  deadline: number;
+}
+
+export const MAX_WAIT_MS = 24 * 60 * 60_000;
+export const DEFAULT_WAIT_MS = 30 * 60_000;
+
+export const openForkWait = (parentId: string): WaitRow | undefined =>
+  db
+    .prepare(
+      `SELECT * FROM fork_waits WHERE parent_session_id = ? AND closed_at IS NULL`
+    )
+    .get(parentId) as WaitRow | undefined;
+
+export function registerForkWait(
+  parentId: string,
+  mode: "all" | "any",
+  timeoutMs = DEFAULT_WAIT_MS,
+  now = Date.now()
+): { id: number; deadline: number } | { already: string } {
+  const open = childrenOf(parentId).filter((c) => c.state !== "settled");
+  const waiting = undelivered(parentId);
+  if (!open.length && !waiting.length)
+    return { already: "you have no running forks and no unread results" };
+  const deadline = now + Math.min(Math.max(timeoutMs, 60_000), MAX_WAIT_MS);
+  // One wait per parent: a new one replaces it.
+  db.prepare(
+    `UPDATE fork_waits SET closed_at = ? WHERE parent_session_id = ? AND closed_at IS NULL`
+  ).run(now, parentId);
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO fork_waits (parent_session_id, mode, created_at, deadline) VALUES (?, ?, ?, ?)`
+    )
+    .run(parentId, mode, now, deadline);
+  return { id: Number(lastInsertRowid), deadline };
+}
+
+const close = (id: number, now: number): boolean =>
+  db
+    .prepare(
+      `UPDATE fork_waits SET closed_at = ? WHERE id = ? AND closed_at IS NULL`
+    )
+    .run(now, id).changes === 1;
+
+export async function tickForkWaits(now = Date.now()): Promise<void> {
+  const waits = db
+    .prepare(`SELECT * FROM fork_waits WHERE closed_at IS NULL`)
+    .all() as WaitRow[];
+  for (const w of waits) {
+    const ready = undelivered(w.parent_session_id);
+    const open = openChildren(w.parent_session_id);
+    const holds =
+      w.mode === "all"
+        ? open.length === 0
+        : ready.length > 0 || open.length === 0;
+    const timedOut = now >= w.deadline;
+    if (!holds && !timedOut) continue;
+    if (!close(w.id, now)) continue;
+    if (!ready.length && !timedOut) continue;
+    if (!ready.length) {
+      const { sendChat } = await import("../chat/runner");
+      await sendChat(w.parent_session_id, {
+        id: `fork-w-${w.id}`,
+        text: `[AgentOS: your wait on forks timed out; ${open.map((c) => numberOf(w.parent_session_id, c.child_session_id)).join(", ")} still running. \`aos children\` shows them.]`,
+        queue: true,
+        from: "AgentOS",
+        origin: { kind: "event", label: "Forks" },
+      });
+      continue;
+    }
+    await deliverNow(w.parent_session_id, ready);
+  }
+}

package/lib/fork/worktree.ts

@@ -0,0 +1,115 @@
+/**
+ * A throwaway checkout for a fork child that has to edit code to find its
+ * answer (`aos fork --worktree`): detached at the parent's HEAD, with the
+ * parent's uncommitted changes applied on top, so it sees what the parent
+ * sees. No branch is made and nothing from it is merged; it is removed when
+ * the child settles.
+ */
+
+import fs from "fs";
+import path from "path";
+import { git } from "../git-exec";
+import { setupWorktree } from "../env-setup";
+import { forkHome, worktreeOf } from "./scratch";
+
+const MAX_UNTRACKED = 200;
+const MAX_UNTRACKED_BYTES = 5_000_000;
+// A change to these means the parent's installed packages may not match.
+const DEPENDENCY_FILES =
+  /(^|\/)(package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$/;
+
+export interface ForkWorktree {
+  // Where the child runs: the parent's folder, in the checkout.
+  cwd: string;
+  // The checkout's root.
+  root: string;
+  // The parent's packages are linked in instead of installed.
+  linked: boolean;
+  // The commit it started from, for the child's return.
+  head: string;
+}
+
+export async function createForkWorktree(opts: {
+  childId: string;
+  parentCwd: string;
+}): Promise<ForkWorktree> {
+  const cwd = opts.parentCwd;
+  const top = (await git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+  const head = (await git(top, ["rev-parse", "HEAD"])).trim();
+  const wt = worktreeOf(opts.childId);
+  await fs.promises.mkdir(forkHome(opts.childId), { recursive: true });
+  try {
+    await git(top, ["worktree", "add", "--detach", "--", wt, head], {
+      timeout: 5 * 60_000,
+    });
+    const diff = await git(top, ["diff", "HEAD", "--binary"], {
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    if (diff.trim())
+      await git(wt, ["apply", "--whitespace=nowarn", "--binary", "-"], {
+        input: diff,
+      });
+    await copyUntracked(top, wt);
+    const changed = (await git(top, ["diff", "HEAD", "--name-only"]))
+      .split("\n")
+      .filter(Boolean);
+    const hasPackages = await exists(path.join(top, "node_modules"));
+    const linked =
+      hasPackages && !changed.some((f) => DEPENDENCY_FILES.test(f));
+    if (linked)
+      await fs.promises.symlink(
+        path.join(top, "node_modules"),
+        path.join(wt, "node_modules")
+      );
+    const setup = await setupWorktree({
+      worktreePath: wt,
+      sourcePath: top,
+      skipInstall: linked,
+    });
+    if (!setup.success)
+      throw new Error(
+        setup.steps.find((s) => !s.success)?.error ?? "worktree setup failed"
+      );
+    return {
+      cwd: path.join(wt, path.relative(top, cwd)),
+      root: wt,
+      linked,
+      head,
+    };
+  } catch (error) {
+    const { removeFork } = await import("./scratch");
+    await removeFork(opts.childId);
+    throw error;
+  }
+}
+
+const exists = (p: string) =>
+  fs.promises.access(p).then(
+    () => true,
+    () => false
+  );
+
+// Files the parent made and hasn't added yet, which a diff doesn't carry.
+async function copyUntracked(top: string, wt: string): Promise<void> {
+  const out = await git(top, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+  ]);
+  const files = out.split("\0").filter(Boolean);
+  if (files.length > MAX_UNTRACKED)
+    throw new Error(
+      `the parent has ${files.length} new files; commit or stage them first`
+    );
+  for (const rel of files) {
+    const from = path.join(top, rel);
+    const stat = await fs.promises.lstat(from);
+    if (stat.isSymbolicLink() || !stat.isFile()) continue;
+    if (stat.size > MAX_UNTRACKED_BYTES)
+      throw new Error(`${rel} is too large to carry into a checkout`);
+    const to = path.join(wt, rel);
+    await fs.promises.mkdir(path.dirname(to), { recursive: true });
+    await fs.promises.copyFile(from, to);
+  }
+}

package/lib/orchestrator/shell-guard.ts

@@ -37,7 +37,7 @@ export interface ShellContext {
   protectedPids: () => Promise<Set<number>>;
 }
 
-interface Invocation {
+export interface Invocation {
   name: string;
   args: string[];
   cmd: SimpleCommand;
@@ -87,7 +87,10 @@ const SHELLS = /^(ba|z|da|k|fi|c|tc)?sh$/;
 
 // What a simple command runs once its wrappers are taken off: one
 // invocation, or several (`bash -c '…'`, `find -exec`).
-function invocations(cmd: SimpleCommand, depth = 0): Invocation[] | string {
+export function invocations(
+  cmd: SimpleCommand,
+  depth = 0
+): Invocation[] | string {
   let words = cmd.words;
   for (;;) {
     while (
@@ -183,7 +186,7 @@ function findInvocations(
 }
 
 // Words that aren't options; `--` ends options. `values` take the next word.
-function positionals(args: string[], values: string[] = []): string[] {
+export function positionals(args: string[], values: string[] = []): string[] {
   const out: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const a = args[i];

package/lib/orchestrator/write-guard.ts

@@ -130,7 +130,7 @@ const FOLDS_CASE =
 const key = (p: string) =>
   FOLDS_CASE ? p.normalize("NFC").toLowerCase() : p.normalize("NFC");
 
-const within = (p: string, root: string) => {
+export const within = (p: string, root: string) => {
   const [a, b] = [key(p), key(root)];
   return a === b || a.startsWith(b === "/" ? b : b + "/");
 };

package/lib/security/demo.ts

@@ -120,10 +120,9 @@ const READS = [
   "schedules",
   "schedules/[id]",
   "orchestrators",
-  "orchestrate/workers",
-  "orchestrate/workers/[id]",
   "bus/messages",
   "bus/peers",
+  "fork/children",
   "usage",
   "vendor/mermaid",
   "artifacts/[id]",

package/lib/sessions/end.ts

@@ -5,6 +5,8 @@ import { endTmuxSession } from "../tmux/end";
 import { releaseOnEnd, shutTaskSimulators } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 import { kickWaits } from "../bus/waits/kick";
+import { openChildren } from "../fork/ledger";
+import { cancelChildren } from "../fork/settle";
 
 type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
   Partial<Pick<Session, "worktree_path" | "branch_name">>;
@@ -14,6 +16,9 @@ type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
 // finish share.
 export async function endSessionAgent(s: Agent): Promise<void> {
   forgetPlanWait(s.id);
+  // Its forks have no one to report to.
+  if (openChildren(s.id).length)
+    void cancelChildren(s.id).catch(() => undefined);
   stopChat(s.id);
   // The task's simulator goes with it; no row, no work.
   releaseOnEnd(s.id, { remove: true });

package/package.json

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

package/server.ts

@@ -17,6 +17,7 @@ import { stackStartGate } from "./lib/orchestrator/brakes";
 import { buildId } from "./lib/build";
 import { startOrchestratorWatcher } from "./lib/orchestrator/watcher";
 import { startWaitWatcher } from "./lib/bus/waits/tick";
+import { startForkWatcher } from "./lib/fork/tick";
 import { installErrorCounter } from "./lib/health/errors";
 import { recordBoot } from "./lib/health/boots";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
@@ -498,6 +499,7 @@ app.prepare().then(async () => {
   if (process.env.AGENTOS_ORCHESTRATOR !== "off") startOrchestratorWatcher();
   // Sessions waiting on each other (aos send --await, aos wait).
   startWaitWatcher();
+  startForkWatcher();
   // Schedules tick here, once a minute, and nowhere else.
   if (schedulesEnabled(process.env)) startScheduler(realDeps);
   // Looking for a newer version, and running an update when one is asked

package/app/api/orchestrate/spawn/route.ts

@@ -1,54 +0,0 @@
-import { NextResponse } from "next/server";
-import { resolveModelForAgent } from "@/lib/model-catalog";
-import { isValidAgentType, type AgentType } from "@/lib/providers";
-import { spawnWorker } from "@/lib/orchestration";
-
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const {
-      conductorSessionId,
-      task,
-      workingDirectory,
-      branchName,
-      useWorktree = true,
-      model,
-      agentType: rawAgentType = "claude",
-    } = body;
-    const agentType: AgentType = isValidAgentType(rawAgentType)
-      ? rawAgentType
-      : "claude";
-    const resolvedModel = resolveModelForAgent(
-      agentType,
-      typeof model === "string" ? model.trim() : model
-    );
-
-    if (!conductorSessionId || !task || !workingDirectory) {
-      return NextResponse.json(
-        {
-          error:
-            "Missing required fields: conductorSessionId, task, workingDirectory",
-        },
-        { status: 400 }
-      );
-    }
-
-    const session = await spawnWorker({
-      conductorSessionId,
-      task,
-      workingDirectory,
-      branchName,
-      useWorktree,
-      model: resolvedModel,
-      agentType,
-    });
-
-    return NextResponse.json({ session });
-  } catch (error) {
-    console.error("Failed to spawn worker:", error);
-    return NextResponse.json(
-      { error: "Failed to spawn worker" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/orchestrate/workers/[id]/route.ts

@@ -1,89 +0,0 @@
-import { NextResponse } from "next/server";
-import {
-  getWorkerOutput,
-  sendToWorker,
-  completeWorker,
-  failWorker,
-  killWorker,
-} from "@/lib/orchestration";
-
-interface RouteParams {
-  params: Promise<{ id: string }>;
-}
-
-// GET /api/orchestrate/workers/[id] - Get worker output
-export async function GET(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const { searchParams } = new URL(request.url);
-    const lines = parseInt(searchParams.get("lines") || "50", 10);
-
-    const output = await getWorkerOutput(id, lines);
-    return NextResponse.json({ output });
-  } catch (error) {
-    console.error("Failed to get worker output:", error);
-    return NextResponse.json(
-      { error: "Failed to get worker output" },
-      { status: 500 }
-    );
-  }
-}
-
-// POST /api/orchestrate/workers/[id] - Send message or update status
-export async function POST(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const body = await request.json();
-    const { action, message } = body;
-
-    switch (action) {
-      case "send":
-        if (!message) {
-          return NextResponse.json(
-            { error: "Missing message" },
-            { status: 400 }
-          );
-        }
-        const sent = await sendToWorker(id, message);
-        return NextResponse.json({ success: sent });
-
-      case "complete":
-        completeWorker(id);
-        return NextResponse.json({ success: true });
-
-      case "fail":
-        failWorker(id);
-        return NextResponse.json({ success: true });
-
-      default:
-        return NextResponse.json(
-          { error: "Invalid action. Use: send, complete, or fail" },
-          { status: 400 }
-        );
-    }
-  } catch (error) {
-    console.error("Failed to perform worker action:", error);
-    return NextResponse.json(
-      { error: "Failed to perform worker action" },
-      { status: 500 }
-    );
-  }
-}
-
-// DELETE /api/orchestrate/workers/[id] - Kill worker
-export async function DELETE(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const { searchParams } = new URL(request.url);
-    const cleanupWorktree = searchParams.get("cleanup") === "true";
-
-    await killWorker(id, cleanupWorktree);
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("Failed to kill worker:", error);
-    return NextResponse.json(
-      { error: "Failed to kill worker" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/orchestrate/workers/route.ts

@@ -1,31 +0,0 @@
-import { NextResponse } from "next/server";
-import { getWorkers, getWorkersSummary } from "@/lib/orchestration";
-
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const conductorId = searchParams.get("conductorId");
-    const summaryOnly = searchParams.get("summary") === "true";
-
-    if (!conductorId) {
-      return NextResponse.json(
-        { error: "Missing conductorId parameter" },
-        { status: 400 }
-      );
-    }
-
-    if (summaryOnly) {
-      const summary = await getWorkersSummary(conductorId);
-      return NextResponse.json({ summary });
-    }
-
-    const workers = await getWorkers(conductorId);
-    return NextResponse.json({ workers });
-  } catch (error) {
-    console.error("Failed to get workers:", error);
-    return NextResponse.json(
-      { error: "Failed to get workers" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/sessions/[id]/mcp-config/route.ts

@@ -1,34 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { db, queries, type Session } from "@/lib/db";
-import { ensureMcpConfig } from "@/lib/mcp-config";
-
-// POST /api/sessions/[id]/mcp-config - Ensure MCP config exists for this session
-export async function POST(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  try {
-    const { id } = await params;
-    const session = queries.getSession(db).get(id) as Session | undefined;
-
-    if (!session) {
-      return NextResponse.json({ error: "Session not found" }, { status: 404 });
-    }
-
-    // Expand ~ to home directory
-    const workingDirectory = session.working_directory.replace(
-      /^~/,
-      process.env.HOME || ""
-    );
-
-    ensureMcpConfig(workingDirectory, id);
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("Failed to write MCP config:", error);
-    return NextResponse.json(
-      { error: "Failed to write MCP config" },
-      { status: 500 }
-    );
-  }
-}