@saadnvd1/agent-os 0.3.853 → 0.3.859

package/lib/leads/messages.ts

@@ -0,0 +1,112 @@
+import { db } from "@/lib/db";
+import type { LeadKind, LeadMessage } from "./types";
+
+const TEXT_CAP = 4000;
+
+interface Row {
+  id: number;
+  workspace_id: string;
+  from_kind: string;
+  to_kind: string;
+  thread: string;
+  text: string;
+  created_at: string;
+  read_at: string | null;
+}
+
+const view = (r: Row): LeadMessage => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  fromKind: r.from_kind,
+  toKind: r.to_kind,
+  thread: r.thread,
+  text: r.text,
+  createdAt: r.created_at,
+  readAt: r.read_at,
+});
+
+// Lead-to-lead and chief-to-lead mail. The chief writes as "chief".
+export function addLeadMessage(m: {
+  workspaceId: string;
+  fromKind: LeadKind;
+  toKind: LeadKind;
+  thread: string;
+  text: string;
+}): LeadMessage {
+  const text = m.text.trim().slice(0, TEXT_CAP);
+  const thread = m.thread.trim().slice(0, 120);
+  if (!text || !thread) throw new Error("A message needs a thread and text");
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO lead_messages (workspace_id, from_kind, to_kind, thread, text)
+       VALUES (?, ?, ?, ?, ?)`
+    )
+    .run(m.workspaceId, m.fromKind, m.toKind, thread, text);
+  return view(
+    db
+      .prepare(`SELECT * FROM lead_messages WHERE id = ?`)
+      .get(Number(lastInsertRowid)) as Row
+  );
+}
+
+export function unreadFor(
+  workspaceId: string,
+  toKind: LeadKind
+): LeadMessage[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_messages
+         WHERE workspace_id = ? AND to_kind = ? AND read_at IS NULL ORDER BY id`
+      )
+      .all(workspaceId, toKind) as Row[]
+  ).map(view);
+}
+
+export function markRead(
+  workspaceId: string,
+  toKind: LeadKind,
+  upToId: number
+): number {
+  return db
+    .prepare(
+      `UPDATE lead_messages SET read_at = datetime('now')
+       WHERE workspace_id = ? AND to_kind = ? AND id <= ? AND read_at IS NULL`
+    )
+    .run(workspaceId, toKind, upToId).changes;
+}
+
+export function threadMessages(
+  workspaceId: string,
+  thread: string,
+  limit = 50
+): LeadMessage[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM (SELECT * FROM lead_messages WHERE workspace_id = ? AND thread = ?
+         ORDER BY id DESC LIMIT ?) ORDER BY id`
+      )
+      .all(workspaceId, thread, limit) as Row[]
+  ).map(view);
+}
+
+// Sent within the window from one lead to another on a thread, for the
+// loop guard.
+export function sentSince(
+  workspaceId: string,
+  fromKind: LeadKind,
+  toKind: LeadKind,
+  thread: string,
+  sinceSqlite: string
+): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM lead_messages
+         WHERE workspace_id = ? AND from_kind = ? AND to_kind = ? AND thread = ?
+           AND created_at >= ?`
+      )
+      .get(workspaceId, fromKind, toKind, thread, sinceSqlite) as { n: number }
+  ).n;
+}

package/lib/leads/profiles.ts

@@ -0,0 +1,83 @@
+// What each kind of lead may do: one profile per kind, applied where the
+// orchestrator's tools are built (orchestrator/worker.ts) and enforced again
+// by the server on every call (./tools.ts). Tool bodies stay where they are.
+
+import type { Session } from "@/lib/db/types";
+import { TOOLS, type ToolName } from "../orchestrator/tool-schemas";
+import { isLeadRole, isTechRole } from "./roles";
+import type { LeadKind } from "./types";
+import { TECH } from "./types";
+
+// A lead's own tools, on top of the orchestrator's (./tools.ts).
+export const LEAD_TOOLS = ["update_memo", "propose_pin", "direction"] as const;
+export type LeadToolName = (typeof LEAD_TOOLS)[number];
+export const isLeadToolName = (t: unknown): t is LeadToolName =>
+  typeof t === "string" && (LEAD_TOOLS as readonly string[]).includes(t);
+
+// Only the Tech lead has these. Landing code is one head's job: reviews,
+// merges, arming, landing stacks and its own quick changes. So are the
+// machine (disk clean-up, moving tasks), the workspace's projects and tiers,
+// other workspaces, its standing rules, reminders and open questions, and
+// starting past the running-task limit.
+export const TECH_ONLY: ReadonlySet<ToolName> = new Set<ToolName>([
+  "review",
+  "sign_off",
+  "arm",
+  "disarm",
+  "land",
+  "done",
+  "quick_change",
+  "quick_pr",
+  "move",
+  "sweep_dry_run",
+  "sweep_arm",
+  "add_project",
+  "project_tier",
+  "orchestrators",
+  "message_orchestrator",
+  "rule_add",
+  "rule_remove",
+  "remind_me",
+  "reminders",
+  "cancel_reminder",
+  "question",
+  "resolve_question",
+  "start_now",
+  "recipe_save",
+  "recipe_update",
+]);
+
+export interface Profile {
+  kind: LeadKind;
+  tools: readonly ToolName[];
+  leadTools: readonly LeadToolName[];
+  // Starts and stops only inside its area (./area.ts).
+  inArea: boolean;
+}
+
+// A standing session's profile, or null for one that has none yet (the
+// chief, piece 7). The orchestrator of a workspace without leads keeps
+// exactly the tools it always had.
+export function profileFor(
+  s: Pick<Session, "role" | "lead_kind">,
+  workspaceHasLeads: boolean
+): Profile | null {
+  if (isTechRole(s.role))
+    return {
+      kind: TECH,
+      tools: TOOLS,
+      leadTools: workspaceHasLeads ? LEAD_TOOLS : [],
+      inArea: false,
+    };
+  if (!isLeadRole(s.role) || !s.lead_kind) return null;
+  return {
+    kind: s.lead_kind,
+    tools: TOOLS.filter((t) => !TECH_ONLY.has(t)),
+    leadTools: LEAD_TOOLS,
+    inArea: true,
+  };
+}
+
+export const profileHas = (p: Profile, tool: string): boolean =>
+  (p.tools as readonly string[]).includes(tool) ||
+  (p.leadTools as readonly string[]).includes(tool);

