@saadnvd1/agent-os 0.3.474 → 0.3.477

package/lib/done/worktree.ts

@@ -142,8 +142,15 @@ async function commitsKeep(
       return `${stray} commit${stray === 1 ? " is" : "s are"} on it that the merged PR didn't include and no remote has`;
     return null;
   }
-  const base = session.base_branch || (await getDefaultBranch(repo));
-  const own = await ownCommits(path, base).catch(() => null);
+  // A base gone everywhere (a stacked parent's branch, deleted) is judged
+  // against the default branch instead.
+  const fallback = await getDefaultBranch(repo);
+  let base = session.base_branch || fallback;
+  let own = await ownCommits(path, base).catch(() => null);
+  if (own === null && base !== fallback) {
+    base = fallback;
+    own = await ownCommits(path, base).catch(() => null);
+  }
   if (own === null) return `its base ${base} can't be found to compare`;
   if (own > 0)
     return `its branch has ${own} commit${own === 1 ? "" : "s"} not merged into ${base}`;

package/lib/models/roles.ts

@@ -53,7 +53,7 @@ export const DEFAULT_ROLE_MODELS: Record<ModelRole, string> = {
   plan: OPUS,
   review: OPUS,
   implement: SONNET,
-  orchestrator: SONNET,
+  orchestrator: OPUS,
   scope: SONNET,
   interactive: OPUS,
   helper: HAIKU,

package/lib/orchestrator/ask-approvals.ts

@@ -93,3 +93,14 @@ export function voidApprovals(workspaceId: string, subject: string): number {
     )
     .run(workspaceId, subject).changes;
 }
+
+// The same, for a subject whose workspace the caller doesn't have at hand
+// (a task's base moved under its approval: what was approved no longer is).
+export function voidApprovalsOn(subject: string): number {
+  return db
+    .prepare(
+      `UPDATE orchestrator_asks SET used_at = datetime('now'), answer = 'approve (void)'
+       WHERE subject = ? AND status = 'approved' AND used_at IS NULL`
+    )
+    .run(subject).changes;
+}

package/lib/orchestrator/brief.ts

