@saadnvd1/agent-os 0.3.700 → 0.3.723

package/lib/analyst/store.ts

@@ -0,0 +1,303 @@
+import { randomUUID } from "crypto";
+import { db } from "../db";
+import {
+  AnalystError,
+  type AnalystLink,
+  type DigestSignals,
+  type Issue,
+  type Recommendation,
+  type RecommendationState,
+  type Verdict,
+} from "./types";
+
+interface LinkRow {
+  id: string;
+  coder_session_id: string;
+  analyst_session_id: string;
+  paused: number;
+  reviewed_through: string | null;
+  pending_digest_id: string | null;
+  pending_through: string | null;
+  digest_signals: string | null;
+  created_at: number;
+  ended_at: number | null;
+}
+
+interface RecRow {
+  id: string;
+  link_id: string;
+  analyst_item_id: string;
+  coder_through: string | null;
+  verdict: string | null;
+  summary: string;
+  issues: string;
+  signals: string | null;
+  prompt: string | null;
+  state: string;
+  error: string | null;
+  sent_text: string | null;
+  sent_item_id: string | null;
+  edited: number;
+  created_at: number;
+  decided_at: number | null;
+}
+
+const parse = <T>(s: string | null, fallback: T): T => {
+  if (!s) return fallback;
+  try {
+    return JSON.parse(s) as T;
+  } catch {
+    return fallback;
+  }
+};
+
+const toLink = (r: LinkRow): AnalystLink => ({
+  id: r.id,
+  coderSessionId: r.coder_session_id,
+  analystSessionId: r.analyst_session_id,
+  paused: !!r.paused,
+  reviewedThrough: r.reviewed_through,
+  pendingDigestId: r.pending_digest_id,
+  pendingThrough: r.pending_through,
+  digestSignals: parse<DigestSignals | null>(r.digest_signals, null),
+  createdAt: r.created_at,
+  endedAt: r.ended_at,
+});
+
+const toRec = (r: RecRow): Recommendation => ({
+  id: r.id,
+  linkId: r.link_id,
+  analystItemId: r.analyst_item_id,
+  coderThrough: r.coder_through,
+  verdict: r.verdict as Verdict | null,
+  summary: r.summary,
+  issues: parse<Issue[]>(r.issues, []),
+  signals: parse<DigestSignals | null>(r.signals, null),
+  prompt: r.prompt,
+  state: r.state as RecommendationState,
+  error: r.error,
+  sentText: r.sent_text,
+  sentItemId: r.sent_item_id,
+  edited: !!r.edited,
+  createdAt: r.created_at,
+  decidedAt: r.decided_at,
+});
+
+export function getLink(id: string): AnalystLink | null {
+  const r = db.prepare(`SELECT * FROM analyst_links WHERE id = ?`).get(id) as
+    LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+export function getLinkOrThrow(id: string): AnalystLink {
+  const link = getLink(id);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  return link;
+}
+
+// The live link a session is in, on either side.
+export function liveLinkFor(sessionId: string): AnalystLink | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM analyst_links WHERE ended_at IS NULL
+         AND (coder_session_id = ? OR analyst_session_id = ?)`
+    )
+    .get(sessionId, sessionId) as LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+// Any link, live or ended, the session was the analyst of.
+export function linkOfAnalyst(sessionId: string): AnalystLink | null {
+  const r = db
+    .prepare(`SELECT * FROM analyst_links WHERE analyst_session_id = ?`)
+    .get(sessionId) as LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+export function liveLinks(): AnalystLink[] {
+  return (
+    db
+      .prepare(`SELECT * FROM analyst_links WHERE ended_at IS NULL`)
+      .all() as LinkRow[]
+  ).map(toLink);
+}
+
+export function insertLink(
+  coderSessionId: string,
+  analystSessionId: string,
+  reviewedThrough: string | null
+): AnalystLink {
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO analyst_links (id, coder_session_id, analyst_session_id,
+       reviewed_through, created_at) VALUES (?, ?, ?, ?, ?)`
+  ).run(id, coderSessionId, analystSessionId, reviewedThrough, Date.now());
+  return getLink(id)!;
+}
+
+export function setPausedRow(id: string, paused: boolean): void {
+  db.prepare(`UPDATE analyst_links SET paused = ? WHERE id = ?`).run(
+    paused ? 1 : 0,
+    id
+  );
+}
+
+export function endLinkRow(id: string): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_links SET ended_at = ? WHERE id = ? AND ended_at IS NULL`
+      )
+      .run(Date.now(), id).changes > 0
+  );
+}
+
+// Recorded before the digest is sent, so a restart can send it again.
+export function markDigestPending(
+  id: string,
+  digestId: string,
+  through: string,
+  signals: DigestSignals
+): void {
+  db.prepare(
+    `UPDATE analyst_links SET pending_digest_id = ?, pending_through = ?,
+       digest_signals = ? WHERE id = ?`
+  ).run(digestId, through, JSON.stringify(signals), id);
+}
+
+// The analyst answered the digest: its turns count as reviewed.
+export function settleDigest(id: string, digestId: string): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_links SET reviewed_through = pending_through,
+           pending_digest_id = NULL, pending_through = NULL
+         WHERE id = ? AND pending_digest_id = ?`
+      )
+      .run(id, digestId).changes > 0
+  );
+}
+
+// A digest that never arrived: dropped, so the next one covers its turns.
+export function dropPendingDigest(id: string): void {
+  db.prepare(
+    `UPDATE analyst_links SET pending_digest_id = NULL, pending_through = NULL
+      WHERE id = ?`
+  ).run(id);
+}
+
+export function listRecommendations(
+  linkId: string,
+  limit = 20
+): Recommendation[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM analyst_recommendations WHERE link_id = ?
+          ORDER BY created_at DESC, rowid DESC LIMIT ?`
+      )
+      .all(linkId, limit) as RecRow[]
+  ).map(toRec);
+}
+
+export function getRecommendation(id: string): Recommendation | null {
+  const r = db
+    .prepare(`SELECT * FROM analyst_recommendations WHERE id = ?`)
+    .get(id) as RecRow | undefined;
+  return r ? toRec(r) : null;
+}
+
+export function recommendationFor(
+  linkId: string,
+  analystItemId: string
+): Recommendation | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM analyst_recommendations WHERE link_id = ? AND analyst_item_id = ?`
+    )
+    .get(linkId, analystItemId) as RecRow | undefined;
+  return r ? toRec(r) : null;
+}
+
+export interface NewRecommendation {
+  linkId: string;
+  analystItemId: string;
+  coderThrough: string | null;
+  verdict: Verdict | null;
+  summary: string;
+  issues: Issue[];
+  signals: DigestSignals | null;
+  prompt: string | null;
+  state: "open" | "invalid";
+  error?: string | null;
+}
+
+// Once per analyst reply: a repeat is a no-op. A new one retires the
+// cards still open, so only one is ever actionable.
+export function insertRecommendation(
+  r: NewRecommendation
+): Recommendation | null {
+  const id = randomUUID();
+  const inserted = db.transaction(() => {
+    const changes = db
+      .prepare(
+        `INSERT OR IGNORE INTO analyst_recommendations (id, link_id,
+           analyst_item_id, coder_through, verdict, summary, issues, signals,
+           prompt, state, error, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        r.linkId,
+        r.analystItemId,
+        r.coderThrough,
+        r.verdict,
+        r.summary,
+        JSON.stringify(r.issues),
+        r.signals ? JSON.stringify(r.signals) : null,
+        r.prompt,
+        r.state,
+        r.error ?? null,
+        Date.now()
+      ).changes;
+    if (!changes) return false;
+    db.prepare(
+      `UPDATE analyst_recommendations SET state = 'superseded', decided_at = ?
+        WHERE link_id = ? AND id != ? AND state IN ('open', 'invalid')`
+    ).run(Date.now(), r.linkId, id);
+    return true;
+  })();
+  return inserted ? getRecommendation(id) : null;
+}
+
+// Moves an open card to its decision, once: false when it was decided.
+export function decideRecommendation(
+  id: string,
+  state: "sent" | "dismissed",
+  sent?: { text: string; itemId: string; edited: boolean }
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_recommendations SET state = ?, decided_at = ?,
+           sent_text = ?, sent_item_id = ?, edited = ?
+         WHERE id = ? AND state IN ('open', 'invalid')`
+      )
+      .run(
+        state,
+        Date.now(),
+        sent?.text ?? null,
+        sent?.itemId ?? null,
+        sent?.edited ? 1 : 0,
+        id
+      ).changes > 0
+  );
+}
+
+// Back to open: a send that failed after the card was claimed.
+export function reopenRecommendation(id: string): void {
+  db.prepare(
+    `UPDATE analyst_recommendations SET state = 'open', decided_at = NULL,
+       sent_text = NULL, sent_item_id = NULL, edited = 0 WHERE id = ?`
+  ).run(id);
+}

package/lib/analyst/types.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+
+// What the analyst says the coding agent should do next.
+export const VERDICTS = ["continue", "done", "blocked", "needs_you"] as const;
+export type Verdict = (typeof VERDICTS)[number];
+
+export const RECOMMENDATION_STATES = [
+  "open",
+  "sent",
+  "dismissed",
+  "superseded",
+  "invalid",
+] as const;
+export type RecommendationState = (typeof RECOMMENDATION_STATES)[number];
+
+export const issueSchema = z.object({
+  severity: z.enum(["high", "medium", "low"]),
+  title: z.string().trim().min(1).max(200),
+  detail: z.string().trim().max(2_000).default(""),
+  where: z.string().trim().max(300).optional(),
+});
+export type Issue = z.infer<typeof issueSchema>;
+
+export const MAX_ISSUES = 8;
+export const MAX_PROMPT = 4_000;
+
+// The fenced `agentos-review` block the analyst ends each review with.
+export const reviewSchema = z.object({
+  verdict: z.enum(VERDICTS),
+  summary: z.string().trim().min(1).max(1_000),
+  issues: z.array(issueSchema).max(MAX_ISSUES).default([]),
+  prompt: z.string().trim().max(MAX_PROMPT).nullable().optional(),
+});
+export type Review = z.infer<typeof reviewSchema>;
+
+// What a batch of the coding agent's turns did, worked out without a model.
+export interface DigestSignals {
+  turns: number;
+  toolCalls: number;
+  failedTools: number;
+  // Test, build, typecheck or lint commands, and whether each passed.
+  checks: { command: string; passed: boolean }[];
+  filesChanged: string[];
+  durationMs: number;
+  costUsd: number;
+  interrupted: boolean;
+  errors: number;
+  // Turns that ended without a single tool call.
+  noToolTurns: number;
+  // Fetched web content: a prompt built on it shouldn't be sent unseen.
+  readWeb: boolean;
+}
+
+export interface AnalystLink {
+  id: string;
+  coderSessionId: string;
+  analystSessionId: string;
+  paused: boolean;
+  // The coding agent's last turn_end the analyst has answered for.
+  reviewedThrough: string | null;
+  // A digest sent and not yet answered, the turn_end it runs to, and what
+  // its turns did.
+  pendingDigestId: string | null;
+  pendingThrough: string | null;
+  digestSignals: DigestSignals | null;
+  createdAt: number;
+  endedAt: number | null;
+}
+
+export interface Recommendation {
+  id: string;
+  linkId: string;
+  analystItemId: string;
+  coderThrough: string | null;
+  verdict: Verdict | null;
+  summary: string;
+  issues: Issue[];
+  signals: DigestSignals | null;
+  prompt: string | null;
+  state: RecommendationState;
+  // Why it's invalid.
+  error: string | null;
+  sentText: string | null;
+  sentItemId: string | null;
+  edited: boolean;
+  createdAt: number;
+  decidedAt: number | null;
+}
+
+export interface PaneSession {
+  id: string;
+  name: string;
+  agentType: string;
+  model: string | null;
+}
+
+// A link as the panes and the native app read it.
+export interface AnalystLinkView extends AnalystLink {
+  coder: PaneSession;
+  analyst: PaneSession;
+  // The coding agent's latest finished turn, to tell a card it has moved on.
+  coderLastTurn: string | null;
+  recommendations: Recommendation[];
+}
+
+export class AnalystError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404 | 409 = 400
+  ) {
+    super(message);
+  }
+}
+
+export const createLinkSchema = z
+  .object({
+    coderSessionId: z.string().min(1).optional(),
+    newCoder: z
+      .object({
+        projectId: z.string().min(1),
+        agentType: z.string().min(1),
+        model: z.string().trim().min(1).optional(),
+        prompt: z.string().trim().max(20_000).optional(),
+        useWorktree: z.boolean().optional(),
+      })
+      .optional(),
+    // The analyst's model for this pair, "provider/model"; else its role's.
+    analystModel: z.string().trim().min(1).max(200).optional(),
+    reviewLast: z.boolean().optional(),
+  })
+  .refine((b) => !!b.coderSessionId !== !!b.newCoder, {
+    message: "Give coderSessionId or newCoder, not both",
+  });
+export type CreateLinkInput = z.infer<typeof createLinkSchema>;
+
+export const patchLinkSchema = z.object({ paused: z.boolean() });
+
+export const sendSchema = z.object({
+  text: z.string().trim().min(1).max(20_000).optional(),
+});

