@saadnvd1/agent-os 0.3.637 → 0.3.644

package/lib/health/facts.ts

@@ -123,7 +123,7 @@ function armed(): ArmedFact[] {
     db
       .prepare(
         `SELECT s.id, s.name, s.merge_armed_at, s.pr_number, p.workspace_id
-         FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+         FROM session_rows s LEFT JOIN projects p ON p.id = s.project_id
          WHERE s.merge_armed_at IS NOT NULL AND s.archived_at IS NULL
            AND COALESCE(s.task_status, 'running') = 'running'`
       )

package/lib/health/pieces.ts

@@ -39,7 +39,7 @@ export function mergedSince(
   return (
     db
       .prepare(
-        `SELECT id, name, pr_number, task_prompt, updated_at FROM sessions
+        `SELECT id, name, pr_number, task_prompt, updated_at FROM session_rows
          WHERE project_id = ? AND task_status = 'merged'
            AND updated_at >= datetime(?)`
       )

package/lib/hosts/peer-actions.ts

@@ -15,7 +15,7 @@ import { isValidTmuxName } from "./attach";
 import { homeRelative } from "./discover";
 import { toPeerSession } from "./peer-sessions";
 import { insertMirror } from "./peer-sync";
-import { hostTasks, postIdempotent } from "../tasks/remote";
+import { list as hostTasks, postIdempotent } from "../tasks/contract/client";
 import type { ProjectRef } from "../tasks/project-ref";
 import {
   HostApiError,
@@ -83,7 +83,7 @@ const path = (id: string, rest = "") =>
   `/api/sessions/${encodeURIComponent(id)}${rest}`;
 
 const row = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as Session;
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as Session;
 
 export async function renameOnPeer(
   link: HostLink,

package/lib/hosts/peer-mirror.ts

@@ -16,7 +16,7 @@ export async function mirrorPeerSession(
   sessionId: string
 ): Promise<Session> {
   const existing = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(sessionId) as Session | undefined;
   if (existing) {
     if (existing.host_id !== hostId)
@@ -43,6 +43,6 @@ export async function mirrorPeerSession(
     )
   );
   return db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(peer.id) as Session;
 }

package/lib/hosts/peer-sync.ts

@@ -6,37 +6,45 @@
  * go there (peer-actions.ts).
  */
 
-import { db, queries, type Project } from "../db";
+import { db, queries, type Project, type Session } from "../db";
 import { isValidAgentType } from "../providers";
 import { projectMatcher } from "./discover";
 import type { PeerSession } from "./peer-sessions";
+import { setPlacement, setPr } from "../db/session-parts";
 
 export function insertMirror(
   peer: PeerSession,
   projectId: string | null
 ): void {
-  db.prepare(
-    `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
-       agent_type, project_id, host_id, view, name_source, pr_url, pr_number,
-       pr_status, updated_at, peer_mirror)
-     VALUES (?, ?, ?, ?, ?, 'sessions', ?, ?, ?, ?, 'user', ?, ?, ?,
-       COALESCE(?, datetime('now')), 1)
-     ON CONFLICT(id) DO NOTHING`
-  ).run(
-    peer.id,
-    peer.name,
-    peer.tmuxName || `${peer.agentType}-${peer.id}`,
-    peer.path || "~",
-    peer.model,
-    isValidAgentType(peer.agentType) ? peer.agentType : "shell",
-    projectId,
-    peer.hostId,
-    peer.view,
-    peer.prUrl,
-    peer.prNumber,
-    peer.prStatus,
-    peer.updatedAt
-  );
+  db.transaction(() => {
+    const inserted = db
+      .prepare(
+        `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
+           agent_type, project_id, host_id, view, name_source, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'sessions', ?, ?, ?, ?, 'user',
+           COALESCE(?, datetime('now')))
+         ON CONFLICT(id) DO NOTHING`
+      )
+      .run(
+        peer.id,
+        peer.name,
+        peer.tmuxName || `${peer.agentType}-${peer.id}`,
+        peer.path || "~",
+        peer.model,
+        isValidAgentType(peer.agentType) ? peer.agentType : "shell",
+        projectId,
+        peer.hostId,
+        peer.view,
+        peer.updatedAt
+      );
+    if (!inserted.changes) return;
+    setPr(db, peer.id, {
+      pr_url: peer.prUrl,
+      pr_number: peer.prNumber,
+      pr_status: peer.prStatus as Session["pr_status"],
+    });
+    setPlacement(db, peer.id, { peer_mirror: 1 });
+  })();
 }
 
 // One listing mirrors at most this many: a listing is another machine's
@@ -71,17 +79,46 @@ export function syncPeerMirrors(
   );
   // That machine lists the id, so it's its session: a row mirrored on open
   // before this column existed is marked too.
-  const update = db.prepare(
+  const current = db.prepare(
+    `SELECT name, view, tmux_name, project_id, pr_url, pr_number, pr_status,
+       updated_at, peer_mirror
+       FROM session_rows WHERE id = ? AND host_id = ? AND task_prompt IS NULL`
+  );
+  const touch = db.prepare(
     `UPDATE sessions SET name = ?, view = ?, tmux_name = ?, project_id = ?,
-       pr_url = ?, pr_number = ?, pr_status = ?,
-       updated_at = COALESCE(?, updated_at), peer_mirror = 1
-     WHERE id = ? AND host_id = ? AND task_prompt IS NULL
-       AND NOT (name IS ? AND view IS ? AND tmux_name IS ? AND project_id IS ?
-         AND pr_url IS ? AND pr_number IS ? AND pr_status IS ?
-         AND updated_at IS COALESCE(?, updated_at) AND peer_mirror = 1)`
+       updated_at = COALESCE(?, updated_at) WHERE id = ?`
   );
+  const update = (
+    peer: PeerSession,
+    fields: (string | number | null)[]
+  ): void => {
+    const [name, view, tmuxName, projectId, prUrl, prNumber, prStatus, at] =
+      fields;
+    const cur = current.get(peer.id, hostId) as
+      | Record<string, string | number | null>
+      | undefined;
+    if (!cur) return;
+    const same =
+      cur.name === name &&
+      cur.view === view &&
+      cur.tmux_name === tmuxName &&
+      cur.project_id === projectId &&
+      cur.pr_url === prUrl &&
+      cur.pr_number === prNumber &&
+      cur.pr_status === prStatus &&
+      cur.updated_at === (at ?? cur.updated_at) &&
+      cur.peer_mirror === 1;
+    if (same) return;
+    touch.run(name, view, tmuxName, projectId, at, peer.id);
+    setPr(db, peer.id, {
+      pr_url: prUrl as string | null,
+      pr_number: prNumber as number | null,
+      pr_status: prStatus as Session["pr_status"],
+    });
+    setPlacement(db, peer.id, { peer_mirror: 1 });
+  };
   const mirrors = db.prepare(
-    `SELECT id FROM sessions WHERE host_id = ? AND peer_mirror = 1
+    `SELECT id FROM session_rows WHERE host_id = ? AND peer_mirror = 1
        AND task_prompt IS NULL AND archived_at IS NULL
        AND created_at < datetime(?, 'unixepoch')`
   );
@@ -112,7 +149,7 @@ export function syncPeerMirrors(
         peer.prStatus,
         peer.updatedAt,
       ];
-      update.run(...fields, peer.id, hostId, ...fields);
+      update(peer, fields);
     }
     if (!complete) return;
     const now = new Set(listed.map((p) => p.id));

package/lib/learning-cards/input.ts

@@ -80,7 +80,7 @@ export async function readSession(id: string): Promise<SessionInput | null> {
     ? (
         db
           .prepare(
-            `SELECT s.task_prompt AS p FROM sessions s JOIN projects p ON p.id = s.project_id
+            `SELECT s.task_prompt AS p FROM session_rows s JOIN projects p ON p.id = s.project_id
              WHERE p.workspace_id = ? AND s.id != ? AND s.quick_of IS NULL
                AND s.task_prompt IS NOT NULL
                AND s.created_at >= datetime('now', ?)

package/lib/learning-cards/store.ts

@@ -30,7 +30,7 @@ export function listPending(): PendingRow[] {
       `SELECT lc.*, s.name AS session_name,
               COALESCE(lc.workspace_id, s.workspace_id, p.workspace_id) AS ws
        FROM learning_cards lc
-       JOIN sessions s ON s.id = lc.session_id
+       JOIN session_rows s ON s.id = lc.session_id
        LEFT JOIN projects p ON p.id = s.project_id
        WHERE lc.status = 'pending'
        ORDER BY lc.created_at DESC, lc.id DESC`

package/lib/models/plan-step.ts

@@ -33,6 +33,7 @@ import {
   planPathOf,
   splitOf,
 } from "../plans/features";
+import { advancePlan, setPlan } from "../db/session-parts";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -164,10 +165,7 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
   const again = retried ? " (asked once more for it first)" : "";
   const head = planNoteFor(s, file, next, again, ref ? " anyway" : "");
   if (s.held_by_device) {
-    db.prepare(`UPDATE sessions SET plan_note = ? WHERE id = ?`).run(
-      head,
-      s.id
-    );
+    setPlan(db, s.id, { plan_note: head });
     return;
   }
   queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
@@ -227,9 +225,9 @@ export const implementMessageId = (sessionId: string) =>
 type Send = (sessionId: string, id: string) => Promise<void>;
 
 function getSession(sessionId: string): Session | undefined {
-  return db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
-    | Session
-    | undefined;
+  return db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
 }
 
 // Planning (or, once approved, awaiting) becomes implementing, once: the
@@ -273,13 +271,7 @@ async function startImplementing(
   let nothingOwn = false;
   let featureId: string | null = null;
   const claimed = db.transaction(() => {
-    const changed = db
-      .prepare(
-        `UPDATE sessions SET plan_phase = 'implementing'
-         WHERE id = ? AND plan_phase = ? AND task_status = 'running'`
-      )
-      .run(sessionId, from).changes;
-    if (!changed) return false;
+    if (!advancePlan(db, sessionId, from, "implementing")) return false;
     setSessionModel(sessionId, routed);
     let piece: string | undefined;
     let note = amendment;
@@ -485,13 +477,7 @@ export async function handoffAfterPlan(
       });
     return ref !== null;
   }
-  const awaiting = db
-    .prepare(
-      `UPDATE sessions SET plan_phase = 'awaiting'
-       WHERE id = ? AND plan_phase = 'planning' AND task_status = 'running'`
-    )
-    .run(sessionId).changes;
-  if (!awaiting) return false;
+  if (!advancePlan(db, sessionId, "planning", "awaiting")) return false;
   try {
     announcePlan(s, null, retried);
   } catch (e) {
@@ -538,7 +524,7 @@ export async function recheckPlanning(
 ): Promise<void> {
   const rows = db
     .prepare(
-      `SELECT id FROM sessions
+      `SELECT id FROM session_rows
        WHERE plan_phase = 'planning' AND task_status = 'running'
          AND archived_at IS NULL AND worktree_path IS NOT NULL`
     )
@@ -603,7 +589,7 @@ export async function approvePlan(
   // On another machine, the plan was written there: this machine decides
   // where it is built, and the approval follows it.
   const ref = isRemoteHost(s.host_id)
-    ? await (await import("../tasks/remote-plan")).continueRemotePlan(s, text)
+    ? await (await import("../tasks/contract/plan")).continuePlanThere(s, text)
     : await startImplementing(s, "awaiting", send, text);
   if (!ref) throw new Error(`${s.name} isn't waiting for plan approval`);
   if (by === "no-approvals")
@@ -617,7 +603,7 @@ export async function approvePlan(
   return { ref, amendments: scopeChangesOf(s.id).length };
 }
 
-// A plan that moved here to be built (remote-plan.ts): implementation starts
+// A plan that moved here to be built (contract/plan.ts): implementation starts
 // on this machine, once, with the approval's change if it had one.
 export async function implementArrived(
   sessionId: string,

package/lib/models/resume.ts

@@ -19,6 +19,7 @@ import {
   type ModelOverride,
 } from "./resolve";
 import { sessionRole } from "./session-role";
+import { setTask } from "../db/session-parts";
 
 export const RESUME_MESSAGE =
   "You were paused. Carry on where you left off: check the worktree and the conversation above for where things stand, then finish the task.";
@@ -45,9 +46,9 @@ export async function resumeOnModel(
   model: unknown,
   message = RESUME_MESSAGE
 ): Promise<ResumeResult> {
-  const s = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId) as
-    | Session
-    | undefined;
+  const s = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
   if (!s?.task_status) throw new Error("No such task");
   if (s.task_status !== "running")
     throw new Error(
@@ -65,10 +66,7 @@ export async function resumeOnModel(
     throw new Error(
       "It's mid-turn: stop it first, or wait for the turn to end"
     );
-  db.prepare(`UPDATE sessions SET model_overrides = ? WHERE id = ?`).run(
-    JSON.stringify(override),
-    sessionId
-  );
+  setTask(db, sessionId, { model_overrides: JSON.stringify(override) });
   if (launchPending(sessionId)) {
     setSessionModel(sessionId, routed);
     return { ref: routed.ref, resumed: false };

package/lib/notify/index.ts

@@ -160,7 +160,7 @@ export async function notifyFrom(
   text: string
 ): Promise<Outcome> {
   const session = from
-    ? (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(from) as
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(from) as
         | Session
         | undefined)
     : undefined;

package/lib/notify/push/events.ts

@@ -92,7 +92,7 @@ export const pushPlanAwaiting = (
 export const pushPlanReady = (sessionId: string, itemId: string) => {
   // Only a task has a screen to open; a plain chat's plan goes to the list.
   const task = db
-    .prepare(`SELECT task_status FROM sessions WHERE id = ?`)
+    .prepare(`SELECT task_status FROM session_rows WHERE id = ?`)
     .get(sessionId) as { task_status: string | null } | undefined;
   fire(
     {

package/lib/notify/push/index.ts

@@ -57,7 +57,7 @@ export interface PushOptions {
 
 function isMirrored(sessionId: string): boolean {
   const s = db
-    .prepare(`SELECT host_id, peer_mirror FROM sessions WHERE id = ?`)
+    .prepare(`SELECT host_id, peer_mirror FROM session_rows WHERE id = ?`)
     .get(sessionId) as
     | { host_id: string | null; peer_mirror: number | null }
     | undefined;

package/lib/orchestrator/act.ts

@@ -439,7 +439,7 @@ export async function resurrect(
   if (!reason.trim()) throw new Error("Say why it's restored");
   const id = resolveEnded(ref, { workspaceId });
   const row = db
-    .prepare(`SELECT task_status, archived_at FROM sessions WHERE id = ?`)
+    .prepare(`SELECT task_status, archived_at FROM session_rows WHERE id = ?`)
     .get(id) as { task_status: string | null; archived_at: string | null };
   const task =
     row.task_status === "dropped" ||

package/lib/orchestrator/armed.test-helpers.ts

@@ -0,0 +1,228 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+import { beforeAll, beforeEach, vi } from "vitest";
+import type { TaskPR } from "@/lib/tasks/state";
+import type { SessionFacts } from "./facts";
+
+// Shared fixtures for the armed*.test.ts files: a real repository with a
+// local bare remote, gh faked around it. Import this before anything it mocks.
+// Tests change the fake world through S.
+export const S: { pr: TaskPR | null } = { pr: null };
+export const merges: string[][] = [];
+export const isProbe = (args: string[]) =>
+  args[0] === "api" ||
+  (args[0] === "pr" &&
+    args[1] === "list" &&
+    args.includes("statusCheckRollup"));
+
+vi.mock("@/lib/tasks/gh", async (importOriginal) => {
+  const real = await importOriginal<typeof import("@/lib/tasks/gh")>();
+  return {
+    ...real,
+    run: async (cmd: string, args: string[], cwd: string, t?: number) => {
+      if (cmd === "gh" && isProbe(args)) return "0";
+      if (cmd === "gh") {
+        merges.push(args);
+        if (S.pr) S.pr = { ...S.pr, state: "MERGED" };
+        return "";
+      }
+      if (cmd === "tmux") throw new Error("no tmux in tests");
+      return real.run(cmd, args, cwd, t);
+    },
+    findPR: async () => S.pr,
+  };
+});
+vi.mock("@/lib/status-detector", () => ({
+  checkWaitingPatterns: () => false,
+  statusDetector: {
+    refreshCache: async () => {},
+    sessionExists: () => true,
+    getStatus: async () => "idle",
+    titleFor: () => "",
+    getTimestamp: () => 0,
+    hostFor: () => "local",
+    capturePane: async () => "❯ ",
+  },
+}));
+
+export const { db, updateSessionRow } = await import("@/lib/db");
+export const { createProject } = await import("@/lib/projects");
+export const { createWorkspace, setProjectWorkspace } =
+  await import("@/lib/workspaces");
+export const { ensureOrchestrator } = await import("./home");
+export const { runTool } = await import("./serve");
+export const { getCheck, putCheck } = await import("./checks");
+export const { failureOf, recordFailure } = await import("./gates");
+export const { LOOP_GUARD_COMMITS } = await import("./loop-guard");
+export const { seedSession } = await import("./testing");
+export const { setMergeApprovals } = await import("./merge-approvals");
+export const { mergeArmed, armTask } = await import("./armed");
+export const { setPaused } = await import("./pause");
+export const { escalate } = await import("./escalate");
+export const { openAsks, raiseAsk } = await import("./asks");
+export const { judge, mergeJudged } = await import("./signoff");
+export const { rebaseConflicting } = await import("./rebase");
+export const { recordConditions } = await import("./events");
+
+beforeAll(() => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-armed-"));
+  vi.spyOn(os, "homedir").mockReturnValue(home);
+});
+beforeEach(() => {
+  merges.length = 0;
+});
+
+export const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: "pipe",
+    env: { ...process.env, GIT_COMMITTER_DATE: "2026-01-01T00:00:00Z" },
+  }).trim();
+
+export function commit(repo: string, file: string, text: string): string {
+  fs.mkdirSync(path.dirname(path.join(repo, file)), { recursive: true });
+  fs.writeFileSync(path.join(repo, file), text);
+  git(repo, "add", "-A");
+  git(repo, "commit", "-qm", `change ${file}`);
+  git(repo, "push", "-q", "origin", "HEAD");
+  return git(repo, "rev-parse", "HEAD");
+}
+
+export const lines = (n: number, change: Record<number, string> = {}) =>
+  Array.from({ length: n }, (_, i) => change[i + 1] ?? `line ${i + 1}`).join(
+    "\n"
+  ) + "\n";
+
+// A workspace whose project is a real clone, which is also the task's
+// worktree, on its branch with its PR open at the branch's head. `other`
+// is a second clone for moving main.
+export function setup() {
+  setMergeApprovals(false);
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-armed-repo-"));
+  const remote = path.join(root, "remote.git");
+  const repo = path.join(root, "repo");
+  const other = path.join(root, "other");
+  git(root, "init", "-q", "--bare", "-b", "main", remote);
+  git(root, "clone", "-q", remote, repo);
+  for (const r of [repo]) {
+    git(r, "config", "user.email", "t@example.com");
+    git(r, "config", "user.name", "T");
+  }
+  commit(repo, "src/b.ts", lines(12));
+  git(root, "clone", "-q", remote, other);
+  git(other, "config", "user.email", "o@example.com");
+  git(other, "config", "user.name", "O");
+  git(repo, "checkout", "-qb", "feature/t");
+  const sha = commit(repo, "src/b.ts", lines(12, { 5: "changed five" }));
+
+  const workspace = createWorkspace(`ws-${path.basename(root)}`);
+  const project = createProject({
+    name: `app-${path.basename(root)}`,
+    workingDirectory: repo,
+  });
+  setProjectWorkspace(project.id, workspace.id);
+  ensureOrchestrator(workspace.id);
+  const task = seedSession({
+    projectId: project.id,
+    name: "add-a",
+    task: true,
+    branch: "feature/t",
+  });
+  updateSessionRow(db, task, {
+    base_branch: "main",
+    task_prompt: "Add a",
+    pr_number: 7,
+    worktree_path: repo,
+  });
+  S.pr = {
+    number: 7,
+    url: "https://github.com/o/r/pull/7",
+    state: "OPEN",
+    checks: "pass",
+    head: sha,
+    failing: null,
+    checkCount: 1,
+    attribution: null,
+  };
+  const w = workspace.id;
+  const put = (
+    kind: "review" | "ci",
+    status: "pass" | "block",
+    at = S.pr!.head!
+  ) =>
+    putCheck({
+      workspaceId: w,
+      sessionId: task,
+      sha: at,
+      kind,
+      status,
+      detail:
+        kind === "ci"
+          ? JSON.stringify({ count: S.pr!.checkCount, at: 0 })
+          : "Looks right.",
+    });
+  // CI has looked settled on the head for a while.
+  put("ci", "pass");
+  return {
+    w,
+    repo,
+    other,
+    remote,
+    task,
+    sha,
+    put,
+    // Someone else's PR merged: main moves.
+    moveMain: (file: string, text: string) => {
+      git(other, "pull", "-q", "origin", "main");
+      return commit(other, file, text);
+    },
+    facts: (status: SessionFacts["status"] = "idle"): SessionFacts[] => [
+      {
+        id: task,
+        name: "add-a",
+        project: project.name,
+        view: "terminal",
+        status,
+        activity: null,
+        needsInput: false,
+        lastActive: 0,
+        branch: "feature/t",
+        task: { state: "review", pr: S.pr, blocked: null, ciSettleIn: 0 },
+        stack: null,
+      },
+    ],
+  };
+}
+
+export const events = (w: string) =>
+  (
+    db
+      .prepare(
+        `SELECT key, line FROM orchestrator_events WHERE workspace_id = ? AND key LIKE 'once:%' ORDER BY id`
+      )
+      .all(w) as { key: string; line: string }[]
+  ).map((e) => e.line);
+
+export const armedAt = (task: string) =>
+  (
+    db
+      .prepare(`SELECT merge_armed_at FROM session_rows WHERE id = ?`)
+      .get(task) as { merge_armed_at: string | null }
+  ).merge_armed_at;
+
+export function armedDeps() {
+  const reviews: string[] = [];
+  return {
+    reviews,
+    deps: {
+      judge,
+      merge: mergeJudged,
+      review: async (_w: string, id: string) => {
+        reviews.push(id);
+      },
+    },
+  };
+}