@saadnvd1/agent-os 0.3.715 → 0.3.728

package/lib/orchestrator/loop-guard.ts

@@ -76,9 +76,10 @@ const ERROR_LINE =
   /##\[error\]|\berror\b|\bfail(ed|ure|s)?\b|AssertionError|panic:/i;
 const RUNNER_EXIT = /Process completed with exit code/;
 
-// A CI failure: the job, then its failing tests, or its first error line.
+// A failure's log (CI, or a local test run): the job or command, then its
+// failing tests, or its first error line.
 // Null when there's nothing to tell one failure from another.
-export function ciSignature(
+export function failureSignature(
   check: string | null | undefined,
   log: string | null
 ): string | null {
@@ -100,6 +101,8 @@ export function ciSignature(
   return error ? cap(`${check}: ${normalize(error)}`) : null;
 }
 
+export const ciSignature = failureSignature;
+
 // A review's blocking findings, by where they are: the reviewer words the
 // same finding differently each time, but not its file and line. A finding
 // with no place is known by the start of its summary.

package/lib/orchestrator/pr-wake.ts

@@ -42,6 +42,7 @@ import { isPaused } from "./pause";
 import { repoOf } from "./repo";
 import { untrusted, UNTRUSTED_RULE } from "./untrusted";
 import { setPr } from "../db/session-parts";
+import { liveLoopFor } from "../loops/store";
 
 export const COMMENT_WAKE_CAP = 10;
 // A first look at a PR this young takes its whole history as new.
@@ -170,6 +171,9 @@ export async function wakeTasks(
   for (const w of watched) {
     if (isPaused(workspaceId)) return;
     if (w.pr.checks !== "fail" || !w.pr.failing) continue;
+    // A running loop reads CI as part of its evidence and tells the coder
+    // in its next instruction: a task never has two steerers.
+    if (liveLoopFor(w.task.id)) continue;
     await wakeOnCheck(workspaceId, w, deps).catch((error) =>
       console.error(`Waking ${w.task.name} on CI:`, error)
     );

package/lib/orchestrator/read.ts

@@ -91,7 +91,11 @@ function itemText(i: ChatItem): string | null {
     case "error":
       return `[error] ${i.message}`;
     case "turn_end":
-      return i.interrupted ? "[turn stopped]" : "[turn ended]";
+      return i.interrupted
+        ? "[turn stopped]"
+        : i.ended
+          ? `[turn ended early: ${i.ended.reason}] ${i.ended.notice}`
+          : "[turn ended]";
     case "command_output":
       return i.text;
     case "note":

package/lib/orchestrator/untrusted.ts

@@ -31,6 +31,10 @@ export const looksRandom = (s: string) =>
 export const SECRET_ASSIGNMENT =
   /^(\s*(?:export\s+)?[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASS|PWD|CREDENTIALS?|AUTH)[A-Z0-9_]*\s*[=:]\s*).+$/gm;
 
+// The same assignment inline, ahead of a command: API_TOKEN=... npm test.
+const INLINE_ASSIGNMENT =
+  /\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASS|PWD|CREDENTIALS?|AUTH)[A-Z0-9_]*=)(?!\[redacted\])("[^"]*"|'[^']*'|\S+)/g;
+
 // A URL's userinfo (https://key@host, postgres://user:pw@host) and a query
 // parameter that carries a credential (?token=, &api_key=).
 export const URL_USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi;
@@ -47,6 +51,7 @@ const URL_PASSWORD = /\b([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)[^@\s]+@/gi;
 export function redact(text: string): string {
   let out = text
     .replace(SECRET_ASSIGNMENT, "$1[redacted]")
+    .replace(INLINE_ASSIGNMENT, "$1[redacted]")
     .replace(URL_PASSWORD, "$1[redacted]@");
   for (const p of TOKEN_PATTERNS) out = out.replace(p, "[redacted]");
   return out.replace(BASE64_RUN, (m) => (looksRandom(m) ? "[redacted]" : m));

package/lib/orchestrator/watcher.ts

@@ -26,6 +26,8 @@ import { followAskVerdicts } from "./ask-verdict";
 import { raiseHeldAsks } from "./held-asks";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
+import { tickLoops } from "../loops/tickLoops";
+import { installReportHooks } from "../reports/hooks";
 import { awayTick } from "../away/run";
 import { healthTick } from "../health/tick";
 import { observeCi } from "../health/ci";
@@ -93,7 +95,8 @@ export async function diffWorkspace(
   return nextDiffAt(now, facts, working);
 }
 
-// Wakes tasks whose PRs failed CI or got reviews, rebases what conflicts
+// Wakes tasks whose PRs failed CI or got reviews, advances developer-analyst
+// loops, rebases what conflicts
 // with its base, then merges what's armed and passes. In the background, one run per workspace at a time, so a git
 // fetch or a merge never holds up event delivery.
 const piping = new Set<string>();
@@ -105,6 +108,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await wakeTasks(workspaceId, facts).catch((error) =>
       console.error(`Waking tasks in ${workspaceId}:`, error)
     );
+    await tickLoops(workspaceId, facts).catch((error) =>
+      console.error(`Ticking loops in ${workspaceId}:`, error)
+    );
     await followAskHeads(workspaceId, facts).catch((error) =>
       console.error(`Following ask heads in ${workspaceId}:`, error)
     );
@@ -189,6 +195,7 @@ async function tick(): Promise<void> {
 }
 
 export function startOrchestratorWatcher(): void {
+  installReportHooks();
   if (timer) return;
   timer = setInterval(() => void tick(), DELIVER_EVERY_MS);
   timer.unref();

package/lib/panes.ts

@@ -208,6 +208,58 @@ export function closePane(state: PaneState, paneId: string): PaneState | null {
   };
 }
 
+export interface OpenSession {
+  sessionId: string;
+  tmux: string;
+  hostId?: string | null;
+}
+
+// Shows a session beside a pane (an analyst beside its coder): where a pane
+// already shows it, that one; else in a new pane to its right; with no room
+// for another pane, in a new tab of this one.
+export function openBeside(
+  state: PaneState,
+  paneId: string,
+  open: OpenSession
+): PaneState {
+  for (const id of getAllPaneIds(state.layout)) {
+    const pane = state.panes[id];
+    const tab = pane?.tabs.find((t) => t.sessionId === open.sessionId);
+    if (tab)
+      return {
+        ...state,
+        focusedPaneId: id,
+        panes: { ...state.panes, [id]: { ...pane, activeTabId: tab.id } },
+      };
+  }
+  const tab: TabData = {
+    ...createTab(),
+    sessionId: open.sessionId,
+    attachedTmux: open.tmux,
+    attachedHost: open.hostId ?? null,
+  };
+  const split = state.panes[paneId] && splitPane(state, paneId, "horizontal");
+  if (split)
+    return {
+      ...split,
+      panes: {
+        ...split.panes,
+        [split.focusedPaneId]: { tabs: [tab], activeTabId: tab.id },
+      },
+    };
+  const pane = state.panes[paneId] ?? state.panes[state.focusedPaneId];
+  if (!pane) return state;
+  const target = state.panes[paneId] ? paneId : state.focusedPaneId;
+  return {
+    ...state,
+    focusedPaneId: target,
+    panes: {
+      ...state.panes,
+      [target]: { tabs: [...pane.tabs, tab], activeTabId: tab.id },
+    },
+  };
+}
+
 // Get all pane IDs from layout
 export function getAllPaneIds(layout: PaneLayout): string[] {
   if (layout.type === "leaf") {

package/lib/plans/acceptance.ts

@@ -0,0 +1,23 @@
+// A plan's optional "## Acceptance" section: a checklist of observable
+// outcomes, parsed like the "## Pieces" block.
+
+const MAX_ITEMS = 12;
+const MAX_LEN = 240;
+
+export function parseAcceptance(plan: string | null | undefined): string[] {
+  if (!plan) return [];
+  const lines = plan.split("\n");
+  const start = lines.findIndex((l) => /^##\s+Acceptance\s*$/i.test(l.trim()));
+  if (start < 0) return [];
+  const items: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,6}\s/.test(line)) break;
+    const m = /^\s*[-*]\s+\[[ xX]\]\s+(.+?)\s*$/.exec(line);
+    if (!m) continue;
+    items.push(m[1].slice(0, MAX_LEN));
+    if (items.length >= MAX_ITEMS) break;
+  }
+  return items;
+}
+
+export const ACCEPTANCE_PROMPT = `Also end the plan with an \`## Acceptance\` section: 3 to 8 checklist lines (\`- [ ] ...\`), each one outcome a test, a CI check or the review could show is true. They become the progress report's completion estimate.`;

package/lib/projects.ts

@@ -294,6 +294,7 @@ export function deleteProject(id: string): boolean {
 
   // Its merge settings override (lib/tasks/merge-policy.ts)
   db.prepare(`DELETE FROM settings WHERE key = ?`).run(`merge.project.${id}`);
+  db.prepare(`DELETE FROM settings WHERE key = ?`).run(`models.project.${id}`);
 
   // Delete project
   queries.deleteProject(db).run(id);

package/lib/reports/drafts.ts

@@ -0,0 +1,87 @@
+// The drafted next prompt: approve (one click), edit-and-approve, or dismiss.
+// A task with an analyst pairing uses the analyst's own recommendation, so
+// there is one draft system; a plain task's draft lives on its report row.
+
+import { db, type Session } from "../db";
+import { deliver } from "../bus";
+import {
+  dismissRecommendation,
+  forwardToCoder,
+  sendRecommendation,
+} from "../analyst/forward";
+import { statusDetector } from "../status-detector";
+import { claimDraft, getReport, reopenDraft, setDraftText } from "./store";
+
+export class DraftError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404 | 409 = 409
+  ) {
+    super(message);
+  }
+}
+
+export const draftItemId = (reportId: number) =>
+  `user-report-draft-${reportId}`;
+
+export async function approveDraft(
+  sessionId: string,
+  input: {
+    source: "report" | "analyst";
+    id: string;
+    linkId?: string;
+    text?: string;
+  }
+): Promise<void> {
+  if (input.source === "analyst") {
+    if (!input.linkId) throw new DraftError("Missing pairing", 400);
+    await sendRecommendation(input.linkId, input.id, input.text);
+    return;
+  }
+  const reportId = Number(input.id);
+  const report = getReport(reportId);
+  if (!report || report.sessionId !== sessionId || !report.draft)
+    throw new DraftError("No such draft", 404);
+  const text = (input.text ?? report.draft.text).trim();
+  if (!text) throw new DraftError("There is no prompt to send", 400);
+  if (!claimDraft(reportId, "sent"))
+    throw new DraftError(`This draft was already ${report.draft.status}`);
+  if (input.text && text !== report.draft.text)
+    setDraftText(reportId, text, "sent");
+  try {
+    const session = db
+      .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+      .get(sessionId) as Session | undefined;
+    if (!session) throw new DraftError("No such task", 404);
+    if (session.view === "chat")
+      await forwardToCoder(sessionId, {
+        text,
+        id: draftItemId(reportId),
+        label: "Analyst",
+      });
+    else {
+      await statusDetector.refreshCache();
+      const delivery = await deliver(session, text, { name: "Analyst" });
+      if (delivery.state === "failed") throw new Error(delivery.why);
+    }
+  } catch (error) {
+    reopenDraft(reportId);
+    throw error;
+  }
+}
+
+export function dismissDraft(
+  sessionId: string,
+  input: { source: "report" | "analyst"; id: string; linkId?: string }
+): void {
+  if (input.source === "analyst") {
+    if (!input.linkId) throw new DraftError("Missing pairing", 400);
+    dismissRecommendation(input.linkId, input.id);
+    return;
+  }
+  const report = getReport(Number(input.id));
+  if (!report || report.sessionId !== sessionId || !report.draft)
+    throw new DraftError("No such draft", 404);
+  if (!claimDraft(report.id, "dismissed"))
+    throw new DraftError(`This draft was already ${report.draft.status}`);
+}

package/lib/reports/end-hook.ts

@@ -0,0 +1,17 @@
+// The task-end trigger, decoupled from the code that ends tasks: finishing a
+// task calls taskEnded(), and the report generator is plugged in at server
+// start (hooks.ts), so ending a task never reaches for gh or a model on its own.
+
+let onEnd: ((sessionId: string) => void) | null = null;
+
+export const setTaskEndHook = (fn: ((sessionId: string) => void) | null) => {
+  onEnd = fn;
+};
+
+export function taskEnded(sessionId: string): void {
+  try {
+    onEnd?.(sessionId);
+  } catch (error) {
+    console.error(`Report at the end of ${sessionId}:`, error);
+  }
+}

package/lib/reports/estimate.ts

@@ -0,0 +1,107 @@
+// The completion estimate. Computed here from evidence, never by a model:
+// the model may only propose which evidence backs an acceptance item, and
+// this decides whether the citation holds.
+
+import type { Estimate, EstimateItem, EvidenceRef } from "./types";
+
+export interface AcceptanceItem {
+  label: string;
+  // Verified by the system itself (a loop criterion met with resolved
+  // evidence), so no model mapping is needed.
+  evidence?: string[];
+}
+
+export interface Stages {
+  planned: boolean;
+  pushed: boolean;
+  prOpen: boolean;
+  ciGreen: boolean;
+  reviewed: boolean;
+  merged: boolean;
+}
+
+export const STAGE_COUNT = 6;
+
+// Diff, piece and log evidence is true of the work, not of one head.
+const HEAD_FREE = new Set(["diff", "piece", "log", "accept", "state"]);
+// A diff alone never verifies: a file changed shows nothing works.
+const PROVING = new Set(["test", "ci", "review", "piece", "accept"]);
+
+export interface Mapping {
+  item: number;
+  evidence: string[];
+}
+
+function holds(
+  ids: string[],
+  evidence: Map<string, EvidenceRef>,
+  head: string | null
+): boolean {
+  if (!ids.length) return false;
+  const cited: EvidenceRef[] = [];
+  for (const id of ids) {
+    const ev = evidence.get(id);
+    if (!ev || ev.status !== "pass") return false;
+    if (!HEAD_FREE.has(ev.kind) && head && ev.sha && ev.sha !== head)
+      return false;
+    cited.push(ev);
+  }
+  if (!cited.some((e) => PROVING.has(e.kind))) return false;
+  const kinds = new Set(cited.map((e) => e.kind));
+  for (const e of evidence.values())
+    if (
+      e.status === "fail" &&
+      kinds.has(e.kind) &&
+      (HEAD_FREE.has(e.kind) || !head || !e.sha || e.sha === head)
+    )
+      return false;
+  return true;
+}
+
+export function computeEstimate(input: {
+  head: string | null;
+  evidence: EvidenceRef[];
+  items: AcceptanceItem[];
+  mappings: Mapping[];
+  stages: Stages;
+}): Estimate {
+  const byId = new Map(input.evidence.map((e) => [e.id, e]));
+  if (input.items.length) {
+    const items: EstimateItem[] = input.items.map((it, i) => {
+      const own = it.evidence ?? [];
+      if (own.length && holds(own, byId, input.head))
+        return { label: it.label, verified: true, evidence: own };
+      const mapped = input.mappings
+        .filter((m) => m.item === i)
+        .flatMap((m) => m.evidence);
+      const ids = [...new Set(mapped)];
+      const ok = holds(ids, byId, input.head);
+      return { label: it.label, verified: ok, evidence: ok ? ids : [] };
+    });
+    return {
+      done: items.filter((i) => i.verified).length,
+      total: items.length,
+      basis: "acceptance",
+      items,
+    };
+  }
+  const s = input.stages;
+  const list: [string, boolean][] = [
+    ["Plan approved", s.planned],
+    ["Code pushed", s.pushed],
+    ["Pull request open", s.prOpen],
+    ["CI green on the latest push", s.ciGreen],
+    ["Review passed", s.reviewed],
+    ["Merged", s.merged],
+  ];
+  return {
+    done: list.filter(([, ok]) => ok).length,
+    total: STAGE_COUNT,
+    basis: "stages",
+    items: list.map(([label, verified]) => ({
+      label,
+      verified,
+      evidence: [],
+    })),
+  };
+}

package/lib/reports/evidence/build.ts

@@ -0,0 +1,193 @@
+// Evidence items from what was read. Pure: the collectors in gather.ts do the
+// reading, so these are tested with fixtures.
+
+import type { TaskCheck, TaskReviewVerdict } from "../../tasks/loop-types";
+import type { TaskState } from "../../tasks/state";
+import type { DigestSignals } from "../../analyst/types";
+import { latestChecks } from "../../analyst/signals";
+import type { EvidenceRef } from "../types";
+
+const EXCERPT = 1500;
+const cap = (s: string, n = EXCERPT) =>
+  s.length > n ? `${s.slice(0, n)}…` : s;
+
+export function ciEvidence(
+  checks: TaskCheck[],
+  head: string | null,
+  at: string
+): EvidenceRef[] {
+  return checks
+    .filter((c) => c.state !== "skipped" && c.state !== "neutral")
+    .slice(0, 30)
+    .map((c) => ({
+      id: `ci:${c.name}`,
+      kind: "ci",
+      label: `CI · ${c.name}`,
+      status:
+        c.state === "pass"
+          ? "pass"
+          : c.state === "pending"
+            ? "pending"
+            : "fail",
+      at: c.completedAt ?? at,
+      sha: head ?? undefined,
+      url: c.url ?? undefined,
+      excerpt: c.log
+        ? cap(`${c.log.step ?? ""}\n${c.log.tail}`.trim())
+        : undefined,
+    }));
+}
+
+export function reviewEvidence(
+  review: TaskReviewVerdict | null
+): EvidenceRef[] {
+  if (!review) return [];
+  const findings = review.findings
+    .map(
+      (f) =>
+        `[${f.severity}] ${f.file ?? ""}${f.line ? `:${f.line}` : ""} ${f.summary}`
+    )
+    .join("\n");
+  return [
+    {
+      id: `review:${review.sha.slice(0, 7)}`,
+      kind: "review",
+      label: "Independent review",
+      status:
+        review.status === "pass"
+          ? "pass"
+          : review.status === "running"
+            ? "pending"
+            : "fail",
+      at: review.at,
+      sha: review.sha,
+      excerpt: cap(`${review.summary}\n${findings}`.trim()),
+    },
+  ];
+}
+
+// The last run of each test, build, typecheck or lint command.
+export function testEvidence(
+  signals: DigestSignals,
+  sessionId: string,
+  head: string | null,
+  at: string
+): EvidenceRef[] {
+  return latestChecks(signals)
+    .slice(0, 12)
+    .map((c, i) => ({
+      id: `test:${i + 1}`,
+      kind: "test",
+      label: c.command.slice(0, 120),
+      status: c.passed ? "pass" : "fail",
+      at,
+      sha: head ?? undefined,
+      href: `/?session=${sessionId}`,
+    }));
+}
+
+export function diffEvidence(
+  numstat: string,
+  sessionId: string,
+  at: string
+): EvidenceRef[] {
+  const out: EvidenceRef[] = [];
+  for (const line of numstat.split("\n")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line);
+    if (!m) continue;
+    out.push({
+      id: `diff:${m[3]}`,
+      kind: "diff",
+      label: `${m[3]} (+${m[1] === "-" ? 0 : m[1]} −${m[2] === "-" ? 0 : m[2]})`,
+      status: "info",
+      at,
+      href: `/?session=${sessionId}`,
+    });
+    if (out.length >= 40) break;
+  }
+  return out;
+}
+
+export function stateEvidence(
+  state: TaskState,
+  blocked: string | null,
+  at: string
+): EvidenceRef {
+  return {
+    id: "state:task",
+    kind: "state",
+    label: `Task state: ${state}`,
+    status: state === "checks-failing" || state === "blocked" ? "fail" : "info",
+    at,
+    excerpt: blocked ? cap(blocked) : undefined,
+  };
+}
+
+export function askEvidence(
+  asks: { id: number; title: string; detail: string; created_at: string }[]
+): EvidenceRef[] {
+  return asks.slice(0, 5).map((a) => ({
+    id: `ask:${a.id}`,
+    kind: "ask",
+    label: `Waiting on you: ${a.title}`,
+    status: "pending",
+    at: a.created_at,
+    excerpt: cap(a.detail),
+  }));
+}
+
+export function acceptEvidence(
+  items: { label: string; met: boolean; note?: string }[],
+  at: string
+): EvidenceRef[] {
+  return items.map((it, i) => ({
+    id: `accept:${i + 1}`,
+    kind: "accept",
+    label: it.label,
+    status: it.met ? "pass" : "pending",
+    at,
+    excerpt: it.note ? cap(it.note) : undefined,
+  }));
+}
+
+export function logEvidence(log: {
+  sessionId: string;
+  mergeCommit: string | null;
+  prNumber: number | null;
+  durationMs: number | null;
+  costUsd: number;
+  createdAt: string;
+}): EvidenceRef {
+  const mins =
+    log.durationMs !== null
+      ? Math.max(1, Math.round(log.durationMs / 60000))
+      : null;
+  return {
+    id: "log:task",
+    kind: "log",
+    label: [
+      log.prNumber ? `Merged as pull request ${log.prNumber}` : "Task log",
+      mins ? `in ${mins} min` : "",
+    ]
+      .filter(Boolean)
+      .join(" "),
+    status: "pass",
+    at: log.createdAt,
+    excerpt: log.mergeCommit ? `Merge commit ${log.mergeCommit}` : undefined,
+    href: `/?session=${log.sessionId}`,
+  };
+}
+
+// FNV-1a over ids and statuses: times and excerpts don't change it.
+export function evidenceHash(evidence: EvidenceRef[], head: string | null) {
+  let h = 2166136261;
+  const s = `${head ?? ""}|${evidence
+    .map((e) => `${e.id}:${e.status}`)
+    .sort()
+    .join(",")}`;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}