@saadnvd1/agent-os 0.3.851 → 0.3.859

package/lib/leads/tools.ts

@@ -0,0 +1,159 @@
+// The tool calls of a workspace's standing sessions, as the server answers
+// them: the caller's profile decides which tools it has, a lead's starts
+// and stops stay inside its area, and what it does is recorded as its own.
+
+import { z } from "zod";
+import type { Session } from "@/lib/db/types";
+import { isToolName, runTool } from "../orchestrator/serve";
+import { owner } from "../owner";
+import { asActor } from "./actor";
+import { areaRefusal } from "./area";
+import { currentDirection, openProposals, proposePin } from "./direction";
+import { leadTitle, listLeads } from "./home";
+import { latestMemo, writeMemo } from "./memos";
+import {
+  isLeadToolName,
+  profileFor,
+  profileHas,
+  type LeadToolName,
+  type Profile,
+} from "./profiles";
+import { isLeadKind, leadKindOf, roleNoun } from "./roles";
+import { hasLeads } from "./settings";
+import type { LeadKind } from "./types";
+
+export const LEAD_TOOL_SHAPES = {
+  update_memo: {
+    text: z
+      .string()
+      .trim()
+      .min(1)
+      .max(6000)
+      .describe(
+        "The whole memo, rewritten: what you're working on, what's decided, what's next"
+      ),
+  },
+  propose_pin: {
+    item: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .describe("The chat item id of the owner's message to pin"),
+  },
+  direction: {
+    lead: z
+      .string()
+      .trim()
+      .max(32)
+      .optional()
+      .describe(
+        "Another lead's kind (marketing, product, tech); yours if left out"
+      ),
+  },
+} satisfies Record<LeadToolName, z.ZodRawShape>;
+
+export const LEAD_TOOL_DESCRIPTIONS: Record<LeadToolName, string> = {
+  update_memo:
+    "Rewrite your memo: the short note (about 1.5k tokens) you carry across a fresh start, with your pinned direction. Every version is kept.",
+  propose_pin:
+    "Propose one of the owner's own messages in your chat as pinned direction. The quote is copied by the server, and it is direction only once he confirms it with a tap.",
+  direction:
+    "The pinned direction in force for you or another lead of this workspace (newest first), with your open proposals and memo.",
+};
+
+function parseLeadArgs<T extends LeadToolName>(tool: T, args: unknown) {
+  const parsed = z
+    .object(LEAD_TOOL_SHAPES[tool])
+    .strict()
+    .safeParse(args ?? {});
+  if (!parsed.success)
+    throw new Error(
+      `Bad arguments for ${tool}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "args"} ${i.message}`).join("; ")}`
+    );
+  return parsed.data as unknown as z.infer<
+    z.ZodObject<(typeof LEAD_TOOL_SHAPES)[T]>
+  >;
+}
+
+function directionText(w: string, kind: LeadKind, me: LeadKind): string {
+  const pins = currentDirection(w, kind);
+  const title = leadTitle(w, kind);
+  const lines = [
+    pins.length
+      ? `Pinned direction for the ${title}, from ${owner()}, newest first:\n${pins.map((p) => `- [pin ${p.id}, ${p.setAt.slice(0, 10)}] "${p.quote}"`).join("\n")}`
+      : `The ${title} has no pinned direction.`,
+  ];
+  if (kind === me) {
+    const open = openProposals(w, kind);
+    if (open.length)
+      lines.push(
+        `Proposed, waiting for ${owner()}'s tap:\n${open.map((p) => `- [proposal ${p.id}] "${p.quote}"`).join("\n")}`
+      );
+    const memo = latestMemo(w, kind);
+    lines.push(memo ? `Your memo:\n${memo.text}` : "You have no memo yet.");
+  }
+  return lines.join("\n\n");
+}
+
+function runLeadTool(
+  w: string,
+  caller: Session,
+  kind: LeadKind,
+  tool: LeadToolName,
+  raw: unknown
+): string {
+  switch (tool) {
+    case "update_memo": {
+      const memo = writeMemo(w, kind, parseLeadArgs(tool, raw).text);
+      return `Memo saved (${memo.text.length} characters). A fresh start reads it with your pinned direction.`;
+    }
+    case "propose_pin": {
+      const out = proposePin({
+        workspaceId: w,
+        leadKind: kind,
+        sessionId: caller.id,
+        chatItemId: parseLeadArgs(tool, raw).item,
+      });
+      if ("error" in out) throw new Error(out.error);
+      return `Proposed as pin ${out.id}: "${out.quote}". It's direction once ${owner()} confirms it.`;
+    }
+    case "direction": {
+      const lead = parseLeadArgs(tool, raw).lead ?? kind;
+      if (!isLeadKind(lead)) throw new Error(`No lead "${lead}"`);
+      if (!listLeads(w).some((s) => leadKindOf(s) === lead))
+        throw new Error(`This workspace has no ${lead} lead`);
+      return directionText(w, lead, kind);
+    }
+  }
+}
+
+export class NotYours extends Error {}
+export class UnknownTool extends Error {}
+
+// One tool call from a standing session. Unknown names stay "unknown", as
+// they always were; a known tool outside the caller's profile is refused.
+export async function runStandingTool(
+  w: string,
+  caller: Session,
+  tool: string,
+  args: unknown
+): Promise<string> {
+  const profile: Profile | null = profileFor(caller, hasLeads(w));
+  if (!profile)
+    throw new NotYours(`The ${roleNoun(caller.role)} has no tools here yet`);
+  if (!isToolName(tool) && !isLeadToolName(tool))
+    throw new UnknownTool("Unknown tool");
+  if (!profileHas(profile, tool))
+    throw new NotYours(
+      `${tool} isn't one of your tools as ${leadTitle(w, profile.kind)}: it's the Tech lead's. Hand it over with send.`
+    );
+  if (isLeadToolName(tool))
+    return runLeadTool(w, caller, profile.kind, tool, args);
+  if (!isToolName(tool)) throw new UnknownTool("Unknown tool");
+  const refusal = profile.inArea
+    ? areaRefusal(w, profile.kind, tool, args)
+    : null;
+  if (refusal) throw new Error(refusal);
+  return asActor(caller, () => runTool(w, tool, args ?? {}));
+}

