@saadnvd1/agent-os 0.3.723 → 0.3.731

package/lib/reports/store.ts

@@ -0,0 +1,180 @@
+import { db } from "../db";
+import type {
+  DraftStatus,
+  HealthReport,
+  ReportSummary,
+  ReportTrigger,
+} from "./types";
+
+interface Row {
+  id: number;
+  session_id: string;
+  workspace_id: string | null;
+  head: string | null;
+  trigger: ReportTrigger;
+  evidence_hash: string;
+  data: string;
+  model: string | null;
+  cost_usd: number | null;
+  draft_text: string | null;
+  draft_status: DraftStatus | null;
+  created_at: string;
+}
+
+// What is stored in `data`: the report without what the row itself holds.
+type Stored = Omit<
+  HealthReport,
+  "id" | "sessionId" | "workspaceId" | "createdAt" | "stale" | "draft"
+> & { draft: HealthReport["draft"] };
+
+export function insertReport(
+  r: Omit<HealthReport, "id" | "createdAt" | "stale">,
+  hash: string
+): number {
+  const { id: _i, sessionId, workspaceId, ...rest } = r as HealthReport;
+  void _i;
+  const draft = r.draft?.source === "report" ? r.draft : null;
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'superseded'
+      WHERE session_id = ? AND draft_status = 'pending'`
+  ).run(sessionId);
+  const info = db
+    .prepare(
+      `INSERT INTO health_reports (session_id, workspace_id, head, trigger, evidence_hash, data, model, cost_usd, draft_text, draft_status)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    )
+    .run(
+      sessionId,
+      workspaceId,
+      r.head,
+      r.trigger,
+      hash,
+      JSON.stringify({ ...rest, draft: null } satisfies Stored),
+      r.model,
+      r.costUsd,
+      draft?.text ?? null,
+      draft ? "pending" : null
+    );
+  return Number(info.lastInsertRowid);
+}
+
+function toReport(row: Row, head: string | null | undefined): HealthReport {
+  const data = JSON.parse(row.data) as Stored;
+  return {
+    ...data,
+    id: row.id,
+    sessionId: row.session_id,
+    workspaceId: row.workspace_id,
+    createdAt: row.created_at,
+    draft: row.draft_text
+      ? {
+          source: "report",
+          id: String(row.id),
+          text: row.draft_text,
+          status: row.draft_status ?? "pending",
+        }
+      : null,
+    stale: head !== undefined && head !== row.head,
+  };
+}
+
+// `head` is the task's current head, to mark an older report stale.
+export function latestReport(
+  sessionId: string,
+  head?: string | null
+): HealthReport | null {
+  const row = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as Row | undefined;
+  return row ? toReport(row, head) : null;
+}
+
+export function getReport(id: number): HealthReport | null {
+  const row = db
+    .prepare(`SELECT * FROM health_reports WHERE id = ?`)
+    .get(id) as Row | undefined;
+  return row ? toReport(row, undefined) : null;
+}
+
+export function hashOfLatest(sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT evidence_hash FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as { evidence_hash: string } | undefined;
+  return row?.evidence_hash ?? null;
+}
+
+// Claimed first, so a double tap sends once.
+export function claimDraft(
+  reportId: number,
+  to: Exclude<DraftStatus, "pending">
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE health_reports SET draft_status = ?, draft_decided_at = datetime('now')
+          WHERE id = ? AND draft_status = 'pending'`
+      )
+      .run(to, reportId).changes === 1
+  );
+}
+
+export function reopenDraft(reportId: number): void {
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'pending', draft_decided_at = NULL
+      WHERE id = ? AND draft_status = 'sent'`
+  ).run(reportId);
+}
+
+export function setDraftText(
+  reportId: number,
+  text: string,
+  status: DraftStatus
+) {
+  db.prepare(
+    `UPDATE health_reports SET draft_text = ?, draft_status = ? WHERE id = ?`
+  ).run(text, status, reportId);
+}
+
+export function historyOf(sessionId: string, limit = 20): ReportSummary[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(sessionId, limit) as Row[];
+  return rows.map((r) => summaryOf(toReport(r, undefined), ""));
+}
+
+export function summaryOf(r: HealthReport, name: string): ReportSummary {
+  return {
+    sessionId: r.sessionId,
+    name,
+    headline: r.headline,
+    state: r.state,
+    estimate: {
+      done: r.estimate.done,
+      total: r.estimate.total,
+      basis: r.estimate.basis,
+    },
+    createdAt: r.createdAt,
+  };
+}
+
+// The newest report of each task in a workspace.
+export function latestByTask(
+  workspaceId: string
+): { report: HealthReport; name: string }[] {
+  const rows = db
+    .prepare(
+      `SELECT h.*, s.name AS name FROM health_reports h
+         JOIN session_rows s ON s.id = h.session_id
+        WHERE h.workspace_id = ?
+          AND h.id = (SELECT MAX(id) FROM health_reports WHERE session_id = h.session_id)
+        ORDER BY h.id DESC LIMIT 100`
+    )
+    .all(workspaceId) as (Row & { name: string })[];
+  return rows.map((r) => ({ report: toReport(r, undefined), name: r.name }));
+}

