@saadnvd1/agent-os 0.3.853 → 0.3.859

package/lib/done/index.ts

@@ -8,6 +8,7 @@
  * its own action, archive.ts). What it will do is decided first (plan.ts).
  */
 
+import { isStandingRole, RoleLabel } from "../leads/roles";
 import { endPauseOnFinish } from "../tasks/pause-hold";
 import { db, queries, type Session } from "../db";
 import { endSessionAgent } from "../sessions/end";
@@ -132,8 +133,8 @@ export async function doneSession(
   // A demo archives and nothing more: no merge, no agent to stop, no
   // worktree to touch.
   if (demoMode()) {
-    if (s.role === "orchestrator")
-      throw new Error("An orchestrator isn't marked done.");
+    if (isStandingRole(s.role))
+      throw new Error(`${RoleLabel(s.role)} isn't marked done.`);
     if (s.archived_at) throw new Error(`${s.name} is already archived.`);
     if (s.task_prompt) setTask(db, s.id, { task_status: "done" });
     archiveSession(s.id);

package/lib/done/plan.ts

@@ -4,6 +4,7 @@
  * single done acts on it; the bulk preview shows it.
  */
 
+import { isStandingRole, roleNoun } from "../leads/roles";
 import { db, stackQueries as sq, type Session } from "../db";
 import type { TaskPR } from "../tasks";
 import { prFor } from "../tasks/session";
@@ -90,8 +91,10 @@ export async function planDone(
   s: Session,
   callerId?: string | null
 ): Promise<DonePlan> {
-  if (s.role === "orchestrator")
-    return refuse(`${s.name} is a workspace's orchestrator; it can't be done`);
+  if (isStandingRole(s.role))
+    return refuse(
+      `${s.name} is a workspace's ${roleNoun(s.role)}; it can't be done`
+    );
   if (s.archived_at) return refuse(`${s.name} is already archived`);
   if (callerId && callerId === s.id)
     return refuse("A session can't mark itself done");

package/lib/experiments/registry.ts

@@ -14,6 +14,8 @@ export interface Experiment {
   status: ExperimentStatus;
   // It shows suggestions, so an accept rate means something for it.
   suggests?: boolean;
+  // Built but not offered in Settings yet: it can be set, nothing lists it.
+  unlisted?: boolean;
 }
 
 export const EXPERIMENTS = [
@@ -34,6 +36,15 @@ export const EXPERIMENTS = [
     area: "sessions",
     status: "experimental",
   },
+  {
+    id: "leads",
+    name: "Leads",
+    description:
+      "Department heads and a chief of staff, per workspace. Off, nothing changes. On, you choose which workspaces get leads; each gets its own chief.",
+    area: "orchestrator",
+    status: "experimental",
+    unlisted: true,
+  },
 ] as const satisfies readonly Experiment[];
 
 export type ExperimentId = (typeof EXPERIMENTS)[number]["id"];

package/lib/experiments/view.ts

@@ -15,5 +15,7 @@ export const experimentView = (id: ExperimentId): ExperimentView => ({
 
 export const experimentsView = () => ({
   locked: experimentsLocked(),
-  experiments: EXPERIMENTS.map((e) => experimentView(e.id)),
+  experiments: EXPERIMENTS.filter((e: Experiment) => !e.unlisted).map((e) =>
+    experimentView(e.id)
+  ),
 });

package/lib/fork/brief.ts

@@ -3,7 +3,7 @@
 import { FORK_LIMITS } from "./options";
 import type { ChildRow } from "./types";
 
-export const PARENT_BRIEF = `Forks: when the user asks you to fork, or to do things in parallel in background copies, run \`aos fork "<instruction>" ...\` (one instruction per fork), keep working, and results arrive as a message. Also when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own throwaway checkout). Fork only work that doesn't depend on your next step.`;
+export const PARENT_BRIEF = `Forks: when the user asks you to fork, or to do things in parallel in background copies, run \`aos fork "<instruction>" ...\` (one instruction per fork), keep working, and results arrive as a message. Also when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own checkout). Fork only work that doesn't depend on your next step.`;
 
 export const CHILD_BRIEF = `You are a fork child: a background copy of another session, started to do one piece of work and report back. You have its abilities, not its checkout: don't change the parent's files, push, open a PR or fork. Put temp work (scripts, repros, notes) in $AOS_SCRATCH. Run builds and tests only through \`aos heavy -- <command>\`, which queues you with the other forks. To ask the parent something, \`aos send <parent> "<question>"\`; that doesn't finish you. When done, \`aos return "<result>"\` (first line: the answer in a sentence; then the detail; \`--failed\` if you couldn't do it). Your reply when you end your turn without it is used as the result, after a short wait.`;
 
@@ -22,7 +22,7 @@ export function childFirstMessage(opts: {
     opts.instruction.trim(),
     "",
     opts.worktree && opts.checkout
-      ? `You work in your own checkout (${opts.checkout}), a copy of the parent's changes as they were when you started. Scratch folder: ${opts.scratch}.`
+      ? `You work in your own checkout (${opts.checkout}), a copy of the parent's changes as they were when you started. Scratch folder: ${opts.scratch}. Both are kept after you return.`
       : `You work in the parent's checkout: read freely, but don't change it. Scratch folder: ${opts.scratch} ($AOS_SCRATCH).`,
     "Finish with `aos return`.",
   ];

package/lib/fork/extras.ts

@@ -1,5 +1,6 @@
 /** What a chat worker adds for fork parents and children. */
 
+import { isStandingRole } from "../leads/roles";
 import os from "os";
 import type { Session } from "../db";
 import type { ToolGuard } from "../chat/driver";
@@ -7,7 +8,7 @@ import { CHILD_BRIEF, PARENT_BRIEF } from "./brief";
 import { forkToolGuard } from "./guard";
 import { getChild } from "./ledger";
 import { forksOn } from "./options";
-import { scratchOf, worktreeOf } from "./scratch";
+import { forksRoot, scratchOf, worktreeOf } from "./scratch";
 import { db } from "../db";
 
 const expand = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
@@ -16,7 +17,7 @@ const expand = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
 // parent, so their prompts match as far as they can).
 export function forkBrief(session: Session): string | null {
   if (getChild(session.id)) return CHILD_BRIEF;
-  if (!forksOn() || session.role === "orchestrator" || session.view !== "chat")
+  if (!forksOn() || isStandingRole(session.role) || session.view !== "chat")
     return null;
   return PARENT_BRIEF;
 }
@@ -46,6 +47,7 @@ export function childExtras(
         parent?.working_directory ?? session.working_directory
       ),
       scratch,
+      forksRoot: forksRoot(),
       ownCheckout: child.worktree ? worktreeOf(session.id) : null,
       cwd: expand(session.working_directory),
     }),

package/lib/fork/guard.ts

@@ -27,6 +27,8 @@ export interface ForkGuardContext {
   parentCheckout: string;
   // The child's scratch folder: free to write.
   scratch: string;
+  // Where every fork's folders live; the others' are never written.
+  forksRoot: string;
   // Its own throwaway checkout, when it has one: free to write.
   ownCheckout: string | null;
   // Where the child runs; relative paths start here.
@@ -39,7 +41,7 @@ const WHERE = (c: ForkGuardContext) =>
     : `put temp work in ${c.scratch} (AOS_SCRATCH), or ask for \`aos fork --worktree\` to edit code`;
 
 const noWrite = (c: ForkGuardContext, what: string) =>
-  `Refused: ${what} would change the parent's checkout, which it is working in. ${WHERE(c)}.`;
+  `Refused: ${what} would change the parent's checkout or another fork's folder, which they are working in. ${WHERE(c)}.`;
 
 // Commands whose every path argument is something they change.
 const MUTATORS = new Set([
@@ -134,7 +136,7 @@ async function protectedPath(
     c.ownCheckout ? physicalPath(c.ownCheckout) : Promise.resolve(null),
   ]);
   if (within(r, scratch) || (own && within(r, own))) return false;
-  return within(r, parent);
+  return within(r, parent) || within(r, await physicalPath(c.forksRoot));
 }
 
 // A file tool's refusal, or null.

package/lib/fork/scratch.ts

@@ -1,14 +1,17 @@
 /**
  * A fork child's own folders under the data root: a scratch folder for temp
- * work (scripts, repros, notes), and, when it was asked for, a throwaway
- * checkout. Both are removed when the child settles or is dropped, and a
- * sweep removes what a crash left.
+ * work (scripts, repros, notes), and, when it was asked for, its own
+ * checkout. Settling a child removes nothing: they are kept while its
+ * session is open, and tidied up after it closes only when nothing in them
+ * would be lost. Deleting the child's session is the one thing that removes
+ * them whatever they hold.
  */
 
 import fs from "fs";
 import path from "path";
 import { agentosHome } from "../agentos-home";
 import { git } from "../git-exec";
+import { describeChanges } from "../worktree-placed";
 
 export const forksRoot = () => agentosHome("forks");
 export const forkHome = (childId: string) => agentosHome("forks", childId);
@@ -17,6 +20,89 @@ export const scratchOf = (childId: string) =>
 export const worktreeOf = (childId: string) =>
   path.join(forkHome(childId), "wt");
 
+// The tree the checkout started from (the parent's changes and what setup
+// placed included), so what the child changed can be told from it.
+export const baseOf = (childId: string) => path.join(forkHome(childId), "base");
+
+const MAX_LISTED = 50;
+
+// A tree of the checkout as it is now, taken through a temporary index so
+// the child's own index is left alone. Ignored files aren't in it.
+export async function snapshotTree(
+  wt: string,
+  childId: string
+): Promise<string> {
+  const index = path.join(forkHome(childId), "index.tmp");
+  const env = { GIT_INDEX_FILE: index };
+  try {
+    await git(wt, ["read-tree", "HEAD"], { env });
+    await git(wt, ["add", "-A", "--", ".", ":(exclude)node_modules"], { env });
+    return (await git(wt, ["write-tree"], { env })).trim();
+  } finally {
+    await fs.promises.rm(index, { force: true });
+  }
+}
+
+async function filesUnder(dir: string, rel = ""): Promise<string[]> {
+  const out: string[] = [];
+  const entries = await fs.promises
+    .readdir(path.join(dir, rel), { withFileTypes: true })
+    .catch(() => []);
+  for (const e of entries) {
+    if (out.length >= MAX_LISTED) break;
+    const r = path.join(rel, e.name);
+    if (e.isDirectory()) out.push(...(await filesUnder(dir, r)));
+    else out.push(r);
+  }
+  return out.slice(0, MAX_LISTED);
+}
+
+// What removing the child's folders would lose: files in its scratch, and
+// changes in its checkout since it started. Null when that can't be told.
+export async function forkLosses(childId: string): Promise<string[] | null> {
+  const lost = (await filesUnder(scratchOf(childId))).map(
+    (f) => `scratch/${f}`
+  );
+  const wt = worktreeOf(childId);
+  if (fs.existsSync(wt)) {
+    try {
+      const base = (
+        await fs.promises.readFile(baseOf(childId), "utf8").catch(() => "")
+      ).trim();
+      if (base) {
+        const now = await snapshotTree(wt, childId);
+        const names = await git(wt, ["diff", "--name-only", base, now]);
+        lost.push(...names.split("\n").filter(Boolean));
+      } else {
+        const st = await git(wt, ["status", "--porcelain"]);
+        lost.push(
+          ...st
+            .split("\n")
+            .filter(Boolean)
+            .map((l) => l.slice(3))
+        );
+      }
+    } catch {
+      return null;
+    }
+  }
+  return lost;
+}
+
+// Removes the child's folders only when nothing in them would be lost.
+export async function tidyFork(childId: string): Promise<boolean> {
+  if (!fs.existsSync(forkHome(childId))) return true;
+  const lost = await forkLosses(childId);
+  if (lost?.length === 0) {
+    await removeFork(childId);
+    return true;
+  }
+  console.log(
+    `[forks] kept ${childId}: ${lost ? describeChanges(lost) : "it couldn't be checked"}`
+  );
+  return false;
+}
+
 // Made on demand, so a settled child that is talked to again has one.
 export async function ensureScratch(childId: string): Promise<string> {
   const dir = scratchOf(childId);
@@ -50,18 +136,22 @@ export async function removeFork(childId: string): Promise<void> {
   await fs.promises.rm(home, { recursive: true, force: true, maxRetries: 3 });
 }
 
-// Folders of children that are settled or gone: what a crash between a
-// settle and its cleanup left. `keep` says whose folders are still in use.
+// Folders of children whose session is closed or gone, tidied the same safe
+// way: what a crash left, and children closed after they settled. `keep`
+// says whose folders are still in use. Patches beside the folders stay.
 export async function sweepForks(
   keep: (childId: string) => boolean
-): Promise<number> {
+): Promise<{ removed: number; kept: number }> {
   const root = forksRoot();
-  const names = await fs.promises.readdir(root).catch(() => [] as string[]);
+  const entries = await fs.promises
+    .readdir(root, { withFileTypes: true })
+    .catch(() => []);
   let removed = 0;
-  for (const name of names) {
-    if (keep(name)) continue;
-    await removeFork(name);
-    removed++;
+  let kept = 0;
+  for (const e of entries) {
+    if (!e.isDirectory() || keep(e.name)) continue;
+    if (await tidyFork(e.name)) removed++;
+    else kept++;
   }
-  return removed;
+  return { removed, kept };
 }

package/lib/fork/settle.ts

@@ -26,7 +26,15 @@ import {
   markDeliveredIds,
 } from "./ledger";
 import { FORK_LIMITS } from "./options";
-import { forksRoot, removeFork, worktreeOf } from "./scratch";
+import {
+  baseOf,
+  forkLosses,
+  forksRoot,
+  scratchOf,
+  snapshotTree,
+  tidyFork,
+  worktreeOf,
+} from "./scratch";
 import type { ChildOutcome, ChildRow, ResultKind } from "./types";
 
 const sessionOf = (id: string) =>
@@ -53,14 +61,17 @@ function tokensOf(childId: string) {
 export const patchPath = (childId: string) =>
   path.join(forksRoot(), `${childId}.patch`);
 
-// What a child changed in its own checkout, kept as a patch the parent can
-// apply: its checkout goes with it.
+// What a child changed in its own checkout (not what the parent had when it
+// started), kept as a patch the parent can apply.
 async function keepPatch(childId: string): Promise<string | null> {
   const wt = worktreeOf(childId);
   if (!fs.existsSync(wt)) return null;
   try {
-    await git(wt, ["add", "-A"]);
-    const diff = await git(wt, ["diff", "--cached", "HEAD", "--binary"], {
+    const base = (
+      await fs.promises.readFile(baseOf(childId), "utf8").catch(() => "")
+    ).trim();
+    const now = await snapshotTree(wt, childId);
+    const diff = await git(wt, ["diff", base || "HEAD", now, "--binary"], {
       maxBuffer: 64 * 1024 * 1024,
     });
     if (!diff.trim()) return null;
@@ -89,12 +100,19 @@ export async function settleAndDeliver(
   const row = getChild(childId);
   if (!row || row.state === "settled") return false;
   let result = s.result ?? null;
-  if (row.worktree && s.outcome !== "cancelled") {
+  if (row.worktree) {
     const patch = await keepPatch(childId);
     if (patch)
       result =
         `${result ?? ""}\n\nIts changes are in ${patch} (apply with \`git apply ${patch}\`).`.trim();
   }
+  if (
+    (await forkLosses(childId).catch(() => null))?.some((f) =>
+      f.startsWith("scratch/")
+    )
+  )
+    result =
+      `${result ?? ""}\n\nIts scratch files are in ${scratchOf(childId)}.`.trim();
   const changed = settleChild(childId, {
     ...s,
     result,
@@ -103,7 +121,11 @@ export async function settleAndDeliver(
   if (!changed) return false;
   // Cancelled by its parent or the user: they know, so nothing is sent.
   if (s.outcome === "cancelled") markDeliveredIds([childId]);
-  await removeFork(childId).catch(() => undefined);
+  // Its folders stay while its session is open; a closed one's go only
+  // when nothing in them would be lost.
+  const session = sessionOf(childId);
+  if (!session || session.archived_at)
+    await tidyFork(childId).catch(() => undefined);
   const { admitQueued } = await import("./start");
   await admitQueued(row.parent_session_id).catch(() => undefined);
   const { kickForks } = await import("./tick");
@@ -175,6 +197,8 @@ const lastReply = (childId: string): string => {
 export async function lookAtChild(row: ChildRow, now: number): Promise<void> {
   if (row.state === "queued" || row.state === "settled") return;
   const session = sessionOf(row.child_session_id);
+  // Its checkout is still being made: no session row yet.
+  if (!session && row.state === "starting") return;
   if (!session || session.archived_at) {
     await settleAndDeliver(row.child_session_id, {
       outcome: "failed",

package/lib/fork/start.ts

@@ -5,6 +5,7 @@
  * holds a slot never waits on its own children.
  */
 
+import { isStandingRole, RoleLabel } from "../leads/roles";
 import os from "os";
 import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
@@ -34,7 +35,7 @@ import {
   setState,
 } from "./ledger";
 import { FORK_LIMITS, FORKS_OFF, forksOn, type DeliveryMode } from "./options";
-import { ensureScratch, removeFork } from "./scratch";
+import { ensureScratch, tidyFork } from "./scratch";
 import { parentSnapshot } from "./snapshot";
 import { createForkWorktree } from "./worktree";
 import type { ChildRow } from "./types";
@@ -66,8 +67,8 @@ export function refusal(parent: Session | undefined): string | null {
   if (!forksOn()) return FORKS_OFF;
   if (!parent) return "Unknown session";
   if (getChild(parent.id)) return "A fork child can't fork";
-  if (parent.role === "orchestrator")
-    return "An orchestrator doesn't fork: start tasks or sessions instead";
+  if (isStandingRole(parent.role))
+    return `${RoleLabel(parent.role)} doesn't fork: start tasks or sessions instead`;
   if (parent.archived_at) return "That session is archived";
   if (parent.view !== "chat") return "Forks work from a chat session";
   if (parent.host_id && parent.host_id !== "local")
@@ -266,7 +267,7 @@ async function startChild(childId: string): Promise<void> {
   } catch (error) {
     const why = error instanceof Error ? error.message : String(error);
     const { settleAndDeliver } = await import("./settle");
-    await removeFork(childId).catch(() => undefined);
+    await tidyFork(childId).catch(() => undefined);
     await settleAndDeliver(childId, {
       outcome: "failed",
       summary: `couldn't start: ${why.split("\n")[0]}`,

package/lib/fork/tick.ts

@@ -7,12 +7,30 @@ import { deliverDue } from "./deliver";
 import { lookAtChild } from "./settle";
 import { tickForkWaits } from "./waits";
 import { forksOn } from "./options";
+import { sweepForks } from "./scratch";
 import type { ChildRow } from "./types";
 
 const EVERY_MS = 5000;
 let running = false;
 let timer: NodeJS.Timeout | null = null;
 let kicked = false;
+const SWEEP_EVERY_MS = 10 * 60_000;
+let sweptAt = 0;
+
+// Folders of children whose session closed after they settled, or a crash.
+async function sweepClosed(now: number): Promise<void> {
+  if (now - sweptAt < SWEEP_EVERY_MS) return;
+  sweptAt = now;
+  const live = db.prepare(
+    `SELECT 1 FROM session_children c
+     LEFT JOIN sessions s ON s.id = c.child_session_id
+     WHERE c.child_session_id = ?
+       AND (c.state != 'settled' OR (s.id IS NOT NULL AND s.archived_at IS NULL))`
+  );
+  await sweepForks((id) => !!live.get(id)).catch((error) =>
+    console.error("[forks] sweep:", error)
+  );
+}
 
 export async function forksTick(now = Date.now()): Promise<void> {
   if (running || !forksOn()) return;
@@ -33,6 +51,7 @@ export async function forksTick(now = Date.now()): Promise<void> {
         await admitQueued(parent);
     await tickForkWaits(now);
     await deliverDue(now);
+    await sweepClosed(now);
   } finally {
     running = false;
   }

package/lib/fork/worktree.ts

@@ -2,15 +2,15 @@
  * 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.
+ * sees. No branch is made and nothing from it is merged; it is kept until
+ * the child's session is closed with nothing changed in it.
  */
 
 import fs from "fs";
 import path from "path";
 import { git } from "../git-exec";
 import { setupWorktree } from "../env-setup";
-import { forkHome, worktreeOf } from "./scratch";
+import { baseOf, forkHome, snapshotTree, worktreeOf } from "./scratch";
 
 const MAX_UNTRACKED = 200;
 const MAX_UNTRACKED_BYTES = 5_000_000;
@@ -70,6 +70,10 @@ export async function createForkWorktree(opts: {
       throw new Error(
         setup.steps.find((s) => !s.success)?.error ?? "worktree setup failed"
       );
+    await fs.promises.writeFile(
+      baseOf(opts.childId),
+      await snapshotTree(wt, opts.childId)
+    );
     return {
       cwd: path.join(wt, path.relative(top, cwd)),
       root: wt,

package/lib/health/env/sendFixNotes.ts

@@ -1,4 +1,5 @@
 import { db } from "@/lib/db";
+import type { SessionRole } from "@/lib/db/types";
 import { MIN } from "../types";
 import { fixFor } from "./fixText";
 import { classById } from "./classes";
@@ -10,11 +11,11 @@ export const STALE_MS = 120 * MIN;
 export interface NoteDeps {
   send: (sessionId: string, body: string) => Promise<void>;
   // Waiting on a person: an approval or a question.
-  blocked: (sessionId: string, role: "orchestrator" | null) => boolean;
+  blocked: (sessionId: string, role: SessionRole | null) => boolean;
 }
 
 interface Target {
-  role: "orchestrator" | null;
+  role: SessionRole | null;
   archived_at: string | null;
   task_status: string | null;
   pause_state: string | null;

package/lib/hosts/peer-actions.ts

@@ -5,6 +5,7 @@
  * (the menu shows the same reasons: lib/hosts/remote-menu.ts).
  */
 
+import { isPeerStanding } from "../leads/roles";
 import { db, type Session } from "../db";
 import { stopChat } from "../chat/runner";
 import { deleteItems } from "../chat/store";
@@ -151,7 +152,7 @@ export async function doneOnPeer(
     throw new Error(
       `${session.name} is a task on ${link.hostName}: sign it off or drop it in Tasks there.`
     );
-  if (there.role)
+  if (isPeerStanding(there.role))
     throw new Error(`${session.name} isn't marked done on ${link.hostName}.`);
   const { outcome } = await hostApi<{
     outcome?: { text?: unknown; worktree?: { action?: unknown } };

package/lib/hosts/peer-sessions.ts

@@ -5,6 +5,7 @@
  * used here are kept, checked and cleaned.
  */
 
+import { isPeerStanding } from "../leads/roles";
 import type { TmuxSessionInfo } from "../status-detector";
 import { isValidTmuxName } from "./attach";
 import { syncPeerMirrors } from "./peer-sync";
@@ -113,7 +114,8 @@ export function toPeerSession(
   if (raw.host_id && raw.host_id !== "local") return null;
   // Its orchestrator and its tasks belong to its own workspace and gates:
   // they're not mirrored as plain sessions here.
-  if (raw.role || raw.task_prompt || raw.task_status) return null;
+  if (isPeerStanding(raw.role) || raw.task_prompt || raw.task_status)
+    return null;
   const tmuxName = typeof raw.tmux_name === "string" ? raw.tmux_name : "";
   const view = raw.view === "chat" ? "chat" : "terminal";
   // A terminal is opened by its tmux name; any name it gives must be one.

package/lib/leads/actor.ts

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "async_hooks";
+import type { Session } from "@/lib/db/types";
+
+// The standing session whose tool call is running: what it sends, starts and
+// notes is its own, not the orchestrator's. Outside a tool call (an event, a
+// route, a timer) there is none, and everything stays the orchestrator's.
+const acting = new AsyncLocalStorage<Session>();
+
+export const asActor = <T>(session: Session, fn: () => T): T =>
+  acting.run(session, fn);
+
+// The caller in this workspace, if a standing session's call is running.
+export function actorIn(workspaceId: string): Session | undefined {
+  const s = acting.getStore();
+  return s && s.workspace_id === workspaceId ? s : undefined;
+}