package/lib/leads/types.ts

@@ -0,0 +1,88 @@
+// A lead's department: the shipped kinds, or a custom slug.
+export type LeadKind = string;
+
+export const TECH: LeadKind = "tech";
+export const BUILT_IN_KINDS = ["tech", "marketing", "product"] as const;
+
+// How far a workspace's chief of staff may go without being asked. V1 acts
+// only on request; its sweep reads and raises asks.
+export type ChiefAutonomy = "on_request" | "acts";
+
+export interface WorkspaceLeads {
+  workspaceId: string;
+  enabledAt: string;
+  chiefAutonomy: ChiefAutonomy;
+}
+
+export interface LeadCharter {
+  workspaceId: string;
+  leadKind: LeadKind;
+  title: string;
+  areaText: string;
+  charterMd: string;
+  goal: string;
+  updatedAt: string;
+}
+
+export type LeadAreaKind = "project" | "path" | "board";
+
+export interface LeadArea {
+  kind: LeadAreaKind;
+  value: string;
+}
+
+export interface DirectionPin {
+  id: number;
+  workspaceId: string;
+  leadKind: LeadKind;
+  sessionId: string;
+  chatItemId: string;
+  quote: string;
+  setAt: string;
+  supersededBy: number | null;
+}
+
+export type ProposalStatus = "open" | "pinned" | "dropped";
+
+export interface PinProposal {
+  id: number;
+  workspaceId: string;
+  leadKind: LeadKind;
+  sessionId: string;
+  chatItemId: string;
+  quote: string;
+  status: ProposalStatus;
+  createdAt: string;
+  resolvedAt: string | null;
+}
+
+export interface LeadMemo {
+  id: number;
+  workspaceId: string;
+  leadKind: LeadKind;
+  text: string;
+  createdAt: string;
+}
+
+export interface LeadMessage {
+  id: number;
+  workspaceId: string;
+  fromKind: LeadKind;
+  toKind: LeadKind;
+  thread: string;
+  text: string;
+  createdAt: string;
+  readAt: string | null;
+}
+
+export interface LeadUsage {
+  sessionId: string;
+  leadKind: LeadKind;
+  role: string;
+  // Model calls (one per assistant response).
+  calls: number;
+  inputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  outputTokens: number;
+}