package/lib/reports/template.ts

@@ -0,0 +1,117 @@
+// The report with no model: sentences built from the same evidence. Used when
+// the model fails or every line it wrote was rejected, and for the headline.
+
+import type { TaskState } from "../tasks/state";
+import type { EvidenceRef, ReportLine } from "./types";
+
+const HEADLINES: Record<TaskState, string> = {
+  working: "The agent is working on it",
+  "needs-input": "The agent is waiting for an answer",
+  blocked: "The task is blocked and needs a decision",
+  review: "The pull request is open and waiting on review",
+  "checks-failing": "Checks are failing on the latest push",
+  "plan-ready": "The plan is written and waits for your approval",
+  exited: "The agent stopped before finishing",
+  merged: "The work is merged",
+  dropped: "The task was dropped",
+  done: "The task is finished",
+  moving: "The task is moving to another machine",
+};
+
+export const headlineFor = (state: TaskState) => HEADLINES[state];
+
+const NEXT: Partial<Record<TaskState, string>> = {
+  "checks-failing": "Next: fix the failing checks, then push again.",
+  review: "Next: wait for the review and the checks to settle, then merge.",
+  blocked: "Next: answer what the task is waiting on.",
+  "needs-input": "Next: reply to the agent so it can go on.",
+  "plan-ready": "Next: read the plan and approve it.",
+  exited: "Next: restart the agent or take the work over.",
+  working: "Next: let the agent finish its turn.",
+};
+
+export function templateLines(
+  state: TaskState,
+  evidence: EvidenceRef[]
+): {
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+} {
+  const lines: ReportLine[] = [];
+  const add = (tone: ReportLine["tone"], text: string, ev: EvidenceRef[]) =>
+    lines.push({
+      id: `l${lines.length + 1}`,
+      tone,
+      text,
+      evidence: ev.map((e) => e.id),
+    });
+  const of = (kind: EvidenceRef["kind"]) =>
+    evidence.filter((e) => e.kind === kind);
+
+  const ci = of("ci");
+  const ciPass = ci.filter((e) => e.status === "pass");
+  const ciFail = ci.filter((e) => e.status === "fail");
+  const ciWait = ci.filter((e) => e.status === "pending");
+  if (ciPass.length)
+    add(
+      "done",
+      `${ciPass.length} CI check${ciPass.length === 1 ? "" : "s"} passed.`,
+      ciPass
+    );
+  for (const e of ciFail) add("warn", `${e.label} is failing.`, [e]);
+  if (ciWait.length)
+    add(
+      "warn",
+      `${ciWait.length} CI check${ciWait.length === 1 ? " is" : "s are"} still running.`,
+      ciWait
+    );
+
+  for (const e of of("test"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? `Tests passed: ${e.label}.`
+        : e.status === "fail"
+          ? `Tests failed: ${e.label}.`
+          : `Tests are running: ${e.label}.`,
+      [e]
+    );
+
+  for (const e of of("review"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? "The independent review passed."
+        : e.status === "fail"
+          ? "The independent review found problems to fix."
+          : "The independent review has not finished.",
+      [e]
+    );
+
+  for (const e of of("piece"))
+    add(e.status === "pass" ? "done" : "next", `${e.label}.`, [e]);
+  for (const e of of("accept").filter((e) => e.status === "pass"))
+    add("done", `Verified: ${e.label}.`, [e]);
+  for (const e of of("ask")) add("blocked", `${e.label}.`, [e]);
+  for (const e of of("log")) add("done", `${e.label}.`, [e]);
+
+  const hasDiff = of("diff");
+  if (hasDiff.length)
+    add(
+      "done",
+      `${hasDiff.length} file${hasDiff.length === 1 ? "" : "s"} changed.`,
+      hasDiff.slice(0, 12)
+    );
+
+  const stateEv = of("state");
+  if (NEXT[state] && stateEv.length) add("next", NEXT[state]!, stateEv);
+
+  const bad = [...ciFail, ...of("test").filter((e) => e.status === "fail")];
+  const recommendation = bad.length
+    ? {
+        text: `Ask the agent to fix ${bad[0].label} first; everything else waits on it.`,
+        evidence: [bad[0].id],
+      }
+    : null;
+  return { lines, recommendation };
+}

package/lib/reports/types.ts

@@ -0,0 +1,135 @@
+// Plain-English health reports: types shared by the server, the browser and
+// the native app (no Node modules here).
+
+import type { TaskState } from "../tasks/state";
+
+export const OPERATING_MODES = ["manual", "assisted", "autonomous"] as const;
+export type OperatingMode = (typeof OPERATING_MODES)[number];
+export const isMode = (v: unknown): v is OperatingMode =>
+  typeof v === "string" && (OPERATING_MODES as readonly string[]).includes(v);
+
+export const MODE_COPY: Record<
+  OperatingMode,
+  { label: string; blurb: string }
+> = {
+  manual: {
+    label: "Manual",
+    blurb: "The analyst recommends, you decide.",
+  },
+  assisted: {
+    label: "Assisted",
+    blurb: "The analyst drafts the next prompt, you approve it with one click.",
+  },
+  autonomous: {
+    label: "Autonomous",
+    blurb: "Agents iterate on their own, within the loop's safeguards.",
+  },
+};
+
+export type ReportTrigger = "on-demand" | "cycle" | "end";
+export type LineTone = "done" | "warn" | "blocked" | "next";
+export type EvidenceKind =
+  | "ci"
+  | "test"
+  | "review"
+  | "diff"
+  | "piece"
+  | "accept"
+  | "ask"
+  | "state"
+  | "log";
+export type EvidenceStatus = "pass" | "fail" | "pending" | "info";
+
+export interface EvidenceRef {
+  id: string;
+  kind: EvidenceKind;
+  label: string;
+  status: EvidenceStatus;
+  at: string;
+  // The head it belongs to; stale when it differs from the current head.
+  sha?: string;
+  url?: string;
+  href?: string;
+  excerpt?: string;
+}
+
+export interface ReportLine {
+  id: string;
+  tone: LineTone;
+  text: string;
+  evidence: string[];
+}
+
+export interface EstimateItem {
+  label: string;
+  verified: boolean;
+  evidence: string[];
+}
+
+export interface Estimate {
+  done: number;
+  total: number;
+  basis: "acceptance" | "stages";
+  items: EstimateItem[];
+}
+
+export type DraftStatus = "pending" | "sent" | "dismissed" | "superseded";
+
+export interface NextPromptDraft {
+  // The report row that holds it, or the analyst recommendation.
+  source: "report" | "analyst";
+  id: string;
+  text: string;
+  status: DraftStatus;
+  // Analyst drafts send through the analyst link.
+  linkId?: string;
+}
+
+export interface HealthReport {
+  id: number;
+  sessionId: string;
+  workspaceId: string | null;
+  head: string | null;
+  trigger: ReportTrigger;
+  createdAt: string;
+  headline: string;
+  state: TaskState;
+  estimate: Estimate;
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+  draft: NextPromptDraft | null;
+  evidence: EvidenceRef[];
+  // "template": the model failed, or every line it wrote was rejected.
+  source: "model" | "template";
+  // Model lines the validator rejected.
+  dropped: number;
+  model: string | null;
+  costUsd: number | null;
+  // Computed on read: the head moved since.
+  stale: boolean;
+}
+
+export interface ReportSummary {
+  sessionId: string;
+  name: string;
+  headline: string;
+  state: TaskState;
+  estimate: Pick<Estimate, "done" | "total" | "basis">;
+  createdAt: string;
+}
+
+export interface ReportResponse {
+  report: HealthReport | null;
+  generating: boolean;
+  mode: { mode: OperatingMode; source: "task" | "workspace" | "default" };
+}
+
+export const estimateLabel = (e: Pick<Estimate, "done" | "total" | "basis">) =>
+  `Estimate · ${e.done} of ${e.total} ${
+    e.basis === "acceptance"
+      ? "acceptance items verified"
+      : "delivery stages reached"
+  }`;
+
+export const estimatePercent = (e: Pick<Estimate, "done" | "total">) =>
+  e.total ? Math.round((100 * e.done) / e.total) : 0;

package/lib/reports/validate.ts

@@ -0,0 +1,142 @@
+// What a model may say in a report. Every line must cite evidence that
+// exists, say only numbers that evidence contains, never use a percent sign,
+// and take a tone its evidence supports. What fails is dropped and counted.
+
+import type { EvidenceRef, LineTone, ReportLine } from "./types";
+import type { Mapping } from "./estimate";
+
+export interface ModelReport {
+  headline?: unknown;
+  lines?: unknown;
+  recommendation?: unknown;
+  acceptance?: unknown;
+  nextPrompt?: unknown;
+}
+
+export interface Validated {
+  headline: string | null;
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+  mappings: Mapping[];
+  nextPrompt: string | null;
+  dropped: number;
+}
+
+export const MAX_LINE = 280;
+export const MAX_LINES = 10;
+export const MAX_PROMPT = 4000;
+const TONES: LineTone[] = ["done", "warn", "blocked", "next"];
+
+const str = (v: unknown, max: number) =>
+  typeof v === "string" ? v.trim().slice(0, max) : "";
+const ids = (v: unknown): string[] =>
+  Array.isArray(v)
+    ? [...new Set(v.filter((x): x is string => typeof x === "string"))]
+    : [];
+
+// Digits in the text that none of the cited evidence contains.
+function inventedNumber(text: string, cited: EvidenceRef[]): boolean {
+  const nums = text.match(/\d+/g);
+  if (!nums) return false;
+  const haystack = cited
+    .map((e) => `${e.id} ${e.label} ${e.excerpt ?? ""} ${e.sha ?? ""}`)
+    .join("\n");
+  return nums.some((n) => !new RegExp(`(?<!\\d)${n}(?!\\d)`).test(haystack));
+}
+
+export function sayable(text: string, cited: EvidenceRef[]): boolean {
+  return (
+    !!text &&
+    text.length <= MAX_LINE &&
+    !/%/.test(text) &&
+    !inventedNumber(text, cited)
+  );
+}
+
+function toneFits(tone: LineTone, cited: EvidenceRef[]): boolean {
+  if (tone === "done") return cited.some((e) => e.status === "pass");
+  if (tone === "warn" || tone === "blocked")
+    return cited.some(
+      (e) => e.status === "fail" || e.status === "pending" || e.kind === "ask"
+    );
+  return true;
+}
+
+export function validateModelReport(
+  raw: unknown,
+  evidence: EvidenceRef[]
+): Validated {
+  const out: Validated = {
+    headline: null,
+    lines: [],
+    recommendation: null,
+    mappings: [],
+    nextPrompt: null,
+    dropped: 0,
+  };
+  if (!raw || typeof raw !== "object") return out;
+  const m = raw as ModelReport;
+  const byId = new Map(evidence.map((e) => [e.id, e]));
+  const resolve = (cites: string[]) => {
+    const found = cites.map((c) => byId.get(c));
+    return found.some((e) => !e) ? null : (found as EvidenceRef[]);
+  };
+
+  const headline = str(m.headline, MAX_LINE);
+  if (
+    headline &&
+    sayable(
+      headline,
+      evidence.filter((e) => e.kind === "state")
+    )
+  )
+    out.headline = headline;
+  else if (headline) out.dropped++;
+
+  const rawLines = Array.isArray(m.lines) ? m.lines.slice(0, 24) : [];
+  for (const l of rawLines) {
+    const o = (l ?? {}) as Record<string, unknown>;
+    const tone = o.tone as LineTone;
+    const text = str(o.text, MAX_LINE + 1);
+    const cites = ids(o.evidence);
+    const cited = cites.length ? resolve(cites) : null;
+    if (
+      !TONES.includes(tone) ||
+      !cited ||
+      !sayable(text, cited) ||
+      !toneFits(tone, cited) ||
+      out.lines.length >= MAX_LINES
+    ) {
+      out.dropped++;
+      continue;
+    }
+    out.lines.push({
+      id: `l${out.lines.length + 1}`,
+      tone,
+      text,
+      evidence: cites,
+    });
+  }
+
+  if (m.recommendation && typeof m.recommendation === "object") {
+    const r = m.recommendation as Record<string, unknown>;
+    const text = str(r.text, 600);
+    const cites = ids(r.evidence);
+    const cited = cites.length ? resolve(cites) : null;
+    if (text && cited && !/%/.test(text) && !inventedNumber(text, cited))
+      out.recommendation = { text, evidence: cites };
+    else out.dropped++;
+  }
+
+  if (Array.isArray(m.acceptance))
+    for (const a of m.acceptance.slice(0, 24)) {
+      const o = (a ?? {}) as Record<string, unknown>;
+      // The model sees items numbered from 1, as in "accept:1".
+      if (typeof o.item === "number" && Number.isInteger(o.item) && o.item >= 1)
+        out.mappings.push({ item: o.item - 1, evidence: ids(o.evidence) });
+    }
+
+  const prompt = str(m.nextPrompt, MAX_PROMPT);
+  if (prompt) out.nextPrompt = prompt;
+  return out;
+}

package/lib/sidebar/groupDrop.ts

@@ -0,0 +1,36 @@
+// Drag a session onto a group to file it there, or onto the list outside any
+// group to take it out. Pure, so the rules are testable without a DOM.
+
+export type DraggedSession = {
+  id: string;
+  groupId: string | null;
+  // The session's workspace, by the same rule the server files by.
+  workspaceId: string | null;
+};
+
+export type DropTarget = { groupId: string; workspaceId: string | null };
+
+// What a drop should do: the group to file into (null = out of any group), or
+// null when nothing should happen. A group of another workspace never takes
+// the session (the server refuses it too); dropping on its own group, or an
+// ungrouped session outside any group, changes nothing.
+export function dropOutcome(
+  dragged: DraggedSession,
+  target: DropTarget | null
+): { groupId: string | null } | null {
+  if (!target) return dragged.groupId ? { groupId: null } : null;
+  if ((target.workspaceId ?? null) !== (dragged.workspaceId ?? null))
+    return null;
+  return target.groupId === dragged.groupId
+    ? null
+    : { groupId: target.groupId };
+}
+
+export const DRAG_TYPE = "application/x-agentos-session";
+
+// dragover can't read the payload, so the one drag in flight is kept here.
+let current: DraggedSession | null = null;
+export const dragging = () => current;
+export const setDragging = (d: DraggedSession | null) => {
+  current = d;
+};

package/lib/sidebar/row-menu.ts

@@ -23,6 +23,7 @@ export type RowMenuItem =
   | "move-machine"
   | "move-project"
   | "move-group"
+  | "add-analyst"
   | "check-ins"
   | "save-recipe"
   | "run-again"
@@ -55,6 +56,7 @@ export interface RowMenuInput {
     | "has_brief"
     | "archived_at"
     | "pause_state"
+    | "agent_role"
   >;
   row?: Pick<SidebarRow, "task" | "wakesAt" | "settled">;
   // A linked machine runs it: what can't reach it yet is left out.
@@ -142,6 +144,13 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
       agentRow && "move-group",
     ]),
     ...group("automate", [
+      // A local chat can have an analyst review its turns; not an analyst.
+      s.view === "chat" &&
+        agentRow &&
+        live &&
+        !s.archived_at &&
+        s.agent_role !== "analyst" &&
+        "add-analyst",
       input.hasWorkspace &&
         !orchestrator &&
         (!s.task_status || s.task_status === "running") &&

package/lib/tasks/contract/routes.ts

@@ -3,6 +3,11 @@
 export const taskPath = (id: string, leaf: string) =>
   `/api/tasks/${encodeURIComponent(id)}/${leaf}`;
 
+// The loop's routes are the task's own: GET/POST/PATCH on `loop`, and the
+// leaves stop, run and next beside it (lib/loops/route.ts).
+export const loopPath = (id: string, leaf = "") =>
+  taskPath(id, leaf ? `loop/${leaf}` : "loop");
+
 export const LIST = "/api/tasks";
 export const IMPORT = "/api/tasks/import";
 export const HELD_REPLIES = "/api/tasks/held-replies";

package/lib/tasks/contract/types.ts

@@ -27,6 +27,9 @@ export const TASK_CAPABILITIES = [
   // compat: the shims marked "task-contract-1" in contract/ go once every
   // linked machine reports this.
   "task-contract-1",
+  // A task's developer-analyst loop: /api/tasks/:id/loop and its leaves
+  // (lib/loops). A task started on a linked machine is looped from there.
+  "task-loop-1",
 ] as const;
 
 export interface HostTasks {

package/lib/tasks/finish.ts

@@ -36,6 +36,7 @@ import {
 } from "./session";
 import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { captureMergedTask } from "../session-logs";
+import { taskEnded } from "../reports/end-hook";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
 import { keepSessionFiles } from "../session-artifacts/collect";
@@ -202,6 +203,7 @@ export async function signOffTask(
   pushMerged(id);
   // Reads the plan file now: cleanup below removes the worktree.
   void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
+  taskEnded(id);
   void sessionEnded(id, "merged");
   const head = opts.head ?? pr!.head;
   resolveMergedTaskAsks(

package/lib/tasks/move-carry.ts

@@ -27,6 +27,7 @@ export const REKEYED = [
   ["check_runs", "session_id", "id"],
   ["away_actions", "subject", "task"],
   ["task_queue", "after_task", "id"],
+  ["task_loops", "session_id", "id"],
 ] as const;
 
 // Session-keyed columns that stay on the old id, and why.