@@ -44,7 +44,8 @@ Merge only through the gates: \`arm\` or \`sign_off\`. \`sign_off\` merges a tas
 - code-review: a passing review (the gate above) covers that exact commit, or the commit AgentOS restacked or rebased into it while the head is still the one AgentOS left, and the PR body carries no AI attribution. Tasks don't review themselves or write a "Code review" section any more: your review is the one review, so don't ask a task for one.
 - blocked: no BLOCKED: line and no approval or question waiting in the task's chat or terminal.
 - scope: the diff stays in the task's repository, adds no secrets, isn't only lockfiles, and, for a task from a card, a check against the card (run with the review) says it's within what the card asks.
-- stack: a stacked task's parent has merged.
+- stack: a stacked task's parent has merged, or was dropped and the PR no longer targets its branch.
+- base: the PR targets the task's base. AgentOS follows GitHub when a PR is retargeted to the default branch or its stack parent's branch (reviews of the old base stop counting); any other base is refused.
 
 PRs AgentOS didn't open (dispatch on another machine, a person, dependabot) go through the same \`sign_off\` and \`review\`: name one by #N, owner/repo#N or its URL. It must be open, in the repository of one of this workspace's projects (anything else is refused), and not from a fork. It's an external PR: there's no task or session behind it, so the gates read it differently. blocked: a draft isn't ready yet, and a label like "blocked", "do not merge" or "wip" holds it. code-review: your \`review\` of that exact head is what counts, as for a task; a "Code review" section in its body is ignored. ci, review, scope, Saad's approvals and his hold are the same as for a task, and a stack never applies. A PR that turns out to be a task's is gated as that task.
 

package/lib/orchestrator/deliver.ts

@@ -2,6 +2,7 @@ import type { ChatOrigin, ChatState } from "../chat/events";
 import type { CompactFirst } from "../chat/stale";
 import {
   isAnswer,
+  isAwayEvent,
   deliveriesSince,
   lastDeliveredAt,
   logDeliveries,
@@ -91,6 +92,7 @@ export async function deliverEvents(opts: {
     kind: "event",
     label: "AgentOS",
     ...(decided.length ? { decided } : {}),
+    ...(pending.every((e) => isAwayEvent(e)) ? { away: true as const } : {}),
   };
   markDelivered(ids, now);
   const logged = logDeliveries(

package/lib/orchestrator/digest.ts

@@ -324,7 +324,7 @@ export function buildDigest(
 ): string {
   const checks = checksBySession(workspaceId);
   const failures = failuresBySession(workspaceId);
-  const away = awayDigestLine();
+  const away = awayDigestLine(workspaceId);
   const head = `## Where things stand (read from AgentOS's database as you started)${away ? `\n\n${away}` : ""}`;
   const body = renderDigest(
     [

package/lib/orchestrator/events.ts

@@ -40,6 +40,9 @@ const ONCE = "once:";
 export const answerKey = (askId: number) => `ask:${askId}`;
 export const isAnswer = (e: Pick<EventRow, "key">) =>
   e.key.startsWith(`${ONCE}ask:`);
+// Away mode's own one-off lines (lib/away/run) all start "away".
+export const isAwayEvent = (e: Pick<EventRow, "key">) =>
+  e.key.startsWith(`${ONCE}away`);
 
 const iso = (ms: number) => new Date(ms).toISOString();
 

package/lib/orchestrator/rebase.ts

@@ -23,9 +23,11 @@ import os from "os";
 import path from "path";
 import { db, type Session } from "../db";
 import { sendMessage } from "../bus";
+import { getDefaultBranch } from "../git";
 import { hostLink } from "../hosts/remote-api";
 import type { TaskPR } from "../tasks/state";
 import { run } from "../tasks/gh";
+import { isAllowedBase } from "../tasks/session";
 import { git as runGit, gitFetch, revParse } from "../git-exec";
 import { outputOf, type Runner } from "../stacks/git";
 import { restackedHeads, stackNotice } from "../stacks/restack";
@@ -127,7 +129,11 @@ async function rebaseOne(
   deps: RebaseDeps
 ): Promise<void> {
   const repo = repoOf(task);
-  const branch = task.base_branch || "main";
+  // The PR's base as GitHub has it now, not the one the task started on.
+  // Only a base AgentOS would judge the task against: a branch the task
+  // picked itself could carry commits nobody reviewed.
+  if (pr.base && !(await isAllowedBase(task, repo, pr.base))) return;
+  const branch = pr.base || task.base_branch || (await getDefaultBranch(repo));
   // A failed fetch throws: nothing is judged against a stale base.
   await gitFetch(repo, ["--quiet", "--", "origin", branch, task.branch_name!], {
     timeout: 60000,

package/lib/orchestrator/repo.ts

@@ -7,8 +7,16 @@ import os from "os";
 import path from "path";
 import type { Session } from "../db";
 import { SKILL_DIRS } from "../agents/skill-dirs";
+import { getDefaultBranch } from "../git";
 import { getProject } from "../projects";
-import { git, gitFetch, gitOk, worktreeAdd, worktreeRemove } from "../git-exec";
+import {
+  git,
+  gitFetch,
+  gitOk,
+  isGitError,
+  worktreeAdd,
+  worktreeRemove,
+} from "../git-exec";
 import { expandHome } from "../tasks/session";
 
 export function repoOf(task: Session): string {
@@ -17,22 +25,79 @@ export function repoOf(task: Session): string {
   return expandHome(project.working_directory);
 }
 
-// The task's base on origin, fetched along with its head.
+// The task's base on origin, fetched along with its head. The base is the
+// PR's own (prFor records GitHub's baseRefName on the task). A base gone
+// from origin (a stacked parent's branch, deleted) falls back to the
+// project's default branch, and so does one that can't be found at all, so
+// a diff never names a missing revision.
 export async function fetchRefs(
   repo: string,
   task: Pick<Session, "base_branch" | "branch_name">
 ): Promise<string> {
-  const base = task.base_branch || "main";
-  await gitFetch(repo, [
-    "--quiet",
-    "--",
-    "origin",
-    base,
-    task.branch_name ?? base,
-  ]).catch(() => {});
-  const remote = `origin/${base}`;
-  const has = await gitOk(repo, ["rev-parse", "--verify", "--quiet", remote]);
-  return has ? remote : base;
+  const head = task.branch_name ? [task.branch_name] : [];
+  const recorded = task.base_branch || null;
+  if (recorded) {
+    const fetched = await fetchBranches(repo, [recorded, ...head]);
+    // A base gone on origin fails the fetch, so the head goes on its own.
+    if (fetched === "gone" && head.length)
+      requireFetched(await fetchBranches(repo, head));
+    requireFetched(fetched);
+    if (fetched !== "gone") {
+      const found = await existingRef(repo, recorded);
+      if (found) return found;
+    }
+  }
+  const fallback = await getDefaultBranch(repo);
+  if (fallback !== recorded) {
+    requireFetched(
+      await fetchBranches(repo, recorded ? [fallback] : [fallback, ...head])
+    );
+    const found = await existingRef(repo, fallback);
+    if (found) return found;
+  }
+  throw new Error(
+    `Neither the base ${recorded ?? "(none recorded)"} nor the default branch ${fallback} can be found`
+  );
+}
+
+// An unreachable origin leaves the tracking refs as they were, and a diff
+// against a stale base can hide or invent changes, so the gates stop.
+function requireFetched(result: "ok" | "gone" | "failed"): void {
+  if (result === "failed")
+    throw new Error("Couldn't fetch from origin, so the base can't be trusted");
+}
+
+// "gone" when origin answered that the first branch isn't there; any other
+// failure is "failed" (origin unreachable).
+async function fetchBranches(
+  repo: string,
+  branches: string[]
+): Promise<"ok" | "gone" | "failed"> {
+  try {
+    // In English whatever the locale: the message is read below.
+    await gitFetch(repo, ["--quiet", "--", "origin", ...branches], {
+      env: { LC_ALL: "C" },
+    });
+    return "ok";
+  } catch (error) {
+    const stderr = isGitError(error) ? error.stderr : "";
+    return stderr.includes(`couldn't find remote ref ${branches[0]}`)
+      ? "gone"
+      : "failed";
+  }
+}
+
+// origin/<branch> when it's there, else a local <branch>.
+async function existingRef(
+  repo: string,
+  branch: string
+): Promise<string | null> {
+  for (const ref of [`origin/${branch}`, branch])
+    if (
+      await gitOk(repo, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])
+    )
+      return ref;
+  return null;
 }
 
 // When the commit was made, in seconds.

package/lib/orchestrator/review.ts

@@ -65,6 +65,13 @@ export function describeReview(row: CheckRow): string {
 // What a review reads: a task's PR, or a PR no task owns (external-pr.ts).
 // `id` keys its stored checks; `task` is set only for a task, whose card
 // gets a scope check.
+const baseBranchOf = (id: string) =>
+  (
+    db.prepare(`SELECT base_branch FROM sessions WHERE id = ?`).get(id) as
+      | { base_branch: string | null }
+      | undefined
+  )?.base_branch ?? null;
+
 export interface ReviewTarget {
   id: string;
   name: string;
@@ -85,6 +92,7 @@ async function reviewJob(
 ): Promise<CheckRow> {
   const { pr, repo, task } = target;
   const row = { workspaceId, sessionId: target.id, sha };
+  const judged = target.refs.base_branch;
   const base = await fetchRefs(repo, target.refs);
   const diff = await fullDiff(repo, base, sha);
   const parts =
@@ -160,6 +168,16 @@ async function reviewJob(
       });
       verdicts.push(toVerdict(answer));
     }
+    // A retarget while it ran (prFor records it): this verdict read the
+    // diff against the old base, so it covers nothing.
+    const now = task ? baseBranchOf(task.id) : judged;
+    if (now !== judged)
+      return putCheck({
+        ...row,
+        kind: "review",
+        status: "error",
+        detail: `the PR's base moved from ${judged} to ${now} while it was reviewed; review it again`,
+      });
     const done = putCheck({
       ...row,
       kind: "review",

package/lib/orchestrator/signoff.ts

@@ -71,6 +71,15 @@ export async function judge(
   const pr = await prFor(task, true);
   if (!pr || pr.state !== "OPEN" || !pr.head)
     return { ok: false, wait: false, text: `${task.name} has no open PR` };
+  // prFor records a retarget to the default branch or the stack parent's
+  // branch; any other base would merge somewhere nobody chose, judged
+  // against a branch the task picked.
+  if (pr.base && pr.base !== task.base_branch)
+    return {
+      ok: false,
+      wait: false,
+      text: `${task.name}'s PR #${pr.number} targets ${pr.base}, not its base ${task.base_branch ?? "(none)"}: retarget it to ${task.base_branch ?? "the default branch"}`,
+    };
   const sha = pr.head;
   const repo = repoOf(task);
   return gateVerdict(

package/lib/stacks/guard.ts

@@ -12,6 +12,17 @@ export function refusalFor(
 ): string | null {
   if (!parent) return null;
   const who = itemName(parent);
+  // A dropped parent never merges: once the PR moved off its branch
+  // (GitHub retargets it when the branch is deleted), there is nothing to
+  // wait for, and the review of the new base reads the parent's commits.
+  // A failed one can be retried, so it still blocks.
+  if (
+    parent.status === "dropped" &&
+    parentBranch &&
+    item.base_branch &&
+    item.base_branch !== parentBranch
+  )
+    return null;
   if (parent.status !== "merged") {
     const state =
       parent.status === "pr" ? "has not merged" : `is ${parent.status}`;

package/lib/tasks/finish.ts

@@ -127,9 +127,16 @@ export async function signOffTask(
   if (!repo) throw new Error("Task has no project");
   const refusal = signOffRefusal(id);
   if (refusal) throw new Error(refusal);
+  // prFor follows a retarget onto the record, so compare with what the
+  // checks above were judged against.
+  const judgedBase = session.base_branch;
   const pr = await prFor(session, true);
   const verdict = canSignOff(pr);
   if (!verdict.ok) throw new Error(verdict.reason);
+  if (pr!.base && pr!.base !== judgedBase)
+    throw new Error(
+      `PR #${pr!.number} targets ${pr!.base}, not its base ${judgedBase ?? "(none)"}: its review and checks were for the old base`
+    );
   if (opts.head && pr!.head && pr!.head !== opts.head)
     throw new Error(
       `The PR moved to ${pr!.head.slice(0, 7)} after ${opts.head.slice(0, 7)} was checked`

package/lib/tasks/gh.ts

@@ -54,6 +54,7 @@ export interface ListedPR {
   isCrossRepository?: boolean;
   createdAt?: string;
   mergeable?: TaskPR["mergeable"];
+  baseRefName?: string;
 }
 
 export interface FindPROpts {
@@ -81,7 +82,7 @@ export async function findPRStrict(
       "--limit",
       "10",
       "--json",
-      "number,url,state,headRefOid,statusCheckRollup,body,isCrossRepository,createdAt,mergeable",
+      "number,url,state,headRefOid,statusCheckRollup,body,isCrossRepository,createdAt,mergeable,baseRefName",
     ],
     repoDir,
     15000
@@ -118,6 +119,7 @@ export async function toTaskPR(repoDir: string, pr: ListedPR): Promise<TaskPR> {
       pr.body === undefined ? undefined : (attributionIn(pr.body) ?? null),
     scopeChange: parseScopeChange(pr.body),
     ...(pr.mergeable && { mergeable: pr.mergeable }),
+    ...(pr.baseRefName && { base: pr.baseRefName }),
   };
 }
 

package/lib/tasks/pr-poll.ts

@@ -9,7 +9,7 @@ import type { TaskPR } from "./state";
 export const OPEN_TTL_MS = 60_000;
 export const BRANCH_TTL_MS = 5 * 60_000;
 const OPEN_FIELDS =
-  "number,url,state,headRefOid,statusCheckRollup,body,headRefName,isCrossRepository,createdAt,mergeable";
+  "number,url,state,headRefOid,statusCheckRollup,body,headRefName,isCrossRepository,createdAt,mergeable,baseRefName";
 
 interface OpenList {
   at: number;

package/lib/tasks/session.ts

@@ -1,7 +1,10 @@
 import fs from "fs";
 import os from "os";
-import { db, queries, type Session } from "../db";
-import { isBranchName } from "../git";
+import { db, queries, stackQueries, type Session } from "../db";
+import { getDefaultBranch, isBranchName } from "../git";
+import { parentBranchOf } from "../stacks/guard";
+import { voidApprovalsOn } from "../orchestrator/ask-approvals";
+import { taskSubject } from "../orchestrator/asks";
 import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
@@ -170,9 +173,67 @@ export async function prFor(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
     ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
   }
+  // Only an answer just read from GitHub: a cached one may predate a
+  // retarget AgentOS made itself (a restack).
+  if (fresh) await recordBase(session, repo, pr);
   return pr;
 }
 
+// An open PR's base as GitHub has it now becomes the task's, in the row and
+// in `session`, so every diff, the stack logic and the UI read the truth:
+// the base recorded at the start goes stale when the PR is retargeted (a
+// stacked parent's branch deleted, so GitHub moved it to main). Only the
+// default branch or the stack parent's branch is taken: a base the task
+// picked itself would choose what its diff is judged against, so it stays
+// unrecorded and sign_off refuses it. Reviews and scope checks judged
+// against the old base no longer count. A stack item on a merged parent
+// keeps its base until the restack moves it, which is also what takes the
+// parent's commits off it.
+// The bases a task may be judged against: the default branch or its stack
+// parent's branch (and what it already has).
+export async function isAllowedBase(
+  session: Session,
+  repo: string,
+  base: string
+): Promise<boolean> {
+  if (base === session.base_branch) return true;
+  const item = stackQueries.itemForSession(db, session.id);
+  const parent = item?.parent_item_id
+    ? stackQueries.item(db, item.parent_item_id)
+    : null;
+  return (
+    base === parentBranchOf(parent) || base === (await getDefaultBranch(repo))
+  );
+}
+
+async function recordBase(
+  session: Session,
+  repo: string,
+  pr: TaskPR | null
+): Promise<void> {
+  const base = pr?.state === "OPEN" ? pr.base : undefined;
+  if (!base || base === session.base_branch || !isBranchName(base)) return;
+  if (!(await isAllowedBase(session, repo, base))) return;
+  const item = stackQueries.itemForSession(db, session.id);
+  const parent = item?.parent_item_id
+    ? stackQueries.item(db, item.parent_item_id)
+    : null;
+  db.transaction(() => {
+    db.prepare(`UPDATE sessions SET base_branch = ? WHERE id = ?`).run(
+      base,
+      session.id
+    );
+    db.prepare(
+      `DELETE FROM orchestrator_checks WHERE session_id = ? AND kind IN ('review', 'scope')`
+    ).run(session.id);
+    // An approval was for the diff against the old base.
+    voidApprovalsOn(taskSubject(session.id));
+    if (item && item.base_branch !== base && parent?.status !== "merged")
+      stackQueries.updateItem(db, item.id, { base_branch: base });
+  })();
+  session.base_branch = base;
+}
+
 // A finished task's PR as the database last saw it: no gh call.
 export function storedPR(s: Session): TaskPR | null {
   if (!s.pr_number) return null;

package/lib/tasks/state.ts

@@ -30,6 +30,9 @@ export interface TaskPR {
   // GitHub's word on merging it into its base: CONFLICTING once the base
   // moved under it (UNKNOWN while GitHub works it out).
   mergeable?: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  // The branch it merges into, as GitHub has it now: it moves when the
+  // PR is retargeted (a stacked parent's branch deleted, say).
+  base?: string;
 }
 
 export type TaskState =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.474",
+  "version": "0.3.477",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"