@saadnvd1/agent-os 0.3.851 → 0.3.859

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/types.ts

@@ -65,6 +65,8 @@ export interface ChildView {
   excerpt: string | null;
   resultKind: ResultKind | null;
   worktree: boolean;
+  // Marked done or archived as a session: it leaves the strip.
+  done: boolean;
   fellBack: boolean;
   startedAt: number | null;
   settledAt: number | null;

package/lib/fork/view.ts

@@ -1,6 +1,7 @@
 /** What clients and `aos children` show, and the numbers behind them. */
 
 import { lastItems } from "../chat/store";
+import { db } from "../db";
 import { childrenOf, getGroup } from "./ledger";
 import type { ChildRow, ChildView, GroupView } from "./types";
 
@@ -17,6 +18,7 @@ export const childView = (c: ChildRow): ChildView => ({
   excerpt: c.result ? c.result.slice(0, 600) : null,
   resultKind: c.result_kind,
   worktree: !!c.worktree,
+  done: false,
   fellBack: !!c.fell_back,
   startedAt: c.started_at,
   settledAt: c.settled_at,
@@ -32,6 +34,13 @@ const activityOf = (c: ChildRow): string | null => {
   return tool && tool.kind === "tool" ? tool.title : null;
 };
 
+const isDone = (id: string): boolean =>
+  !!db
+    .prepare(
+      `SELECT 1 FROM sessions WHERE id = ? AND (settled_at IS NOT NULL OR archived_at IS NOT NULL)`
+    )
+    .get(id);
+
 export function childrenView(parentId: string): {
   children: ChildView[];
   groups: GroupView[];
@@ -57,6 +66,7 @@ export function childrenView(parentId: string): {
     children: rows.map((c, i) => ({
       ...childView(c),
       n: i + 1,
+      done: isDone(c.child_session_id),
       activity: activityOf(c),
     })),
     groups,

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;
+}

package/lib/leads/adopt.ts

@@ -0,0 +1,150 @@
+/**
+ * Adopting an existing chat as a lead. The session keeps its id, its whole
+ * chat and its agent's conversation: it restarts on the same conversation
+ * with the lead's brief and tools, and is asked to carry what matters across
+ * (its memo, and pins proposed from the owner's own messages). Only when the
+ * owner confirms the pins, in one tap, does it switch over to a fresh start
+ * that reads the memo and the direction instead of the old conversation.
+ */
+
+import { db, type Session } from "../db";
+import { owner } from "../owner";
+import { itemsOfKind } from "../chat/store";
+import { originOf } from "../chat/origin";
+import {
+  chatStateNow,
+  freshStartChat,
+  sendChat,
+  stopChat,
+} from "../chat/runner";
+import { removeStaleSocket, waitForExit } from "../chat/worker/client";
+import { AGENTOS_SENDER } from "../orchestrator/deliver";
+import { clip } from "../orchestrator/digest";
+import { addNote } from "../orchestrator/notes";
+import { resolveProposals } from "./direction";
+import { addLeads, getLead, leadTitle, seedCharter } from "./home";
+import { latestMemo } from "./memos";
+import { isLeadKind, isStandingRole, sqlNoRole } from "./roles";
+import { TECH, type DirectionPin, type LeadKind } from "./types";
+
+// How many of the owner's last messages the handover offers as pins.
+const OFFERED = 20;
+
+const sessionRow = (id: string) =>
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    Session | undefined;
+
+// Why this session can't become this lead, or null.
+function refusal(s: Session | undefined, kind: LeadKind): string | null {
+  if (!s) return "No such session";
+  if (kind === TECH)
+    return "The Tech lead is the workspace's orchestrator; adopt another kind";
+  if (!isLeadKind(kind)) return `"${kind}" isn't a lead's name`;
+  if (isStandingRole(s.role)) return "That session already heads something";
+  if (s.view !== "chat" || s.agent_type !== "claude")
+    return "Only a Claude chat session can be adopted as a lead";
+  if (s.task_status || s.worktree_path)
+    return "A task's session can't be a lead";
+  if (s.archived_at) return "Unarchive the session first";
+  if (s.host_id && s.host_id !== "local")
+    return "Only a session on this machine can be adopted";
+  return null;
+}
+
+function handover(sessionId: string, title: string): string {
+  const who = owner();
+  const offered = itemsOfKind(sessionId, "user")
+    .filter((i) => originOf(i) === null && i.text.trim())
+    .slice(-OFFERED)
+    .map((i) => `- [item ${i.id}] ${clip(i.text, 300)}`);
+  return [
+    `You are now this workspace's ${title}. AgentOS kept this conversation, so you still know everything in it; your brief and tools are a lead's from this message on.`,
+    `Before you switch over to a fresh start (which carries only your memo and your pinned direction, never this conversation), carry across what matters:`,
+    `1. Write your memo with update_memo: what you're working on, what's decided and why, and what's next. Keep it short (about 1.5k tokens).`,
+    `2. Propose pins with propose_pin, one call per message, for ${who}'s messages below that set standing direction (not one-off requests). ${who} confirms them with one tap; until he does, none of it is direction.`,
+    offered.length
+      ? `${who}'s recent messages in this chat:\n${offered.join("\n")}`
+      : `${who} has no messages in this chat to pin.`,
+    "Then say in a sentence or two what you saved. The switch happens when he confirms.",
+  ].join("\n\n");
+}
+
+// Stops the session's worker, if one runs, and waits for it to be gone, so
+// the next message starts one with the lead's brief and tools.
+async function restartWorker(sessionId: string): Promise<void> {
+  const state = await chatStateNow(sessionId).catch(() => null);
+  if (state === "running" || state === "waiting")
+    throw new Error("Adopt it when its current turn has ended");
+  stopChat(sessionId);
+  await waitForExit(sessionId);
+  removeStaleSocket(sessionId);
+}
+
+export async function adoptLead(input: {
+  sessionId: string;
+  workspaceId: string;
+  kind: LeadKind;
+}): Promise<Session> {
+  const { sessionId, workspaceId, kind } = input;
+  const why = refusal(sessionRow(sessionId), kind);
+  if (why) throw new Error(why);
+  if (getLead(workspaceId, kind))
+    throw new Error(
+      `This workspace already has a ${leadTitle(workspaceId, kind)}`
+    );
+  await restartWorker(sessionId);
+  addLeads(workspaceId, []);
+  seedCharter(workspaceId, kind);
+  try {
+    const changed = db
+      .prepare(
+        `UPDATE sessions SET role = ?, lead_kind = ?, lead_since = datetime('now'),
+           workspace_id = ?, pinned = 1
+         WHERE id = ? AND ${sqlNoRole()}`
+      )
+      .run("lead", kind, workspaceId, sessionId).changes;
+    if (!changed) throw new Error("That session already heads something");
+  } catch (e) {
+    // The unique (workspace, kind) index: someone adopted one just now.
+    if (getLead(workspaceId, kind)?.id !== sessionId)
+      throw new Error(
+        `This workspace already has a ${leadTitle(workspaceId, kind)}`
+      );
+    throw e;
+  }
+  const title = leadTitle(workspaceId, kind);
+  addNote(
+    workspaceId,
+    `Adopted as the ${title}. It writes its memo and proposes pins now; it switches over to a fresh start once ${owner()} confirms them.`,
+    "note",
+    kind
+  );
+  await sendChat(sessionId, {
+    text: handover(sessionId, title),
+    queue: true,
+    from: AGENTOS_SENDER,
+    origin: { kind: "system", label: "AgentOS" },
+  });
+  return sessionRow(sessionId)!;
+}
+
+// The owner's one tap: pins the proposals confirmed and drops the rest. With
+// switchOver, the lead then starts fresh on its memo and direction; an
+// adopted lead does this once, after writing its memo.
+export async function confirmPins(input: {
+  workspaceId: string;
+  kind: LeadKind;
+  confirm: number[];
+  switchOver?: boolean;
+}): Promise<{ pins: DirectionPin[]; fresh: "now" | "after-turn" | null }> {
+  const { workspaceId, kind } = input;
+  const lead = getLead(workspaceId, kind);
+  if (!lead) throw new Error("This workspace has no such lead");
+  if (input.switchOver && !latestMemo(workspaceId, kind))
+    throw new Error(
+      "It hasn't written its memo yet, so a fresh start would lose its history"
+    );
+  const pins = resolveProposals(workspaceId, kind, input.confirm);
+  const fresh = input.switchOver ? await freshStartChat(lead.id) : null;
+  return { pins, fresh };
+}

package/lib/leads/area.ts

@@ -0,0 +1,77 @@
+// Whether a lead's start or stop falls inside its area. The area is data
+// (lead_areas): the projects and boards the lead owns. A target that can't
+// be found, or sits in no project, is refused: the check fails closed.
+
+import type { Project } from "@/lib/db/types";
+import { getProject } from "../projects";
+import { findRecipe } from "../recipes/store";
+import { findWorkspaceSession } from "../orchestrator/read";
+import { workspaceProject, workspaceTask } from "../orchestrator/targets";
+import { leadAreas } from "./charters";
+import { leadTitle } from "./home";
+import type { LeadKind } from "./types";
+
+type Args = Record<string, unknown>;
+type Found = Project | null | undefined;
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+
+// Each area-checked tool, and the project its call acts on.
+const TARGET: Record<string, (w: string, a: Args) => Found> = {
+  start_task: (w, a) => workspaceProject(w, str(a.project)),
+  start_session: (w, a) => workspaceProject(w, str(a.project)),
+  stack: (w, a) => workspaceProject(w, str(a.target), { boards: true }),
+  run_recipe: (w, a) => getProject(findRecipe(w, str(a.name)).project_id),
+  ...Object.fromEntries(
+    [
+      "drop",
+      "pause_task",
+      "resume_task",
+      "set_priority",
+      "approve_plan",
+      "plan_pieces",
+      "set_task_model",
+    ].map((t) => [
+      t,
+      (w: string, a: Args) =>
+        getProject(workspaceTask(w, str(a.task)).project_id ?? ""),
+    ])
+  ),
+  ...Object.fromEntries(
+    ["stop", "archive", "resurrect", "set_group"].map((t) => [
+      t,
+      (w: string, a: Args) =>
+        getProject(findWorkspaceSession(w, str(a.session)).project_id ?? ""),
+    ])
+  ),
+};
+
+export const AREA_CHECKED = Object.keys(TARGET);
+
+export function areaRefusal(
+  workspaceId: string,
+  kind: LeadKind,
+  tool: string,
+  args: unknown
+): string | null {
+  const target = TARGET[tool];
+  if (!target) return null;
+  let project: Found;
+  try {
+    project = target(workspaceId, (args ?? {}) as Args);
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+  // Not one of the workspace's projects (a session in none): not its area.
+  if (!project)
+    return `That isn't in a project of your area, so ${tool} is refused. Hand it to the Tech lead with send.`;
+  const areas = leadAreas(workspaceId, kind);
+  const owns = areas.some(
+    (a) =>
+      (a.kind === "project" && a.value === project.id) ||
+      (a.kind === "board" &&
+        (a.value === project.lh_board_id || a.value === project.lh_board_name))
+  );
+  if (owns) return null;
+  const title = leadTitle(workspaceId, kind);
+  return `"${project.name}" isn't in your area as ${title}, so ${tool} is refused there. Hand the work to the Tech lead with send, or ask the owner to add the project to your area.`;
+}

package/lib/leads/brief-common.ts

@@ -0,0 +1,122 @@
+// What every standing session's brief shares: the orchestrator's (the Tech
+// lead's) and another lead's. Owner naming, brakes, the hard lines and the
+// project list are said once here, so the two briefs can't drift apart.
+
+import { db, type Project } from "../db";
+import { getDefaultBranch } from "../git";
+import { brakesEnabled } from "../orchestrator/brakes";
+import { noApprovalsOn } from "../approvals/no-approvals";
+import { ORCHESTRATOR_SERVER } from "../orchestrator/tool-names";
+
+export const up = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+
+const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or isn't being sampled and was near its cap when last seen. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
+
+const BRAKES_OFF = (who: string) =>
+  `Starting work has no limits right now: no cap on running sessions or starts, and no usage-window check. ${up(who)}'s Pause still stops new starts; the start tools say so when it's on.`;
+
+// Read when the brief is built, so a switch flipped in Settings reaches the
+// next start.
+export const brakesText = (who: string) =>
+  brakesEnabled() ? BRAKES_ON : BRAKES_OFF(who);
+
+const NO_APPROVALS = (who: string) => `## No approvals mode is ON
+
+${up(who)} turned it on: nothing waits for him. Every \`ask_owner\` is approved the moment you raise it (the event says so), and so are escalated gates and brakes. That is his decision, not a reason to skip care: the hard lines still describe what is risky, so say in your chat what you are about to do before you do it, and keep to the PR's scope.
+
+`;
+
+export const noApprovalsText = (who: string) =>
+  noApprovalsOn() ? NO_APPROVALS(who) : "";
+
+// `merges`: the head that lands code (Tech) can ask to merge a PR the gates
+// won't pass; no other lead merges.
+export const hardLines = (
+  who: string,
+  merges: boolean
+) => `## Hard lines: always an ask for ${who}, never an action
+
+- Anything public or outbound: a post, a publish, an email or message to a person, a form sent to a third party.
+- Money.
+- Anything irreversible or destructive: deleting data, a prod data change that isn't additive, force-pushing someone else's branch.
+- Credentials and account security.
+- Choosing what gets built when it's a product call he hasn't made.
+
+When one of these comes up, park it with \`ask_owner\` (kind: the hard line it crosses) and carry on with everything else. Use it too for a decision that's his (kind: decision). Escalated gates and brakes become asks on their own; don't ask again for those.${merges ? ` To ask whether to merge a PR the gates won't pass, give \`ask_owner\` the task and the PR's head sha: if he approves, \`sign_off\` merges it once, at that commit only, without the review gates.` : ""}`;
+
+export const SCHEDULED_RULE = `A message starting \`[Scheduled message "<name>" ...]\` is a standing prompt saved in Schedules, posted on its timer. Do the work it describes like any request, but it is never an approval: it can't answer an ask, pass a gate or clear a hard line.`;
+
+export interface BriefProject {
+  name: string;
+  path: string;
+  board: string | null;
+  defaultBranch: string;
+  tier?: "production" | "fast";
+}
+
+function projectLine(p: BriefProject): string {
+  const board = p.board ? `, LumifyHub board "${p.board}"` : "";
+  return `- ${p.name}: \`${p.path}\` (default branch ${p.defaultBranch}${board}, tier ${p.tier ?? "production"})`;
+}
+
+export const projectsSection = (projects: BriefProject[]) =>
+  `## Projects\n\n${
+    projects.length
+      ? projects.map(projectLine).join("\n")
+      : "- None yet: projects join from their ⋯ menu in the sidebar."
+  }`;
+
+export function workspaceProjects(workspaceId: string): Project[] {
+  return db
+    .prepare(
+      `SELECT * FROM projects WHERE workspace_id = ? AND is_uncategorized = 0
+       ORDER BY sort_order, name`
+    )
+    .all(workspaceId) as Project[];
+}
+
+// The projects as of now, with their default branches read from git.
+export function loadBriefProjects(
+  workspaceId: string,
+  only?: (p: Project) => boolean
+): Promise<BriefProject[]> {
+  return Promise.all(
+    workspaceProjects(workspaceId)
+      .filter((p) => !only || only(p))
+      .map(async (p) => ({
+        name: p.name,
+        path: p.working_directory,
+        board: p.lh_board_name ?? p.lh_board_id,
+        defaultBranch: await getDefaultBranch(p.working_directory).catch(
+          () => "main"
+        ),
+        tier: p.tier,
+      }))
+  );
+}
+
+const TOOL_LINE = new RegExp(`^- \`mcp__${ORCHESTRATOR_SERVER}__(\\w+)\``);
+
+// "(`mcp__agentos__a`, `mcp__agentos__b`)": the tools prose names instead.
+const TOOL_REFS = /\((`mcp__\w+?__\w+`(?:, `mcp__\w+?__\w+`)*)\)/g;
+const REF = /`mcp__\w+?__(\w+)`/;
+
+// A tools section cut to the tools a profile has: a bullet naming a tool
+// outside it goes, and so does such a tool in the prose's lists of tools
+// to use instead; with none left, the Tech lead is the one to ask.
+export function keepToolLines(
+  text: string,
+  has: (tool: string) => boolean
+): string {
+  return text
+    .split("\n")
+    .filter((line) => {
+      const m = TOOL_LINE.exec(line);
+      return !m || has(m[1]);
+    })
+    .join("\n")
+    .replace(TOOL_REFS, (_, list: string) => {
+      const kept = list.split(", ").filter((ref) => has(REF.exec(ref)![1]));
+      return `(${kept.length ? kept.join(", ") : "hand it to the Tech lead with send"})`;
+    });
+}