package/lib/leads/roles.ts

@@ -0,0 +1,114 @@
+import type { SessionRole } from "@/lib/db/types";
+import { TECH, type LeadKind } from "./types";
+
+// Client-safe: no database. Every check of `sessions.role` goes through one of
+// the decisions below (role-sites.test.ts fails on a raw one), and each
+// decision is a table over every role, so a new role can't be added without
+// deciding it everywhere.
+
+type RoleTable<T> = Readonly<Record<SessionRole | "none", T>>;
+
+const decide =
+  (t: RoleTable<boolean>) =>
+  (role: string | null | undefined): boolean =>
+    (t as Record<string, boolean>)[role ?? "none"] ?? false;
+
+// Every value `sessions.role` can hold. A standing session belongs to its
+// workspace and lives until its workspace goes: it is never swept as idle,
+// shown as done, archived, forked, moved or counted as a worker, and it
+// starts fresh rather than compacting.
+export const STANDING_ROLES = [
+  "orchestrator",
+  "lead",
+  "chief",
+] as const satisfies readonly SessionRole[];
+
+const STANDING: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: true,
+  chief: true,
+};
+
+// The workspace's orchestrator, which is its Tech lead: the one head that
+// lands code (sign-off, arming, merges), owns the workspace's own schedule
+// kind and is what "orchestrator" names on the bus. Also the orchestrator's
+// own machinery (its tools, brief and Needs-you bar) until a lead gets a
+// profile of its own.
+const TECH_ROLE: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: false,
+  chief: false,
+};
+
+// A department head: the orchestrator (Tech) or another lead.
+const LEAD: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: true,
+  chief: false,
+};
+
+export const ROLE_DECISIONS = {
+  standing: STANDING,
+  tech: TECH_ROLE,
+  lead: LEAD,
+} as const;
+
+export const isStandingRole = decide(STANDING) as (
+  role: string | null | undefined
+) => role is SessionRole;
+export const isTechRole = decide(TECH_ROLE);
+export const isLeadRole = decide(LEAD);
+
+const NOUN: RoleTable<string> = {
+  none: "session",
+  orchestrator: "orchestrator",
+  lead: "lead",
+  chief: "chief of staff",
+};
+
+// "orchestrator", "lead": for refusals that name what a session is.
+export const roleNoun = (role: string | null | undefined): string =>
+  (NOUN as Record<string, string>)[role ?? "none"] ?? NOUN.none;
+export const roleLabel = (role: string | null | undefined): string => {
+  const n = roleNoun(role);
+  return `${/^[aeiou]/.test(n) ? "an" : "a"} ${n}`;
+};
+export const RoleLabel = (role: string | null | undefined): string => {
+  const l = roleLabel(role);
+  return l[0].toUpperCase() + l.slice(1);
+};
+
+// The same decisions in SQL, for a column holding `sessions.role`. Every
+// role value is standing, so "no role" is the plain worker.
+const SQL_ROLES = STANDING_ROLES.map((r) => `'${r}'`).join(", ");
+export const sqlStanding = (col = "role") => `${col} IN (${SQL_ROLES})`;
+export const sqlNoRole = (col = "role") => `${col} IS NULL`;
+export const sqlTech = (col = "role") => `${col} = 'orchestrator'`;
+const SQL_LEADS = STANDING_ROLES.filter((r) => LEAD[r])
+  .map((r) => `'${r}'`)
+  .join(", ");
+export const sqlLead = (col = "role") => `${col} IN (${SQL_LEADS})`;
+
+// The department a standing session heads: the orchestrator is always Tech,
+// even before its workspace adds leads; the chief heads none.
+export function leadKindOf(s: {
+  role: string | null;
+  lead_kind?: string | null;
+}): LeadKind | null {
+  if (s.role === "orchestrator") return TECH;
+  if (s.role === "lead") return s.lead_kind ?? null;
+  return null;
+}
+
+const SLUG = /^[a-z][a-z0-9-]{0,31}$/;
+
+export const isLeadKind = (v: unknown): v is LeadKind =>
+  typeof v === "string" && SLUG.test(v);
+
+// A linked machine may run a newer AgentOS with roles this one doesn't know:
+// any role it reports is standing there.
+export const isPeerStanding = (role: unknown): boolean =>
+  typeof role === "string" ? role !== "" : role != null;