package/lib/bus/condense.ts

@@ -102,7 +102,11 @@ function lineOf(i: ChatItem): string | null {
     case "compacted":
       return "[conversation compacted]";
     case "turn_end":
-      return i.interrupted ? "[turn stopped]" : null;
+      return i.interrupted
+        ? "[turn stopped]"
+        : i.ended
+          ? `[turn ended early: ${i.ended.reason}]`
+          : null;
     default:
       return null;
   }

package/lib/bus/index.ts

@@ -38,6 +38,7 @@ import {
   waitBadges,
 } from "./waits/store";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
+import { groupNames } from "../session-groups/store";
 
 export * from "./format";
 export {
@@ -64,6 +65,11 @@ export interface Peer {
   // Names of the sessions it waits on, and of those waiting on it.
   waitingOn: string[];
   waitedBy: string[];
+  // The user's group it sits in, when it is in one.
+  group?: string;
+  // The agent role it was started in (lib/models/agent-roles), and its model.
+  agentRole?: string;
+  model?: string;
 }
 
 // A chat has no pane: its worker is the state, and it can always take a
@@ -99,6 +105,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
   const caller = sessionById(callerId);
   const orchestrator = heldOrchestrator(caller);
   const badges = waitBadges();
+  const groups = groupNames();
   const listed = await Promise.all(
     sessions.map(async (s, i) => {
       const info = await peerState(s);
@@ -114,6 +121,12 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         orchestratorOf: orchestratorOf(s),
         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 }),
+        ...(s.agent_role && s.model && { model: s.model }),
+        ...(s.session_group_id &&
+          groups.has(s.session_group_id) && {
+            group: groups.get(s.session_group_id),
+          }),
         ...(caller?.workspace_id &&
           s.role === "orchestrator" &&
           s.workspace_id === caller.workspace_id && { yours: true }),

package/lib/bus/read-scope.ts

@@ -4,6 +4,7 @@ import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
 import { previousNames } from "../session-names";
 import { resolveRef, type Candidate } from "./resolve";
+import { resolveRoleAlias, roleAliasOf } from "./role-alias";
 
 export type ReadableSession = Session & { project_name: string | null };
 
@@ -79,6 +80,17 @@ export function resolveReadable(callerId: string, ref: string): Readable {
     a.updated_at < b.updated_at ? 1 : -1
   );
   const mine = all.filter((s) => inScope(s, scope));
+  const alias = roleAliasOf(ref);
+  if (alias) {
+    const found = resolveRoleAlias(
+      alias,
+      mine.filter(isLive),
+      all.find((s) => s.id === callerId)
+    );
+    return found.ok
+      ? { ok: true, session: found.session }
+      : { ok: false, external: found.none, error: found.error };
+  }
   let none = "";
   for (const group of [mine.filter(isLive), mine.filter((s) => !isLive(s))]) {
     const r = resolveRef(ref, candidates(group));

package/lib/bus/role-alias.ts

@@ -0,0 +1,70 @@
+/**
+ * "@reviewer", "@developer", "@analyst", "@supervisor": the live session in
+ * that agent role. The caller's crew first, then its project; a supervisor
+ * nobody started is the workspace's orchestrator. More than one match
+ * refuses and lists them, like any other name.
+ */
+
+import type { Session } from "../db";
+
+type RoleSession = Pick<
+  Session,
+  | "id"
+  | "name"
+  | "role"
+  | "agent_role"
+  | "crew_id"
+  | "project_id"
+  | "workspace_id"
+>;
+import {
+  AGENT_ROLES,
+  isAgentRole,
+  type AgentRole,
+} from "../models/agent-roles";
+
+export type RoleAlias<T extends RoleSession = Session> =
+  { ok: true; session: T } | { ok: false; none: boolean; error: string };
+
+export const roleAliasOf = (ref: string): AgentRole | null => {
+  const m = /^@([a-z]+)$/i.exec(ref.trim());
+  const role = m?.[1].toLowerCase();
+  return isAgentRole(role) ? role : null;
+};
+
+const label = (s: RoleSession) => `${s.name} (id ${s.id.slice(0, 8)})`;
+
+export function resolveRoleAlias<T extends RoleSession>(
+  role: AgentRole,
+  sessions: T[],
+  caller: RoleSession | undefined
+): RoleAlias<T> {
+  const others = sessions.filter((s) => s.id !== caller?.id);
+  const inRole = others.filter((s) => s.agent_role === role);
+  const scopes = [
+    caller?.crew_id ? inRole.filter((s) => s.crew_id === caller.crew_id) : [],
+    caller?.project_id && caller.project_id !== "uncategorized"
+      ? inRole.filter((s) => s.project_id === caller.project_id)
+      : [],
+  ];
+  for (const found of scopes) {
+    if (found.length === 1) return { ok: true, session: found[0] };
+    if (found.length > 1)
+      return {
+        ok: false,
+        none: false,
+        error: `"@${role}" matches ${found.length} sessions: ${found.map(label).join(", ")}. Use the name or the id`,
+      };
+  }
+  if (role === "supervisor" && caller?.workspace_id) {
+    const orchestrator = others.find(
+      (s) => s.role === "orchestrator" && s.workspace_id === caller.workspace_id
+    );
+    if (orchestrator) return { ok: true, session: orchestrator };
+  }
+  return {
+    ok: false,
+    none: true,
+    error: `No ${role} is running in your crew or project. Roles: ${AGENT_ROLES.map((r) => `@${r}`).join(", ")}. Run: aos peers`,
+  };
+}

package/lib/bus/targets.ts

@@ -9,6 +9,7 @@ import { previousNames } from "../session-names";
 import { sessionWorkspace } from "../schedules/store";
 import { heldTarget } from "./held-reply";
 import { resolveRef, type Candidate } from "./resolve";
+import { resolveRoleAlias, roleAliasOf } from "./role-alias";
 
 export function liveSessions(): Session[] {
   return db
@@ -86,6 +87,8 @@ export function tryResolveTarget(
   | { ok: true; session: Session; note?: string }
   | { ok: false; none: boolean; error: string } {
   const sessions = liveSessions();
+  const alias = roleAliasOf(ref);
+  if (alias) return resolveRoleAlias(alias, sessions, sessionById(callerId));
   const own = ownOrchestrator(ref, sessions, callerId);
   if (own) return { ok: true, session: own };
   const r = resolveRef(ref, candidates(sessions));