@saadnvd1/agent-os 0.3.853 → 0.3.859

package/lib/analyst/createLink.ts

@@ -1,3 +1,4 @@
+import { isStandingRole, RoleLabel } from "../leads/roles";
 import { db, type Session } from "../db";
 import { lastItems } from "../chat/store";
 import { launchSession } from "../sessions/launch";
@@ -18,7 +19,8 @@ const sessionRow = (id: string) =>
 export function coderRefusal(s: Session | undefined): string | null {
   if (!s) return "Session not found";
   if (s.archived_at) return `${s.name} is archived`;
-  if (s.role === "orchestrator") return "An orchestrator can't have an analyst";
+  if (isStandingRole(s.role))
+    return `${RoleLabel(s.role)} can't have an analyst`;
   if (s.view !== "chat")
     return "Only a chat session can have an analyst: a terminal has no turns to review";
   if ((s.host_id || "local") !== "local")

package/lib/away/report.ts

@@ -4,6 +4,7 @@
  * as Away ends and kept with the period, so it reads the same later.
  */
 
+import { sqlNoRole } from "../leads/roles";
 import { db } from "../db";
 import { listWorkspaces } from "../workspaces";
 import { HARD_LINES, openAsks } from "../orchestrator/asks";
@@ -178,7 +179,7 @@ function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
       `SELECT s.id, s.name, p.name AS project, s.pr_number, s.pr_url,
          s.merge_armed_at AS armed_at
        FROM session_rows s JOIN projects p ON p.id = s.project_id
-       WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
+       WHERE p.workspace_id = ? AND ${sqlNoRole("s.role")} AND s.archived_at IS NULL
          AND s.task_status = 'running'
          AND EXISTS (SELECT 1 FROM away_actions a WHERE a.away_id = ?
            AND a.subject = s.id AND a.kind IN (${TOUCHED}))

package/lib/bus/format.ts

@@ -81,6 +81,8 @@ export function matchesRef(
     // orchestrator: "<workspace>/<name>" and "<workspace>/orchestrator".
     workspaceName?: string | null;
     orchestrator?: boolean;
+    // A lead's department: "<workspace>/<kind>".
+    leadKind?: string | null;
   }
 ): boolean {
   const r = ref.trim().toLowerCase();
@@ -92,6 +94,7 @@ export function matchesRef(
     r === name ||
     (!!s.projectName && r === `${s.projectName.toLowerCase()}/${name}`) ||
     (!!ws && r === `${ws}/${name}`) ||
-    (!!ws && !!s.orchestrator && r === `${ws}/orchestrator`)
+    (!!ws && !!s.orchestrator && r === `${ws}/orchestrator`) ||
+    (!!ws && !!s.leadKind && r === `${ws}/${s.leadKind}`)
   );
 }

package/lib/bus/index.ts

@@ -4,6 +4,7 @@
  * the recipient's tmux pane, which works for any agent CLI.
  */
 
+import { isTechRole } from "../leads/roles";
 import { db, type Session } from "../db";
 import { statusDetector } from "../status-detector";
 import { chatState, sendChatConfirmed } from "../chat/runner";
@@ -63,6 +64,8 @@ export interface Peer {
   orchestratorOf: string | null;
   // The asking session's own workspace orchestrator.
   yours?: boolean;
+  // A lead's address, "<workspace>/<kind>", once its workspace has leads.
+  lead?: string;
   // Names of the sessions it waits on, and of those waiting on it.
   waitingOn: string[];
   waitedBy: string[];
@@ -93,7 +96,7 @@ async function peerState(
 }
 
 const orchestratorOf = (s: Session) =>
-  s.role === "orchestrator" && s.workspace_id
+  isTechRole(s.role) && s.workspace_id
     ? (getWorkspace(s.workspace_id)?.name ?? "a workspace")
     : null;
 
@@ -121,6 +124,10 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         running: info.running,
         doing: info.subtitle,
         orchestratorOf: orchestratorOf(s),
+        ...(named[i].leadKind &&
+          named[i].workspaceName && {
+            lead: `${named[i].workspaceName}/${named[i].leadKind}`,
+          }),
         waitingOn: badges.get(s.id)?.on.map((w) => w.name) ?? [],
         waitedBy: badges.get(s.id)?.by.map((w) => w.name) ?? [],
         ...(s.agent_role && { agentRole: s.agent_role }),
@@ -130,7 +137,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
             group: groups.get(s.session_group_id),
           }),
         ...(callerWorkspace &&
-          s.role === "orchestrator" &&
+          isTechRole(s.role) &&
           s.workspace_id === callerWorkspace && { yours: true }),
       };
     })

package/lib/bus/read-scope.ts

@@ -1,3 +1,4 @@
+import { isStandingRole, roleLabel } from "../leads/roles";
 import { db } from "../db";
 import type { Session } from "../db";
 import { getProject } from "../projects";
@@ -58,7 +59,7 @@ function candidates(rows: ReadableSession[]): Candidate[] {
 }
 
 function inScope(s: ReadableSession, scope: ReaderScope): boolean {
-  if (s.role) return false;
+  if (isStandingRole(s.role)) return false;
   if (scope.workspaceId) {
     const p = s.project_id ? getProject(s.project_id) : null;
     // A session in no project is in the workspace it was started in.
@@ -113,8 +114,8 @@ export function resolveReadable(callerId: string, ref: string): Readable {
     return {
       ok: false,
       external: false,
-      error: s.role
-        ? `${s.name} is an orchestrator: it isn't readable. Message it with aos send`
+      error: isStandingRole(s.role)
+        ? `${s.name} is ${roleLabel(s.role)}: it isn't readable. Message it with aos send`
         : `"${ref}" isn't in your ${scope.label}; aos read reaches only sessions there`,
     };
   }