package/lib/leads/usage.ts

@@ -0,0 +1,46 @@
+import { db } from "@/lib/db";
+import { leadKindOf, sqlStanding } from "./roles";
+import type { LeadUsage } from "./types";
+
+// What each standing chat in a workspace spent since `sinceMs`, from the
+// calls every chat worker already records (lib/usage/calls). An adopted
+// lead counts only from when it became one, so week one is measured, not
+// guessed.
+export function leadUsage(workspaceId: string, sinceMs: number): LeadUsage[] {
+  const rows = db
+    .prepare(
+      `SELECT s.id AS session_id, s.role, s.lead_kind,
+              COUNT(c.id) AS calls,
+              COALESCE(SUM(c.input_tokens), 0) AS input,
+              COALESCE(SUM(c.cache_read_tokens), 0) AS cache_read,
+              COALESCE(SUM(c.cache_write_5m_tokens + c.cache_write_1h_tokens), 0) AS cache_write,
+              COALESCE(SUM(c.output_tokens), 0) AS output
+       FROM sessions s
+       LEFT JOIN usage_calls c ON c.session_id = s.id
+         AND c.at >= MAX(?, COALESCE(
+           CAST(strftime('%s', s.lead_since) AS INTEGER) * 1000, 0))
+       WHERE s.workspace_id = ? AND ${sqlStanding("s.role")}
+       GROUP BY s.id
+       ORDER BY s.role, s.lead_kind`
+    )
+    .all(sinceMs, workspaceId) as {
+    session_id: string;
+    role: string;
+    lead_kind: string | null;
+    calls: number;
+    input: number;
+    cache_read: number;
+    cache_write: number;
+    output: number;
+  }[];
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    leadKind: leadKindOf(r) ?? r.role,
+    role: r.role,
+    calls: r.calls,
+    inputTokens: r.input,
+    cacheReadTokens: r.cache_read,
+    cacheWriteTokens: r.cache_write,
+    outputTokens: r.output,
+  }));
+}

package/lib/learning-cards/input.ts

@@ -2,6 +2,7 @@
 // brief, the final report and the tool and user steps, each cut down.
 // Never the transcript.
 
+import { isStandingRole, roleNoun } from "../leads/roles";
 import { db, queries, type Session } from "../db";
 import { itemsOfKind, itemsOfKinds } from "../chat/store";
 import { isGitRepo } from "../git";
@@ -61,7 +62,7 @@ export async function readSession(id: string): Promise<SessionInput | null> {
     BRIEF
   );
   let skip: string | null = null;
-  if (s.role === "orchestrator") skip = "orchestrator";
+  if (isStandingRole(s.role)) skip = roleNoun(s.role);
   else if (s.quick_of) skip = "quick change";
   else if (!steps.length && !final) skip = "no conversation";
 

package/lib/live/drive.ts

@@ -6,6 +6,7 @@
  * worker's guest gate (lib/chat/worker/guest-gate).
  */
 
+import { isStandingRole, roleLabel } from "../leads/roles";
 import os from "os";
 import path from "path";
 import { randomBytes } from "crypto";