package/lib/leads/settings.ts

@@ -0,0 +1,55 @@
+import { db } from "@/lib/db";
+import type { ChiefAutonomy, WorkspaceLeads } from "./types";
+
+interface Row {
+  workspace_id: string;
+  enabled_at: string;
+  chief_autonomy: ChiefAutonomy;
+}
+
+const view = (r: Row): WorkspaceLeads => ({
+  workspaceId: r.workspace_id,
+  enabledAt: r.enabled_at,
+  chiefAutonomy: r.chief_autonomy,
+});
+
+// Whether "Add leads" ran on this workspace. The experiment switch alone
+// creates nothing; a workspace without this row is exactly as before.
+export function workspaceLeads(workspaceId: string): WorkspaceLeads | null {
+  const row = db
+    .prepare(`SELECT * FROM workspace_leads WHERE workspace_id = ?`)
+    .get(workspaceId) as Row | undefined;
+  return row ? view(row) : null;
+}
+
+export const hasLeads = (workspaceId: string | null | undefined): boolean =>
+  !!workspaceId && !!workspaceLeads(workspaceId);
+
+export function workspacesWithLeads(): WorkspaceLeads[] {
+  return (
+    db
+      .prepare(`SELECT * FROM workspace_leads ORDER BY enabled_at`)
+      .all() as Row[]
+  ).map(view);
+}
+
+export function markLeadsEnabled(workspaceId: string): WorkspaceLeads {
+  db.prepare(
+    `INSERT INTO workspace_leads (workspace_id) VALUES (?)
+     ON CONFLICT(workspace_id) DO NOTHING`
+  ).run(workspaceId);
+  return workspaceLeads(workspaceId)!;
+}
+
+export function setChiefAutonomy(
+  workspaceId: string,
+  autonomy: ChiefAutonomy
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE workspace_leads SET chief_autonomy = ? WHERE workspace_id = ?`
+      )
+      .run(autonomy, workspaceId).changes > 0
+  );
+}

package/lib/leads/templates.ts

@@ -0,0 +1,51 @@
+import { TECH, type LeadKind } from "./types";
+
+// The generic charters a new lead starts from. Real charters (a person's
+// own voice, market, house rules) are written into their own database
+// from Settings, never shipped here.
+export interface CharterTemplate {
+  title: string;
+  areaText: string;
+  charterMd: string;
+  goal: string;
+}
+
+const TEMPLATES: Record<string, CharterTemplate> = {
+  [TECH]: {
+    title: "Tech lead",
+    areaText:
+      "Every project in the workspace: tasks, reviews, merges and deploys.",
+    charterMd:
+      "You own how code lands: every task, review, merge and deploy goes through you and the gates. Other leads hand you code work; you decide how it is built and when it merges.",
+    goal: "Ship what the workspace needs, safely, through the gates.",
+  },
+  marketing: {
+    title: "Marketing lead",
+    areaText: "Content, pages, guides and the marketing board.",
+    charterMd:
+      "You own how the product is explained and found: pages, guides, posts and what's new. You draft; anything public waits for the owner's yes. Code changes go to the Tech lead.",
+    goal: "Steady, organic growth through useful content.",
+  },
+  product: {
+    title: "Product lead",
+    areaText: "What gets built next: the roadmap, cards and specs.",
+    charterMd:
+      "You own what gets built and why: you turn feedback and ideas into clear cards and specs, keep the roadmap ordered, and hand build work to the Tech lead. Product calls the owner hasn't made are asks.",
+    goal: "The next thing built is the most useful one.",
+  },
+};
+
+const titleCase = (kind: string) =>
+  kind
+    .split("-")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ");
+
+// A shipped kind's template, or a blank one titled after a custom kind.
+export const charterTemplate = (kind: LeadKind): CharterTemplate =>
+  TEMPLATES[kind] ?? {
+    title: `${titleCase(kind)} lead`,
+    areaText: "",
+    charterMd: "",
+    goal: "",
+  };

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