@saadnvd1/agent-os 0.3.853 → 0.3.859

package/lib/leads/digest.ts

@@ -0,0 +1,166 @@
+/**
+ * What a lead carries across a fresh start: its pinned direction (all of it,
+ * newest first), its memo, the pins it proposed, unread mail from other
+ * leads, and its own asks, work and decision log. Read from the database at
+ * every start, no model involved, under the same token budget as the
+ * orchestrator's digest.
+ */
+
+import { db } from "../db";
+import { owner } from "../owner";
+import {
+  CHARS_PER_TOKEN,
+  clip,
+  DIGEST_TOKENS,
+  renderDigest,
+  type Section,
+} from "../orchestrator/digest";
+import { openAsks } from "../orchestrator/asks";
+import { shortId } from "../orchestrator/describe";
+import { untrusted } from "../orchestrator/untrusted";
+import { currentDirection, openProposals } from "./direction";
+import { latestMemo } from "./memos";
+import { unreadFor } from "./messages";
+import { leadTitle } from "./home";
+import type { LeadKind } from "./types";
+
+const QUOTE_CAP = 600;
+const NOTES_SCANNED = 100;
+// What Tech's digest adds once its workspace has leads.
+export const TECH_LEAD_TOKENS = 1500;
+
+function directionSection(w: string, kind: LeadKind): Section {
+  return {
+    title: `Pinned direction, from ${owner()}, newest first`,
+    // The server copied each quote from his own message: it's his word.
+    lines: currentDirection(w, kind).map(
+      (p) =>
+        `- [pin ${p.id}, ${p.setAt.slice(0, 10)}] "${clip(p.quote, QUOTE_CAP)}"`
+    ),
+    empty: `- None yet. Only ${owner()} sets direction; propose a pin with propose_pin.`,
+    more: "direction",
+  };
+}
+
+function memoSection(w: string, kind: LeadKind): Section {
+  const memo = latestMemo(w, kind);
+  return {
+    title: "Your memo",
+    // Written by the lead from what it read: it informs, never authorizes.
+    lines: memo
+      ? [
+          `(${memo.createdAt.slice(0, 16)} UTC) ${untrusted("your memo", memo.text)}`,
+        ]
+      : [],
+    empty: "- None yet. Write one with update_memo.",
+    more: "direction",
+  };
+}
+
+function proposalsSection(w: string, kind: LeadKind): Section {
+  return {
+    title: `Pins you proposed, waiting for ${owner()}`,
+    lines: openProposals(w, kind).map(
+      (p) => `- [proposal ${p.id}] "${clip(p.quote, QUOTE_CAP)}"`
+    ),
+    more: "direction",
+  };
+}
+
+function mailSection(w: string, kind: LeadKind): Section {
+  return {
+    title: "Unread mail from other leads",
+    lines: unreadFor(w, kind).map(
+      (m) =>
+        `- [${m.createdAt.slice(0, 16)} UTC, from ${m.fromKind}, thread "${clip(m.thread, 80)}"] ${untrusted(`the ${m.fromKind} lead`, clip(m.text))}`
+    ),
+    more: "",
+  };
+}
+
+function asksSection(w: string, kind: LeadKind): Section {
+  return {
+    title: `Your open asks (waiting on ${owner()})`,
+    lines: openAsks(w)
+      .filter((a) => a.lead_kind === kind)
+      .map(
+        (a) =>
+          `- [ask ${a.id}] ${a.kind}: ${untrusted("ask title", clip(a.title, 160))}`
+      ),
+    empty: "- None.",
+    more: "",
+  };
+}
+
+function workSection(sessionId: string): Section {
+  const rows = db
+    .prepare(
+      `SELECT id, name, task_status, pr_number FROM session_rows
+       WHERE started_by = ? AND archived_at IS NULL
+         AND (task_status IS NULL OR task_status = 'running')
+       ORDER BY created_at DESC LIMIT 30`
+    )
+    .all(sessionId) as {
+    id: string;
+    name: string;
+    task_status: string | null;
+    pr_number: number | null;
+  }[];
+  return {
+    title: "Work you started, still open",
+    lines: rows.map(
+      (r) =>
+        `- ${shortId(r.id)} ${untrusted("session name", clip(r.name, 80))}${r.task_status ? " (task)" : ""}${r.pr_number ? ` PR #${r.pr_number}` : ""}`
+    ),
+    empty: "- None.",
+    more: "sessions",
+  };
+}
+
+function notesSection(w: string, kind: LeadKind): Section {
+  const rows = db
+    .prepare(
+      `SELECT kind, text, created_at FROM orchestrator_notes
+       WHERE workspace_id = ? AND lead_kind = ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(w, kind, NOTES_SCANNED) as {
+    kind: string;
+    text: string;
+    created_at: string;
+  }[];
+  return {
+    title: "Your decision log, newest first",
+    lines: rows.map(
+      (n) =>
+        `- ${n.created_at.slice(0, 16)} UTC${n.kind === "note" ? "" : ` ${n.kind}`}: ${untrusted(n.kind === "note" ? "your note" : `${n.kind} log line`, clip(n.text))}`
+    ),
+    more: "",
+  };
+}
+
+// A lead's whole digest. Tech's (`tech`) is only what its own digest lacks:
+// direction, memo, proposals and mail.
+export function buildLeadDigest(
+  w: string,
+  kind: LeadKind,
+  opts: { sessionId: string; tech?: boolean },
+  budgetTokens = opts.tech ? TECH_LEAD_TOKENS : DIGEST_TOKENS
+): string {
+  const head = opts.tech
+    ? `## Your direction as ${leadTitle(w, kind)}`
+    : "## Where things stand (read from AgentOS's database as you started)";
+  const sections = [
+    directionSection(w, kind),
+    memoSection(w, kind),
+    proposalsSection(w, kind),
+    mailSection(w, kind),
+    ...(opts.tech
+      ? []
+      : [
+          asksSection(w, kind),
+          workSection(opts.sessionId),
+          notesSection(w, kind),
+        ]),
+  ];
+  return `${head}\n\n${renderDigest(sections, budgetTokens - Math.ceil((head.length + 2) / CHARS_PER_TOKEN))}`;
+}

package/lib/leads/direction.ts

@@ -0,0 +1,202 @@
+import { db } from "@/lib/db";
+import type { Session } from "@/lib/db/types";
+import { getItem } from "@/lib/chat/store";
+import { originOf } from "@/lib/chat/origin";
+import { leadKindOf } from "./roles";
+import type { DirectionPin, LeadKind, PinProposal } from "./types";
+
+const QUOTE_CAP = 2000;
+
+interface PinRow {
+  id: number;
+  workspace_id: string;
+  lead_kind: string;
+  session_id: string;
+  chat_item_id: string;
+  quote: string;
+  set_at: string;
+  superseded_by: number | null;
+}
+
+interface ProposalRow {
+  id: number;
+  workspace_id: string;
+  lead_kind: string;
+  session_id: string;
+  chat_item_id: string;
+  quote: string;
+  status: PinProposal["status"];
+  created_at: string;
+  resolved_at: string | null;
+}
+
+const pinView = (r: PinRow): DirectionPin => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  leadKind: r.lead_kind,
+  sessionId: r.session_id,
+  chatItemId: r.chat_item_id,
+  quote: r.quote,
+  setAt: r.set_at,
+  supersededBy: r.superseded_by,
+});
+
+const proposalView = (r: ProposalRow): PinProposal => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  leadKind: r.lead_kind,
+  sessionId: r.session_id,
+  chatItemId: r.chat_item_id,
+  quote: r.quote,
+  status: r.status,
+  createdAt: r.created_at,
+  resolvedAt: r.resolved_at,
+});
+
+// The words a pin may quote: a message the person typed in this chat, read
+// from the database. An event, a peer, a schedule or the agent's own text
+// is never direction, whatever a lead says about it.
+export function authoredQuote(
+  sessionId: string,
+  chatItemId: string
+): string | null {
+  const item = getItem(sessionId, chatItemId);
+  if (!item || item.kind !== "user" || originOf(item) !== null) return null;
+  const text = item.text.trim().slice(0, QUOTE_CAP);
+  return text || null;
+}
+
+export interface PinTarget {
+  workspaceId: string;
+  leadKind: LeadKind;
+  sessionId: string;
+  chatItemId: string;
+}
+
+// The quote for a pin in a lead's own chat, or why it can't be one.
+function attest(t: PinTarget): { quote: string } | { error: string } {
+  const s = db
+    .prepare(
+      `SELECT role, lead_kind, workspace_id FROM session_rows WHERE id = ?`
+    )
+    .get(t.sessionId) as
+    Pick<Session, "role" | "lead_kind" | "workspace_id"> | undefined;
+  if (!s || s.workspace_id !== t.workspaceId || leadKindOf(s) !== t.leadKind)
+    return { error: "That chat isn't this lead's" };
+  const quote = authoredQuote(t.sessionId, t.chatItemId);
+  return quote ? { quote } : { error: "Only your own message can be pinned" };
+}
+
+export function pinDirection(
+  t: PinTarget & { supersedes?: number }
+): DirectionPin | { error: string } {
+  const a = attest(t);
+  if ("error" in a) return a;
+  return db.transaction(() => {
+    const { lastInsertRowid } = db
+      .prepare(
+        `INSERT INTO lead_direction (workspace_id, lead_kind, session_id, chat_item_id, quote)
+         VALUES (?, ?, ?, ?, ?)`
+      )
+      .run(t.workspaceId, t.leadKind, t.sessionId, t.chatItemId, a.quote);
+    const id = Number(lastInsertRowid);
+    if (t.supersedes)
+      db.prepare(
+        `UPDATE lead_direction SET superseded_by = ?
+         WHERE id = ? AND workspace_id = ? AND lead_kind = ? AND superseded_by IS NULL`
+      ).run(id, t.supersedes, t.workspaceId, t.leadKind);
+    return getPin(id)!;
+  })();
+}
+
+export function getPin(id: number): DirectionPin | null {
+  const r = db.prepare(`SELECT * FROM lead_direction WHERE id = ?`).get(id) as
+    PinRow | undefined;
+  return r ? pinView(r) : null;
+}
+
+// The pins in force, newest first.
+export function currentDirection(
+  workspaceId: string,
+  leadKind: LeadKind
+): DirectionPin[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_direction
+         WHERE workspace_id = ? AND lead_kind = ? AND superseded_by IS NULL
+         ORDER BY id DESC`
+      )
+      .all(workspaceId, leadKind) as PinRow[]
+  ).map(pinView);
+}
+
+export function directionHistory(
+  workspaceId: string,
+  leadKind: LeadKind
+): DirectionPin[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_direction WHERE workspace_id = ? AND lead_kind = ?
+         ORDER BY id DESC`
+      )
+      .all(workspaceId, leadKind) as PinRow[]
+  ).map(pinView);
+}
+
+// A lead suggests a pin; the quote is still the server's, and nothing is
+// direction until the person confirms it.
+export function proposePin(t: PinTarget): PinProposal | { error: string } {
+  const a = attest(t);
+  if ("error" in a) return a;
+  db.prepare(
+    `INSERT INTO lead_pin_proposals (workspace_id, lead_kind, session_id, chat_item_id, quote)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(session_id, chat_item_id) WHERE status = 'open' DO NOTHING`
+  ).run(t.workspaceId, t.leadKind, t.sessionId, t.chatItemId, a.quote);
+  const r = db
+    .prepare(
+      `SELECT * FROM lead_pin_proposals
+       WHERE session_id = ? AND chat_item_id = ? AND status = 'open'`
+    )
+    .get(t.sessionId, t.chatItemId) as ProposalRow;
+  return proposalView(r);
+}
+
+export function openProposals(
+  workspaceId: string,
+  leadKind: LeadKind
+): PinProposal[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_pin_proposals
+         WHERE workspace_id = ? AND lead_kind = ? AND status = 'open' ORDER BY id`
+      )
+      .all(workspaceId, leadKind) as ProposalRow[]
+  ).map(proposalView);
+}
+
+// One tap: pins the confirmed proposals and drops the rest of the open
+// ones. The quote is attested again, in case the item changed.
+export function resolveProposals(
+  workspaceId: string,
+  leadKind: LeadKind,
+  confirm: readonly number[]
+): DirectionPin[] {
+  const keep = new Set(confirm);
+  return db.transaction(() => {
+    const pins: DirectionPin[] = [];
+    for (const p of openProposals(workspaceId, leadKind)) {
+      const pin = keep.has(p.id) ? pinDirection(p) : null;
+      const ok = !!pin && !("error" in pin);
+      if (ok) pins.push(pin);
+      db.prepare(
+        `UPDATE lead_pin_proposals SET status = ?, resolved_at = datetime('now')
+         WHERE id = ?`
+      ).run(ok ? "pinned" : "dropped", p.id);
+    }
+    return pins;
+  })();
+}

package/lib/leads/home.ts

@@ -0,0 +1,196 @@
+/**
+ * A workspace's leads: durable chat sessions run like its orchestrator, each
+ * heading one department. The orchestrator is the Tech lead in place (same
+ * row, same data); the others are rows with the lead role, made by "Add leads"
+ * or adopted from an existing chat (./adopt).
+ */
+
+import fs from "fs";
+import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
+import { db, type Session } from "../db";
+import { agentosHome } from "../agentos-home";
+import { refuseRealStateUnderTest } from "../test-home-guard";
+import { getWorkspace } from "../workspaces";
+import { resolveRoleOrDefault } from "../models/resolve";
+import {
+  ensureOrchestrator,
+  getOrchestrator,
+  orchestratorDir,
+} from "../orchestrator/home";
+import { isLeadKind, leadKindOf, sqlLead, sqlStanding } from "./roles";
+import { TECH, type LeadKind } from "./types";
+import { markLeadsEnabled } from "./settings";
+import { getCharter, leadAreas, putCharter } from "./charters";
+import { charterTemplate } from "./templates";
+
+// Tech first, then the shipped kinds, then custom ones by name.
+const ORDER = [TECH, "marketing", "product"];
+const rank = (kind: string) => {
+  const i = ORDER.indexOf(kind);
+  return i < 0 ? ORDER.length : i;
+};
+export const byLeadOrder = (a: string, b: string) =>
+  rank(a) - rank(b) || a.localeCompare(b);
+
+// Where a lead starts and may write freely: the Tech lead keeps the
+// orchestrator's folder.
+export const leadDir = (workspaceId: string, kind: LeadKind) =>
+  kind === TECH
+    ? orchestratorDir(workspaceId)
+    : refuseRealStateUnderTest(agentosHome("leads", workspaceId, kind));
+
+// A standing session's own folder, whatever its role.
+export const standingDir = (
+  s: Pick<Session, "role" | "lead_kind" | "workspace_id">
+) => leadDir(s.workspace_id ?? "", leadKindOf(s) ?? "chief");
+
+export function getLead(workspaceId: string, kind: LeadKind): Session | null {
+  if (kind === TECH) return getOrchestrator(workspaceId);
+  return (
+    (db
+      .prepare(
+        `SELECT * FROM session_rows WHERE ${sqlLead()} AND workspace_id = ? AND lead_kind = ?`
+      )
+      .get(workspaceId, kind) as Session | undefined) ?? null
+  );
+}
+
+// The workspace's heads: its orchestrator (Tech) and its other leads.
+export function listLeads(workspaceId: string): Session[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE workspace_id = ? AND ${sqlLead()}`
+    )
+    .all(workspaceId) as Session[];
+  return rows.sort((a, b) =>
+    byLeadOrder(leadKindOf(a) ?? "", leadKindOf(b) ?? "")
+  );
+}
+
+export function leadTitle(workspaceId: string, kind: LeadKind): string {
+  return getCharter(workspaceId, kind)?.title || charterTemplate(kind).title;
+}
+
+// A lead starts from the generic charter for its kind; one already written
+// (by the person, in their own database) is never overwritten.
+export function seedCharter(workspaceId: string, kind: LeadKind): void {
+  if (getCharter(workspaceId, kind)) return;
+  const t = charterTemplate(kind);
+  putCharter({ workspaceId, leadKind: kind, ...t });
+}
+
+// Marks the orchestrator as the Tech lead, once.
+function claimTech(workspaceId: string): Session {
+  const tech = ensureOrchestrator(workspaceId);
+  db.prepare(
+    `UPDATE sessions SET lead_kind = 'tech', lead_since = COALESCE(lead_since, datetime('now'))
+     WHERE id = ?`
+  ).run(tech.id);
+  seedCharter(workspaceId, TECH);
+  return getOrchestrator(workspaceId)!;
+}
+
+function createLead(workspaceId: string, kind: LeadKind): Session {
+  const existing = getLead(workspaceId, kind);
+  if (existing) return existing;
+  const workspace = getWorkspace(workspaceId)!;
+  seedCharter(workspaceId, kind);
+  const dir = leadDir(workspaceId, kind);
+  fs.mkdirSync(dir, { recursive: true });
+  const id = randomUUID();
+  // Two at once still make one: the unique (workspace, kind) index decides.
+  db.prepare(
+    `INSERT OR IGNORE INTO sessions (id, name, tmux_name, working_directory, model,
+       group_path, agent_type, auto_approve, project_id, host_id, view, chat_access,
+       role, lead_kind, lead_since, workspace_id, pinned)
+     VALUES (?, ?, ?, ?, ?, 'sessions', 'claude', 0, NULL, 'local', 'chat', 'ask',
+       'lead', ?, datetime('now'), ?, 1)`
+  ).run(
+    id,
+    `${workspace.name} ${leadTitle(workspaceId, kind)}`,
+    `claude-${id}`,
+    dir,
+    resolveRoleOrDefault("orchestrator", { workspaceId }).model,
+    kind,
+    workspaceId
+  );
+  return getLead(workspaceId, kind)!;
+}
+
+export function checkKinds(kinds: unknown): LeadKind[] {
+  if (!Array.isArray(kinds) || !kinds.every(isLeadKind))
+    throw new Error(
+      "Each lead is a short lowercase name: letters, digits and dashes"
+    );
+  return [...new Set(kinds)].filter((k) => k !== TECH);
+}
+
+// "Add leads": the workspace gets its Tech lead (its orchestrator, made if
+// it has none) and the leads picked. Safe to run again; nothing made twice.
+export function addLeads(workspaceId: string, kinds: LeadKind[]): Session[] {
+  if (!getWorkspace(workspaceId)) throw new Error("Unknown workspace");
+  const picked = checkKinds(kinds);
+  markLeadsEnabled(workspaceId);
+  claimTech(workspaceId);
+  for (const kind of picked) createLead(workspaceId, kind);
+  return listLeads(workspaceId);
+}
+
+// The secret a standing session's worker sends with each tool call, so no
+// other local process can act as it. The orchestrator's is the one it
+// always had.
+export function standingToken(sessionId: string): string {
+  db.prepare(
+    `UPDATE sessions SET orch_token = COALESCE(orch_token, ?) WHERE id = ?`
+  ).run(randomBytes(32).toString("hex"), sessionId);
+  const row = db
+    .prepare(`SELECT orch_token FROM sessions WHERE id = ?`)
+    .get(sessionId) as { orch_token: string | null } | undefined;
+  if (!row?.orch_token) throw new Error("No such session");
+  return row.orch_token;
+}
+
+// Which of the workspace's standing sessions holds this token, if any.
+export function standingByToken(
+  workspaceId: string,
+  token: string | null
+): Session | null {
+  if (!token) return null;
+  const b = Buffer.from(token);
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE workspace_id = ? AND ${sqlStanding()} AND orch_token IS NOT NULL`
+    )
+    .all(workspaceId) as Session[];
+  let found: Session | null = null;
+  for (const s of rows) {
+    const a = Buffer.from(s.orch_token!);
+    if (a.length === b.length && timingSafeEqual(a, b)) found = s;
+  }
+  return found;
+}
+
+export interface LeadView {
+  kind: LeadKind;
+  title: string;
+  sessionId: string;
+  name: string;
+  since: string | null;
+  areas: { kind: string; value: string }[];
+}
+
+export function leadViews(workspaceId: string): LeadView[] {
+  return listLeads(workspaceId).map((s) => {
+    const kind = leadKindOf(s) ?? TECH;
+    return {
+      kind,
+      title: leadTitle(workspaceId, kind),
+      sessionId: s.id,
+      name: s.name,
+      since: s.lead_since ?? null,
+      areas: leadAreas(workspaceId, kind),
+    };
+  });
+}

package/lib/leads/index.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./roles";
+export * from "./settings";
+export * from "./charters";
+export * from "./direction";
+export * from "./memos";
+export * from "./messages";
+export * from "./usage";

package/lib/leads/memos.ts

@@ -0,0 +1,70 @@
+import { db } from "@/lib/db";
+import type { LeadKind, LeadMemo } from "./types";
+
+// About 1.5k tokens: what a lead carries across a fresh start, with its
+// pinned direction.
+export const MEMO_CAP = 6000;
+
+interface Row {
+  id: number;
+  workspace_id: string;
+  lead_kind: string;
+  text: string;
+  created_at: string;
+}
+
+const view = (r: Row): LeadMemo => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  leadKind: r.lead_kind,
+  text: r.text,
+  createdAt: r.created_at,
+});
+
+// Every version is kept; the newest is the memo.
+export function writeMemo(
+  workspaceId: string,
+  leadKind: LeadKind,
+  text: string
+): LeadMemo {
+  const body = text.trim().slice(0, MEMO_CAP);
+  if (!body) throw new Error("The memo is empty");
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO lead_memos (workspace_id, lead_kind, text) VALUES (?, ?, ?)`
+    )
+    .run(workspaceId, leadKind, body);
+  return view(
+    db
+      .prepare(`SELECT * FROM lead_memos WHERE id = ?`)
+      .get(Number(lastInsertRowid)) as Row
+  );
+}
+
+export function latestMemo(
+  workspaceId: string,
+  leadKind: LeadKind
+): LeadMemo | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM lead_memos WHERE workspace_id = ? AND lead_kind = ?
+       ORDER BY id DESC LIMIT 1`
+    )
+    .get(workspaceId, leadKind) as Row | undefined;
+  return r ? view(r) : null;
+}
+
+export function memoHistory(
+  workspaceId: string,
+  leadKind: LeadKind,
+  limit = 20
+): LeadMemo[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_memos WHERE workspace_id = ? AND lead_kind = ?
+         ORDER BY id DESC LIMIT ?`
+      )
+      .all(workspaceId, leadKind, limit) as Row[]
+  ).map(view);
+}