@@ -69,7 +70,7 @@ const home = (p: string) => path.resolve(p.replace(/^~(?=$|\/)/, os.homedir()));
 export function driveRefusal(s: Session): string | null {
   if (s.view !== "chat" || s.agent_type !== "claude")
     return "Claude chat sessions only";
-  if (s.role) return "Not for an orchestrator";
+  if (isStandingRole(s.role)) return `Not for ${roleLabel(s.role)}`;
   if (!s.task_prompt) return "Task sessions only";
   if (!s.worktree_path) return "Task sessions with their own worktree only";
   const project = s.project_id ? getProject(s.project_id) : undefined;

package/lib/models/launch.ts

@@ -3,6 +3,7 @@
  * name for its CLI, and the provider's endpoint and key in its environment.
  */
 
+import { isStandingRole } from "../leads/roles";
 import type { Session } from "../db";
 import {
   defaultRoute,
@@ -72,7 +73,7 @@ export async function routeOrchestrator(
   session: Session,
   exec?: SecretCommand
 ): Promise<Session> {
-  if (session.role !== "orchestrator") return session;
+  if (!isStandingRole(session.role)) return session;
   let routed;
   try {
     routed = resolveRole("orchestrator", { workspaceId: session.workspace_id });

package/lib/models/session-role.ts

@@ -1,3 +1,4 @@
+import { isStandingRole } from "../leads/roles";
 import { orchestratorOf } from "../tasks/starter";
 import type { ModelRole } from "./roles";
 
@@ -9,7 +10,7 @@ export function sessionRole(session: {
   plan_phase?: string | null;
   started_by?: string | null;
 }): ModelRole {
-  if (session.role === "orchestrator") return "orchestrator";
+  if (isStandingRole(session.role)) return "orchestrator";
   // Work an orchestrator started is implementation, not a person's session.
   if (!session.task_status)
     return orchestratorOf(session.started_by) ? "implement" : "interactive";

package/lib/needs-you.ts

@@ -1,7 +1,8 @@
 import { getDb, type Session } from "./db";
 import type { ChatItem, ChatState } from "./chat/events";
 import { originOf } from "./chat/origin";
-import { openAskCount } from "./orchestrator/asks";
+import { standingAskCount } from "./orchestrator/asks";
+import { isStandingRole } from "./leads/roles";
 import { notifyStatusChanged } from "./status/hub";
 import type { SessionNeed } from "./sidebar/shelves";
 import type { ProgramSummary } from "./program-status/records";
@@ -36,7 +37,12 @@ export function needsYou(
     Partial<
       Pick<
         Session,
-        "role" | "workspace_id" | "task_status" | "settled_at" | "archived_at"
+        | "role"
+        | "lead_kind"
+        | "workspace_id"
+        | "task_status"
+        | "settled_at"
+        | "archived_at"
       >
     >,
   chatState: ChatState | null
@@ -46,8 +52,8 @@ export function needsYou(
     // A finished task's agent is stopped: its last turn is history, not news.
     if (session.task_status && session.task_status !== "running") return false;
     if (chatState === "waiting") return true;
-    if (session.role === "orchestrator")
-      return openAskCount(session.workspace_id) > 0;
+    if (isStandingRole(session.role))
+      return standingAskCount({ ...session, role: session.role }) > 0;
     if (session.archived_at) return false;
     const latest = latestChatItem(session.id);
     // Put on the Done shelf after its last turn: that turn is history, not
@@ -89,7 +95,7 @@ export function chatNeed(
   state: ChatState | null,
   asks = 0
 ): SessionNeed | null {
-  if (session.role === "orchestrator")
+  if (isStandingRole(session.role))
     return asks > 0 || state === "waiting" ? "answer" : null;
   if (state === "waiting")
     return pendingApproval(session.id)?.questions?.length
@@ -135,7 +141,7 @@ export function isUnread(
   const seen = sqliteMs(session.last_seen_at);
   if (session.view === "chat") {
     if (chatState === "running" || chatState === "waiting") return false;
-    if (session.role === "orchestrator")
+    if (isStandingRole(session.role))
       return orchestratorReplied(session.id, seen);
     const latest = latestChatItem(session.id);
     return latest?.kind === "turn_end" && latest.createdAt > seen;

package/lib/notify/index.ts

@@ -5,6 +5,7 @@
  * Needs-you list has those.
  */
 
+import { isStandingRole } from "../leads/roles";
 import { db, type Session } from "../db";
 import { Limiter, type Outcome } from "./limiter";
 import { holdForBatch, msToNextSweep } from "../away/state";
@@ -167,7 +168,7 @@ export async function notifyFrom(
   const body = text.trim();
   if (!body) throw new Error("Nothing to send");
   if (
-    session?.role === "orchestrator" &&
+    isStandingRole(session?.role) &&
     session.workspace_id &&
     holdForBatch(session.workspace_id, session.id, body)
   )

package/lib/orchestrator/act.ts

@@ -44,6 +44,7 @@ import { findPiece, pieceLabel, workspacePieces } from "../plans/claim";
 import { approvePlanNow } from "../models/plan-step";
 import { braked } from "./brakes";
 import { getOrchestrator } from "./home";
+import { actorIn } from "../leads/actor";
 import { addNote } from "./notes";
 import { findWorkspaceSession } from "./read";
 import { assignSessions, resolveGroup } from "../session-groups";
@@ -64,8 +65,9 @@ import {
 import { pauseUntil, type PausePreset } from "../sidebar/snooze";
 import type { Priority } from "../tasks/schedule-types";
 
+// Who is acting: the lead whose tool call this is, else the orchestrator.
 function orchestratorId(workspaceId: string): string {
-  const o = getOrchestrator(workspaceId);
+  const o = actorIn(workspaceId) ?? getOrchestrator(workspaceId);
   if (!o) throw new Error("This workspace has no orchestrator yet");
   return o.id;
 }

package/lib/orchestrator/ask-tool.ts

@@ -1,3 +1,6 @@
+import { actorIn } from "../leads/actor";
+import { leadKindOf } from "../leads/roles";
+import { TECH } from "../leads/types";
 import type { Session } from "../db";
 import { prFor } from "../tasks/session";
 import {
@@ -90,6 +93,12 @@ export async function askSaad(
     sha?: string;
   }
 ): Promise<string> {
+  const actor = actorIn(workspaceId);
+  const leadKind = (actor && leadKindOf(actor)) ?? TECH;
+  if (a.task && leadKind !== TECH)
+    throw new Error(
+      "Only the Tech lead asks to merge a PR; hand it over with send"
+    );
   if (!a.task !== !a.sha)
     throw new Error(
       "Give both task and sha to ask about merging a PR at a commit, or neither"
@@ -116,6 +125,7 @@ export async function askSaad(
       link: merge ? merge.url : (a.link ?? null),
       sha: merge?.sha ?? null,
       raisedBy: merge ? "orchestrator" : null,
+      leadKind,
     });
   } catch (error) {
     if (error instanceof AskRefused) return `Not asked: ${error.message}.`;

package/lib/orchestrator/ask-view.ts

@@ -30,6 +30,8 @@ export interface AskView {
   binding: string;
   presence: boolean;
   createdAt: string;
+  // The lead it is for: "tech" (the orchestrator) unless a lead raised it.
+  leadKind: string;
 }
 
 // A question the orchestrator put to Saad in chat, open until answered.

package/lib/orchestrator/asks.ts

@@ -18,8 +18,15 @@ import { addNote } from "./notes";
 import { cleanTitle, classifyKind, titleSubject } from "./ask-text";
 import { revokePasskey } from "../security/passkeys";
 import type { AskKind } from "./ask-view";
+import { TECH, type LeadKind } from "../leads/types";
+import { leadKindOf } from "../leads/roles";
 import { owner, ownerUi } from "../owner";
 
+const tellLead = (workspaceId: string, kind: LeadKind, line: string) =>
+  import("../leads/deliver")
+    .then((m) => m.tellLead(workspaceId, kind, line))
+    .catch((e) => console.error(`Ask answer for the ${kind} lead:`, e));
+
 export { ASK_KINDS, type AskKind } from "./ask-view";
 
 // The kinds the orchestrator raises itself; gate and brake asks come from
@@ -79,6 +86,9 @@ export interface AskRow {
   // "orchestrator" for a merge ask it raised with ask_owner; null when the
   // gates, the brakes or AgentOS raised or last wrote it.
   raised_by: string | null;
+  // The lead it is for (lib/leads): "tech", the orchestrator, unless a lead
+  // raised it. Two leads on one subject share the first one's ask.
+  lead_kind: LeadKind;
 }
 
 export type AskAnswer =
@@ -165,6 +175,7 @@ export function raiseAsk(input: {
   sha?: string | null;
   brakeKey?: string | null;
   raisedBy?: "orchestrator" | null;
+  leadKind?: LeadKind;
 }): { ask: AskRow; created: boolean } {
   const title = cleanTitle(input.title);
   if (!title) throw new Error("An ask needs a title");
@@ -197,8 +208,8 @@ export function raiseAsk(input: {
     if (refused) throw new AskRefused(refused);
     const { lastInsertRowid } = db
       .prepare(
-        `INSERT INTO orchestrator_asks (workspace_id, subject, kind, title, detail, link, sha, brake_key, raised_by)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO orchestrator_asks (workspace_id, subject, kind, title, detail, link, sha, brake_key, raised_by, lead_kind)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       )
       .run(
         input.workspaceId,
@@ -209,7 +220,8 @@ export function raiseAsk(input: {
         link,
         sha,
         brakeKey,
-        raisedBy
+        raisedBy,
+        input.leadKind ?? TECH
       );
     return {
       ask: getAsk(input.workspaceId, Number(lastInsertRowid))!,
@@ -254,17 +266,34 @@ export function openAsks(workspaceId: string): AskRow[] {
     .all(workspaceId) as AskRow[];
 }
 
-export function openAskCount(workspaceId: string | null | undefined): number {
+export function openAskCount(
+  workspaceId: string | null | undefined,
+  leadKind?: LeadKind
+): number {
   if (!workspaceId) return 0;
+  const lead = leadKind === undefined ? "" : " AND lead_kind = ?";
   return (
     db
       .prepare(
-        `SELECT COUNT(*) AS n FROM orchestrator_asks WHERE workspace_id = ? AND status = 'open'`
+        `SELECT COUNT(*) AS n FROM orchestrator_asks WHERE workspace_id = ? AND status = 'open'${lead}`
       )
-      .get(workspaceId) as { n: number }
+      .get(workspaceId, ...(leadKind === undefined ? [] : [leadKind])) as {
+      n: number;
+    }
   ).n;
 }
 
+// The open asks a standing session answers for: its own lead's. The chief
+// heads no department, so none are its.
+export function standingAskCount(s: {
+  role: string | null;
+  lead_kind?: string | null;
+  workspace_id?: string | null;
+}): number {
+  const kind = leadKindOf(s);
+  return kind ? openAskCount(s.workspace_id, kind) : 0;
+}
+
 const short = (sha: string | null) => (sha ? sha.slice(0, 7) : "its head");
 
 // What an approval lets the orchestrator do, said in the event so it can't
@@ -320,6 +349,10 @@ export function answerAsk(
   const text =
     answer.action === "reply" ? cap(answer.text, 4000) : answer.action;
   if (answer.action === "reply" && !text) throw new Error("The reply is empty");
+  // Another lead's ask is answered in its own chat; Tech's events stay
+  // exactly as they were.
+  const ownLead =
+    ask.lead_kind && ask.lead_kind !== TECH ? ask.lead_kind : null;
   const line = answerLine(
     ask,
     answer.action === "reply" ? { action: "reply", text } : answer,
@@ -330,11 +363,18 @@ export function answerAsk(
       `UPDATE orchestrator_asks SET status = ?, answer = ?, resolved_at = datetime('now') WHERE id = ?`
     ).run(STATUS_OF[answer.action], text, id);
     if (ask.kind === "passkey") settlePasskeyAsk(ask, answer.action);
-    else queueEvent(workspaceId, answerKey(id), null, line);
+    else if (!ownLead) queueEvent(workspaceId, answerKey(id), null, line);
   })();
+  if (ownLead && ask.kind !== "passkey")
+    void tellLead(workspaceId, ownLead, line);
   // An auto-approval is noted once, by recordAutoApproval.
   if (by === "saad")
-    addNote(workspaceId, `${ownerUi(true)} answered ${line}`, "ask");
+    addNote(
+      workspaceId,
+      `${ownerUi(true)} answered ${line}`,
+      "ask",
+      ownLead ?? undefined
+    );
   return getAsk(workspaceId, id)!;
 }