package/lib/bus/resolve.ts

@@ -13,6 +13,8 @@ export interface Candidate {
   previousNames: string[];
   workspaceName?: string | null;
   orchestrator?: boolean;
+  // The department it heads, when its workspace has leads: "<workspace>/<kind>".
+  leadKind?: string | null;
 }
 
 export type Resolution =
@@ -23,7 +25,7 @@ export const MIN_ID_PREFIX = 4;
 
 const label = (c: Candidate) =>
   `${
-    c.orchestrator && c.workspaceName
+    (c.orchestrator || c.leadKind) && c.workspaceName
       ? `${c.workspaceName}/`
       : c.projectName
         ? `${c.projectName}/`
@@ -46,6 +48,7 @@ const matchesOld = (r: string, c: Candidate) =>
       tmuxName: "",
       name: old,
       orchestrator: false,
+      leadKind: null,
     })
   );
 

package/lib/bus/role-alias.ts

@@ -5,6 +5,7 @@
  * refuses and lists them, like any other name.
  */
 
+import { isTechRole } from "../leads/roles";
 import type { Session } from "../db";
 import { sessionWorkspace } from "../models/resolve";
 
@@ -60,7 +61,7 @@ export function resolveRoleAlias<T extends RoleSession>(
   const workspace = caller ? sessionWorkspace(caller) : null;
   if (role === "supervisor" && workspace) {
     const orchestrator = others.find(
-      (s) => s.role === "orchestrator" && s.workspace_id === workspace
+      (s) => isTechRole(s.role) && s.workspace_id === workspace
     );
     if (orchestrator) return { ok: true, session: orchestrator };
   }

package/lib/bus/targets.ts

@@ -2,6 +2,8 @@
  * Which live session a name someone typed reaches, across workspaces.
  */
 
+import { isTechRole, leadKindOf } from "../leads/roles";
+import { hasLeads } from "../leads/settings";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
@@ -37,7 +39,10 @@ export function candidates(sessions: Session[]): Candidate[] {
     tmuxName: s.tmux_name,
     previousNames: old.get(s.id) ?? [],
     workspaceName: workspaceName(s),
-    orchestrator: s.role === "orchestrator",
+    orchestrator: isTechRole(s.role),
+    // The orchestrator answers to "tech" only once its workspace has leads.
+    leadKind:
+      isTechRole(s.role) && !hasLeads(s.workspace_id) ? null : leadKindOf(s),
   }));
 }
 
@@ -77,7 +82,7 @@ function ownOrchestrator(
   const workspace = caller ? sessionWorkspace(caller) : null;
   if (!workspace) return undefined;
   return sessions.find(
-    (s) => s.role === "orchestrator" && s.workspace_id === workspace
+    (s) => isTechRole(s.role) && s.workspace_id === workspace
   );
 }
 
@@ -95,7 +100,7 @@ export function tryResolveTarget(
   const r = resolveRef(ref, candidates(sessions));
   if (!r.ok) {
     const orchestrators = /^(my )?orchestrator$/i.test(ref.trim())
-      ? sessions.filter((s) => s.role === "orchestrator")
+      ? sessions.filter((s) => isTechRole(s.role))
       : [];
     if (orchestrators.length)
       return {

package/lib/bus/waits/tick.ts

@@ -5,6 +5,7 @@
  * reads status through statusOf, the same idle test the orchestrator uses.
  */
 
+import { isStandingRole } from "../../leads/roles";
 import type { Session } from "../../db";
 import { db } from "../../db";
 import { statusDetector } from "../../status-detector";
@@ -128,7 +129,7 @@ async function settle(w: WaitRow, waiter: Session, now: number): Promise<void> {
       timeoutLine(target, w.kind, w.deadline - w.created_at, w.request, is)
     );
     const workspace = sessionWorkspace(waiter);
-    if (workspace && waiter.role !== "orchestrator")
+    if (workspace && !isStandingRole(waiter.role))
       queueEventOnce(
         workspace,
         `wait-timeout:${w.id}`,

package/lib/chat/compact-context.ts

@@ -5,6 +5,7 @@
  * deploy restarted the worker too.
  */
 
+import { isStandingRole } from "../leads/roles";
 import os from "node:os";
 import { statusPorcelain } from "../git-exec";
 import { db, type Session } from "../db";
@@ -33,7 +34,7 @@ export async function compactContext(sessionId: string): Promise<string> {
     .get(sessionId) as
     Pick<Session, "working_directory" | "task_prompt" | "role"> | undefined;
   // An orchestrator starts fresh instead of compacting.
-  if (!session || session.role === "orchestrator") return "";
+  if (!session || isStandingRole(session.role)) return "";
   const tools = lastItems(sessionId, 400, "tool").filter(
     (i) => i.kind === "tool"
   );

package/lib/chat/mention-roots.ts

@@ -1,3 +1,4 @@
+import { isStandingRole } from "../leads/roles";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -35,7 +36,7 @@ export function mentionRoots(sessionId: string): MentionRoot[] | null {
         working_directory: string;
       }
     | undefined;
-  if (session?.role !== "orchestrator") return null;
+  if (!isStandingRole(session?.role)) return null;
 
   // Never the home folder or the whole disk: a project pointed there would
   // list everything under it, dotfiles and keys included.

package/lib/chat/runner.ts

@@ -5,6 +5,7 @@
  * events to whoever is watching. Restarting the server leaves turns running.
  */
 
+import { isStandingRole } from "../leads/roles";
 import { pushPlanReady } from "../notify/push/events";
 import {
   handoffAfterPlan,
@@ -638,7 +639,7 @@ async function resumeCutOff(sessionId: string): Promise<void> {
   const task =
     row.workspace_id &&
     row.task_status === "running" &&
-    row.role !== "orchestrator"
+    !isStandingRole(row.role)
       ? row.workspace_id
       : null;
   try {
@@ -923,7 +924,7 @@ export async function freshStartChat(
     id: `note-refresh-${Date.now()}`,
     kind: "note",
     tone: "note",
-    text: `Fresh start: the agent starts a new conversation with its brief${session.role === "orchestrator" ? " and the current state from AgentOS" : ""} at its next message.`,
+    text: `Fresh start: the agent starts a new conversation with its brief${isStandingRole(session.role) ? " and the current state from AgentOS" : ""} at its next message.`,
     createdAt: Date.now(),
   };
   saveItem(sessionId, item);

package/lib/chat/settings.ts

@@ -3,6 +3,7 @@
  * per-session settings that go with them: the model and the access level.
  */
 
+import { isStandingRole } from "../leads/roles";
 import { effectiveChatAccess, noApprovalsOn } from "../approvals/no-approvals";
 import os from "os";
 import { agentLabel } from "../agent-options";
@@ -330,7 +331,7 @@ export async function setChatAccess(
 ): Promise<void> {
   if (!CHAT_ACCESS.includes(access)) return;
   // An orchestrator's access is fixed by its role.
-  if (getSession(sessionId).role === "orchestrator") return;
+  if (isStandingRole(getSession(sessionId).role)) return;
   db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(
     access,
     sessionId
@@ -341,7 +342,7 @@ export async function setChatAccess(
 
 // An orchestrator's permission mode is fixed by its role.
 const canPlan = (s: Session) =>
-  s.role !== "orchestrator" && chatDriverFor(s.agent_type)?.plan !== false;
+  !isStandingRole(s.role) && chatDriverFor(s.agent_type)?.plan !== false;
 
 // Plan mode: the agent reads and plans, and changes nothing until the plan
 // is carried out. Now if a conversation is live, and for every next start.

package/lib/chat/worker/extras.ts

@@ -1,3 +1,4 @@
+import { isLeadRole } from "../../leads/roles";
 import type { Session } from "../../db";
 import type { ChatStartOptions } from "../driver";
 import { refreshSettings } from "../refresh";
@@ -40,7 +41,9 @@ export async function roleExtras(session: Session): Promise<RoleExtras> {
 }
 
 async function ownExtras(session: Session): Promise<RoleExtras> {
-  if (session.role === "orchestrator")
+  // The orchestrator and the other leads run on the orchestrator's worker,
+  // each with its own profile.
+  if (isLeadRole(session.role))
     return (await import("../../orchestrator/worker")).orchestratorExtras(
       session
     );

package/lib/chat/worker/host.ts

@@ -4,6 +4,7 @@
  * events to whoever is connected.
  */
 
+import { isStandingRole } from "../../leads/roles";
 import os from "os";
 import { db, type Session } from "../../db";
 import { agentEnv } from "../../agents/launch";
@@ -216,7 +217,7 @@ export class ChatHost {
     this.atRest = driver.atRest !== false;
     const cwd = session.working_directory.replace(/^~/, os.homedir());
     const env = { ...agentEnv(session.id), ...extras.env };
-    const orchestrator = session.role === "orchestrator";
+    const orchestrator = isStandingRole(session.role);
     // Every chat can show visuals, asked for like any tool under its access
     // setting (they read files and reach the web). An orchestrator reads
     // other sessions' text, so it gets a shorter brief that says what stays
@@ -289,7 +290,7 @@ export class ChatHost {
     if (session.chat_refreshed)
       this.refreshedNote = refreshedNote(
         extras.refresh?.role ??
-          (session.role === "orchestrator" ? "orchestrator" : "task"),
+          (isStandingRole(session.role) ? "orchestrator" : "task"),
         session.chat_refreshed
       );
     // Told only an orchestrator whose tools changed since its last worker:
@@ -964,7 +965,7 @@ export class ChatHost {
     const stale = this.staleNow(cmd.compact);
     // An orchestrator starts over at its own threshold (lib/chat/refresh);
     // only one gone stale does it early.
-    if (!stale || (this.session.role === "orchestrator" && !stale.stale))
+    if (!stale || (isStandingRole(this.session.role) && !stale.stale))
       return false;
     try {
       enqueue(this.session.id, cmd);
@@ -978,7 +979,7 @@ export class ChatHost {
     // from tasks and CI without its untrusted fence. It starts a fresh
     // conversation from its brief and the database instead, as at its
     // threshold, and the next worker sends the message.
-    if (this.session.role === "orchestrator") {
+    if (isStandingRole(this.session.role)) {
       this.staleRefresh = stale;
       this.refreshAt = stale.tokens;
       this.retiring = true;
@@ -1085,7 +1086,7 @@ export class ChatHost {
   // line saying where it started over.
   private endConversation(): void {
     releaseConversation(this.session.id, this.refreshAt);
-    const brief = `its brief${this.session.role === "orchestrator" ? " and the current state from AgentOS" : ""}`;
+    const brief = `its brief${isStandingRole(this.session.role) ? " and the current state from AgentOS" : ""}`;
     const stale = this.staleRefresh;
     const requested = this.refreshAt === REQUESTED_FRESH;
     this.record({

package/lib/db/migrations/20261102T1944_leads.ts

@@ -0,0 +1,142 @@
+import type { Migration } from "../migration-types";
+import { createSessionRowsView } from "../session-parts/view";
+
+const columnsOf = (db: Parameters<Migration["up"]>[0], table: string) =>
+  (db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]).map(
+    (c) => c.name
+  );
+
+export default {
+  key: "20261102T1944_leads",
+  up: (db) => {
+    // Leads (lib/leads): a lead is a standing chat like the orchestrator,
+    // with role 'lead' and a lead_kind; the orchestrator is the 'tech' lead
+    // once its workspace adds leads, and a workspace has one 'chief'.
+    // lead_since is when it became one, so its usage counts from then.
+    // Additive: a workspace without leads has none of these rows.
+    const sessions = columnsOf(db, "sessions");
+    if (!sessions.includes("lead_kind"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN lead_kind TEXT`);
+    if (!sessions.includes("lead_since"))
+      db.exec(`ALTER TABLE sessions ADD COLUMN lead_since TEXT`);
+    createSessionRowsView(db);
+    db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_lead
+         ON sessions(workspace_id, lead_kind) WHERE role = 'lead'`
+    );
+    db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_chief
+         ON sessions(workspace_id) WHERE role = 'chief'`
+    );
+
+    // A row means the workspace added leads. The chief's autonomy starts at
+    // acting only when asked; a later setting lifts it without code.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS workspace_leads (
+        workspace_id TEXT PRIMARY KEY,
+        enabled_at TEXT NOT NULL DEFAULT (datetime('now')),
+        chief_autonomy TEXT NOT NULL DEFAULT 'on_request'
+          CHECK (chief_autonomy IN ('on_request', 'acts'))
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_charters (
+        workspace_id TEXT NOT NULL,
+        lead_kind TEXT NOT NULL,
+        title TEXT NOT NULL,
+        area_text TEXT NOT NULL DEFAULT '',
+        charter_md TEXT NOT NULL DEFAULT '',
+        goal TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (workspace_id, lead_kind)
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_areas (
+        workspace_id TEXT NOT NULL,
+        lead_kind TEXT NOT NULL,
+        kind TEXT NOT NULL CHECK (kind IN ('project', 'path', 'board')),
+        value TEXT NOT NULL,
+        PRIMARY KEY (workspace_id, lead_kind, kind, value)
+      )
+    `);
+    // Pinned direction quotes a chat item the person wrote; a newer pin
+    // supersedes an older one and nothing is deleted.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_direction (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        lead_kind TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        chat_item_id TEXT NOT NULL,
+        quote TEXT NOT NULL,
+        set_at TEXT NOT NULL DEFAULT (datetime('now')),
+        superseded_by INTEGER
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_lead_direction
+         ON lead_direction(workspace_id, lead_kind, id)`
+    );
+    // Proposed pins (an adopted lead's, or a lead's suggestion) wait here
+    // until the person confirms or drops them.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_pin_proposals (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        lead_kind TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        chat_item_id TEXT NOT NULL,
+        quote TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'open'
+          CHECK (status IN ('open', 'pinned', 'dropped')),
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        resolved_at TEXT
+      )
+    `);
+    db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_lead_pin_proposals_open
+         ON lead_pin_proposals(session_id, chat_item_id) WHERE status = 'open'`
+    );
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_memos (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        lead_kind TEXT NOT NULL,
+        text TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_lead_memos
+         ON lead_memos(workspace_id, lead_kind, id)`
+    );
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS lead_messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        from_kind TEXT NOT NULL,
+        to_kind TEXT NOT NULL,
+        thread TEXT NOT NULL,
+        text TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        read_at TEXT
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_lead_messages_to
+         ON lead_messages(workspace_id, to_kind, id)`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_lead_messages_thread
+         ON lead_messages(workspace_id, thread, id)`
+    );
+
+    // The decision log and asks per lead; every existing row is Tech's.
+    for (const table of ["orchestrator_notes", "orchestrator_asks"])
+      if (!columnsOf(db, table).includes("lead_kind"))
+        db.exec(
+          `ALTER TABLE ${table} ADD COLUMN lead_kind TEXT NOT NULL DEFAULT 'tech'`
+        );
+  },
+} satisfies Migration;

package/lib/db/migrations/20261102T2300_needs_you_chat_per_session.ts

@@ -0,0 +1,24 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261102T2300_needs_you_chat_per_session",
+  up: (db) => {
+    // The Needs-you "waiting in chat" item was keyed per workspace
+    // (approval:<workspace id>), so one lead's waiting chat would hide
+    // another's. It is keyed per session now; a hidden one stays hidden on
+    // the workspace's orchestrator, the only chat that showed it. Safe to
+    // repeat: a renamed key no longer matches.
+    db.exec(`
+      UPDATE OR IGNORE needs_you_dismissed
+         SET key = 'approval:' || (
+           SELECT s.id FROM sessions s
+            WHERE s.role = 'orchestrator'
+              AND s.workspace_id = needs_you_dismissed.workspace_id)
+       WHERE key = 'approval:' || workspace_id
+         AND EXISTS (
+           SELECT 1 FROM sessions s
+            WHERE s.role = 'orchestrator'
+              AND s.workspace_id = needs_you_dismissed.workspace_id)
+    `);
+  },
+} satisfies Migration;

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

@@ -186,4 +186,6 @@ export const SESSION_ROW_COLUMNS: readonly string[] = [
   "session_group_id",
   "agent_role",
   "crew_id",
+  "lead_kind",
+  "lead_since",
 ];

package/lib/db/types.ts

@@ -1,6 +1,9 @@
 import type { AgentType } from "../providers";
 import type { ChatAccess } from "../chat/events";
 
+// The standing chats a workspace can have (lib/leads/roles.ts).
+export type SessionRole = "orchestrator" | "lead" | "chief";
+
 export interface Session {
   id: string;
   name: string;
@@ -118,8 +121,13 @@ export interface Session {
   // 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;
+  // A workspace's standing chat (and that workspace), or null: its
+  // orchestrator, and with Leads its other leads and chief (lib/leads).
+  role: SessionRole | null;
+  // A lead's department ('tech' for the orchestrator once leads are added)
+  // and when it became one.
+  lead_kind?: string | null;
+  lead_since?: string | null;
   // An orchestrator's tool-call secret.
   orch_token?: string | null;
   workspace_id: string | null;

package/lib/done/archive.ts

@@ -1,6 +1,7 @@
 // Archived sessions: out of the sidebar, the needs-you count and the
 // orchestrator's view, but kept with their history and chat items.
 
+import { isStandingRole, roleNoun } from "../leads/roles";
 import fs from "fs";
 import { db, queries, type Session } from "../db";
 import { statusOf } from "../orchestrator/facts";
@@ -102,9 +103,9 @@ export async function archiveChecked(
   const s = queries.getSession(db).get(id) as Session | undefined;
   if (!s) throw new Error("Session not found");
   if (s.archived_at) throw new Error(`${s.name} is already archived`);
-  if (s.role === "orchestrator")
+  if (isStandingRole(s.role))
     throw new Error(
-      `${s.name} is a workspace's orchestrator; it can't be archived`
+      `${s.name} is a workspace's ${roleNoun(s.role)}; it can't be archived`
     );
   if (peerSessionLink(s))
     throw new Error(`${s.name} runs on another machine: archive it there`);

package/lib/done/auto-archive.ts

@@ -3,6 +3,7 @@
 // session, an orchestrator, one that needs input or is working, or one with
 // an open PR. Mirrors the sidebar's Done placement (lib/sidebar/shelves).
 
+import { sqlNoRole } from "../leads/roles";
 import { db, type Session } from "../db";
 import { fromSqliteTime } from "../session-meta";
 import { statusOf } from "../orchestrator/facts";
@@ -34,7 +35,7 @@ export async function archiveStaleDone(now = Date.now()): Promise<string[]> {
   const rows = db
     .prepare(
       `SELECT * FROM session_rows
-       WHERE archived_at IS NULL AND pinned = 0 AND role IS NULL
+       WHERE archived_at IS NULL AND pinned = 0 AND ${sqlNoRole()}
          AND peer_mirror = 0 AND quick_of IS NULL
          AND (pr_status IS NULL OR pr_status != 'open')`
     )

package/lib/done/bulk.ts

@@ -5,6 +5,7 @@
  * The preview says what will happen to each before anything does.
  */
 
+import { sqlNoRole, isStandingRole, roleLabel } from "../leads/roles";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { workspaceProjects } from "../orchestrator/brief";
@@ -52,7 +53,7 @@ function scopeSessions(scope: DoneScope): Session[] {
     .prepare(
       `SELECT * FROM session_rows
        WHERE project_id IN (${projectIds.map(() => "?").join(", ")})
-         AND role IS NULL AND archived_at IS NULL
+         AND ${sqlNoRole()} AND archived_at IS NULL
          -- A linked machine's own sessions are cleaned up there.
          AND peer_mirror = 0
          -- A task another machine's orchestrator moved here is its to finish.
@@ -80,9 +81,9 @@ export async function idleSessions(
 export function scopeOf(session: Session): DoneScope {
   // An orchestrator acts through its tools, which Pause holds and which are
   // logged; aos would reach the same sessions past both.
-  if (session.role === "orchestrator")
+  if (isStandingRole(session.role))
     throw new Error(
-      `${session.name} is an orchestrator: it moves, finishes and stops sessions with its move, done and stop tools, not aos`
+      `${session.name} is ${roleLabel(session.role)}: it moves, finishes and stops sessions with its move, done and stop tools, not aos`
     );
   const project = session.project_id ? getProject(session.project_id) : null;
   if (!project || project.is_uncategorized)