@saadnvd1/agent-os 0.3.486 → 0.3.488

package/README.md

@@ -358,6 +358,9 @@ and leave no transcript, so each run's tokens, model and duration are read
 from its JSON result into `check_runs`, and the review's verdict says them
 too. Every compaction is kept in `chat_compactions` (who ran it, whether it
 fired `mid_turn` or `between_turns`, and the context before and after), so cost per task can be compared by date.
+Rows from before the column existed, and any written by a chat worker still
+running older code, have a NULL `phase`: read those as unknown
+(`COALESCE(phase, 'unknown')`), not as either kind.
 
 **Esc** stops a running turn, as it does in Claude Code's terminal, unless a
 menu, dialog or the command list is open (those close first). On a phone the
@@ -464,7 +467,9 @@ default; set it in **Settings → Workspaces**, or `PATCH /api/workspaces/<id>`
 worktree or agent yet, and starts by itself in line order when one finishes
 (merged, dropped or done). `aos task --after <task|any>` (and the
 orchestrator's `start_task` with `after`) holds a task until a named task
-finishes, or until any task running now does. Pause stops automatic starts,
+finishes, or until any task still working now does (a running task whose PR
+was closed or merged doesn't count; with none, it starts at once). The
+orchestrator's `drop` removes a queued task by its id. Pause stops automatic starts,
 and the orchestrator's brakes still apply when its queued tasks start. The
 line is kept in the database across restarts (`GET /api/tasks/queue`; start
 now, move up or down, or remove with `/api/tasks/queue/<id>`). The sidebar
@@ -1129,7 +1134,11 @@ it may do on its own, and the lines that always come back to you as asks.
   nothing uncommitted, AgentOS rebases it in the task's worktree and pushes
   only its branch with `--force-with-lease`, and the orchestrator's review
   carries over when the PR's own patch is
-  unchanged (same `git patch-id`; a fresh review starts otherwise). Not
+  unchanged (same `git patch-id`; a fresh review starts otherwise). Your
+  merge approval carries over a rebase the same way (any rebase, the task's
+  own included): when the PR's patch is unchanged it follows the new head,
+  else you're asked again, naming the new head and what changed, and an open
+  merge ask follows its PR's head. Not
   clean: the task is asked once to rebase. Either way, one event. Main and
   other tasks' branches are never written.
 - **Tasks woken on CI failures and reviews:** a check failing on a task's

package/lib/orchestrator/act.ts

@@ -20,7 +20,12 @@ import {
   type StartView,
 } from "../sessions/launch";
 import { createTask, dropTask } from "../tasks";
-import { startOrQueue } from "../tasks/queue";
+import {
+  findQueued,
+  queuedLabel,
+  removeQueued,
+  startOrQueue,
+} from "../tasks/queue";
 import { getStack, previewStack, startStack } from "../stacks";
 import { treeOrder } from "../stacks/tree";
 import type { StackItemView } from "../stacks/types";
@@ -235,7 +240,27 @@ export async function drop(
   reason: string
 ): Promise<string> {
   if (!reason.trim()) throw new Error("Say why it's dropped");
-  const task = workspaceTask(workspaceId, ref);
+  // A task still in the queue has no session yet: its id removes it.
+  const removeQueuedTask = (
+    queued: NonNullable<ReturnType<typeof findQueued>>
+  ) => {
+    removeQueued(queued.id);
+    addNote(
+      workspaceId,
+      `Removed queued task ${queuedLabel(queued)} before it started: ${reason.trim()}`
+    );
+    return `Removed queued task "${queuedLabel(queued)}" (id ${queued.id.slice(0, 8)}) from the queue; it never started.`;
+  };
+  const byId = findQueued(workspaceId, ref);
+  if (byId) return removeQueuedTask(byId);
+  let task;
+  try {
+    task = workspaceTask(workspaceId, ref);
+  } catch (error) {
+    const byName = findQueued(workspaceId, ref, { byName: true });
+    if (byName) return removeQueuedTask(byName);
+    throw error;
+  }
   await dropTask(task.id);
   addNote(workspaceId, `Dropped task ${task.name}: ${reason.trim()}`);
   return `Dropped ${task.name}: its PR is closed and its worktree removed.`;

package/lib/orchestrator/approval-carry.ts

@@ -0,0 +1,48 @@
+// Saad's merge approval across a rebase. He approved a commit; the task
+// rebased onto the base (only to renumber a migration, say) and its head
+// moved. The approval was for the PR's patch, so it follows the head when
+// that patch is unchanged (the check the review's carry-over uses, patch.ts),
+// and otherwise is asked again, with a note on what changed.
+
+import type { AskRow } from "./asks";
+import { getAsk } from "./asks";
+import { rebindApproval } from "./ask-approvals";
+import { addNote } from "./notes";
+import { comparePatches } from "./patch";
+import { fetchRefs } from "./repo";
+import type { Session } from "../db";
+
+const short = (sha: string) => sha.slice(0, 7);
+
+export async function carryApproval(
+  workspaceId: string,
+  work: {
+    name: string;
+    repo: string;
+    refs: Pick<Session, "base_branch" | "branch_name">;
+  },
+  approval: AskRow & { sha: string },
+  head: string
+): Promise<{ approval: AskRow | null; note: string }> {
+  let base: string;
+  try {
+    base = await fetchRefs(work.repo, work.refs);
+  } catch {
+    return { approval: null, note: "its base couldn't be fetched to compare" };
+  }
+  const { same, note } = await comparePatches(
+    work.repo,
+    base,
+    approval.sha,
+    head
+  );
+  if (!same) return { approval: null, note };
+  const line = `Carried to ${short(head)}: same patch as ${short(approval.sha)} (rebased onto ${base}).`;
+  if (rebindApproval(approval.id, approval.sha, head, line))
+    addNote(
+      workspaceId,
+      `Saad's approval of ${work.name} at ${short(approval.sha)} carries to ${short(head)}: same patch, rebased onto ${base}.`
+    );
+  const now = getAsk(workspaceId, approval.id);
+  return { approval: now?.sha === head && !now.used_at ? now : null, note };
+}

package/lib/orchestrator/ask-approvals.ts

@@ -1,7 +1,7 @@
 // Spending Saad's approvals: each covers one item, once.
 
 import { db } from "../db";
-import type { AskRow } from "./asks";
+import { MAX_DETAIL, type AskRow } from "./asks";
 
 // An approval on the subject not spent yet, newer than maxAgeMs if given.
 export function unspentApproval(
@@ -104,3 +104,22 @@ export function voidApprovalsOn(subject: string): number {
     )
     .run(subject).changes;
 }
+
+// Moves an approval Saad gave to the commit it was rebased into, when the
+// patch is the same: it stays one approval, spent once. Compare-and-swap on
+// the old commit, so two judgements racing move it once.
+export function rebindApproval(
+  id: number,
+  from: string,
+  to: string,
+  line: string
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE orchestrator_asks SET sha = ?, detail = substr(detail || char(10) || ?, 1, ?)
+         WHERE id = ? AND sha = ? AND status = 'approved' AND used_at IS NULL`
+      )
+      .run(to, line, MAX_DETAIL, id, from).changes === 1
+  );
+}

package/lib/orchestrator/ask-heads.ts

@@ -0,0 +1,47 @@
+// An open merge ask follows its PR's head. A task that rebases or pushes
+// while the ask waits would otherwise show Saad a commit that's already
+// gone; the ask is moved to the head it would merge, with a line on whether
+// the PR's patch changed. The approve button is bound to the commit shown,
+// so an answer from a screen that predates the move is refused (asks.ts).
+
+import { db, type Session } from "../db";
+import { hostLink } from "../hosts/remote-api";
+import { moveAskHead, openAsks, taskSubject } from "./asks";
+import type { SessionFacts } from "./facts";
+import { addNote } from "./notes";
+import { comparePatches } from "./patch";
+import { fetchRefs, repoOf } from "./repo";
+
+const short = (sha: string) => sha.slice(0, 7);
+
+// Tasks only: a PR no task owns has no facts here.
+export async function followAskHeads(
+  workspaceId: string,
+  facts: SessionFacts[]
+): Promise<void> {
+  for (const ask of openAsks(workspaceId)) {
+    const f = facts.find((x) => taskSubject(x.id) === ask.subject);
+    const pr = f?.task?.pr;
+    if (!ask.sha || pr?.state !== "OPEN" || !pr.head || pr.head === ask.sha)
+      continue;
+    const task = db
+      .prepare(`SELECT * FROM sessions WHERE id = ?`)
+      .get(f!.id) as Session | undefined;
+    if (!task || hostLink(task.host_id)) continue;
+    try {
+      const repo = repoOf(task);
+      const base = await fetchRefs(repo, task);
+      const { same, note } = await comparePatches(repo, base, ask.sha, pr.head);
+      const what = same ? `same patch (rebased onto ${base})` : note;
+      const line = `Head moved from ${short(ask.sha)} to ${short(pr.head)}: ${what}. Approving merges ${short(pr.head)}.`;
+      if (moveAskHead(ask.id, ask.sha, pr.head, line))
+        addNote(
+          workspaceId,
+          `Saad's ask on ${task.name} now names ${short(pr.head)} (${same ? "same patch" : "patch changed"}).`,
+          "ask"
+        );
+    } catch (error) {
+      console.error(`Following ${task.name}'s head in its ask:`, error);
+    }
+  }
+}

package/lib/orchestrator/asks.ts

@@ -330,3 +330,29 @@ export function resolveAsks(
     )
     .run(why, workspaceId, subject).changes;
 }
+
+// An open ask about a commit that has since been replaced (a rebase, a push)
+// now names the head, with a line saying what happened to it. Only while it
+// still names `from`, so a re-raise in between isn't overwritten.
+export function moveAskHead(
+  id: number,
+  from: string,
+  to: string,
+  line: string
+): boolean {
+  const ask = db
+    .prepare(`SELECT detail FROM orchestrator_asks WHERE id = ?`)
+    .get(id) as { detail: string } | undefined;
+  if (!ask) return false;
+  const rest = ask.detail.split(/\n?Head moved from /)[0];
+  const room = Math.max(0, MAX_DETAIL - line.length - 1);
+  const detail = `${rest.slice(0, room)}\n${line}`.trim();
+  return (
+    db
+      .prepare(
+        `UPDATE orchestrator_asks SET sha = ?, detail = ?
+         WHERE id = ? AND status = 'open' AND sha = ?`
+      )
+      .run(to, detail, id, from).changes === 1
+  );
+}

package/lib/orchestrator/held.ts

@@ -14,14 +14,15 @@ export function heldVerdict(
   held: FailureRow[],
   url: string,
   sha: string,
-  pr: number
+  pr: number,
+  moved?: string
 ): Verdict {
   // One the orchestrator raised was judged before this (signoff.ts).
   const approval = latestApproval(workspaceId, workSubject(task.id));
   if (approval?.sha === sha)
     return { ok: true, sha, pr, approval: approval.id };
   if (approval) {
-    const why = `Saad approved ${approval.sha ? short(approval.sha) : "an earlier commit"}, but PR #${pr}'s head is now ${short(sha)}`;
+    const why = `Saad approved ${approval.sha ? short(approval.sha) : "an earlier commit"}, but PR #${pr}'s head is now ${short(sha)}${moved ? ` and ${moved}` : ""}`;
     try {
       raiseAsk({
         workspaceId,

package/lib/orchestrator/patch.ts

@@ -0,0 +1,98 @@
+// Whether two commits carry the same patch against a base, as `git
+// patch-id` sees it. The one check behind both carry-overs of a decision
+// across a rebase: the orchestrator's review (rebase.ts) and Saad's merge
+// approval (approval-carry.ts).
+
+import { git, gitFetch, gitOk } from "../git-exec";
+
+const diffOf = (repo: string, base: string, head: string) =>
+  git(repo, [
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--full-index",
+    `${base}...${head}`,
+  ]).catch(() => null);
+
+async function idOf(repo: string, diff: string): Promise<string | null> {
+  return git(repo, ["patch-id", "--verbatim"], {
+    input: diff,
+    timeout: 30000,
+  }).then(
+    (out) => out.split(" ")[0] || null,
+    () => null
+  );
+}
+
+// A diff split by file, each without what a rebase legitimately changes
+// (blob ids, line offsets), so two diffs can be compared file by file.
+function byFile(diff: string): Map<string, string> {
+  const files = new Map<string, string>();
+  for (const part of diff.split(/^(?=diff --git )/m)) {
+    const name = part.match(/^diff --git a\/(.+?) b\//)?.[1];
+    if (!name) continue;
+    files.set(
+      name,
+      part
+        .split("\n")
+        .filter((l) => !l.startsWith("index "))
+        .map((l) =>
+          l.replace(/^(@@ )-\d+(?:,\d+)? \+\d+(?:,\d+)?( @@)/, "$1$2")
+        )
+        .join("\n")
+    );
+  }
+  return files;
+}
+
+const names = (list: string[]) =>
+  list.slice(0, 5).join(", ") +
+  (list.length > 5 ? ` and ${list.length - 5} more` : "");
+
+// What differs between two diffs, in a few words.
+export function describeChange(before: string, after: string): string {
+  const a = byFile(before);
+  const b = byFile(after);
+  const added = [...b.keys()].filter((f) => !a.has(f));
+  const removed = [...a.keys()].filter((f) => !b.has(f));
+  const changed = [...b.keys()].filter(
+    (f) => a.has(f) && a.get(f) !== b.get(f)
+  );
+  const parts = [
+    added.length && `now also touches ${names(added)}`,
+    removed.length && `no longer touches ${names(removed)}`,
+    changed.length && `changes differ in ${names(changed)}`,
+  ].filter(Boolean);
+  return parts.length
+    ? `its patch changed: ${parts.join("; ")}`
+    : "its patch changed";
+}
+
+// `from` and `to` against `base`: the same patch, or else a note on why not.
+// Fails closed: a commit or diff that can't be read is never "the same".
+export async function comparePatches(
+  repo: string,
+  base: string,
+  from: string,
+  to: string
+): Promise<{ same: boolean; note: string }> {
+  if (!(await gitOk(repo, ["cat-file", "-e", `${from}^{commit}`]))) {
+    await gitFetch(repo, ["--quiet", "--", "origin", from], {
+      timeout: 30000,
+    }).catch(() => undefined);
+    if (!(await gitOk(repo, ["cat-file", "-e", `${from}^{commit}`])))
+      return {
+        same: false,
+        note: `the earlier commit ${from.slice(0, 7)} can't be read here, so the patches can't be compared`,
+      };
+  }
+  const [before, after] = await Promise.all([
+    diffOf(repo, base, from),
+    diffOf(repo, base, to),
+  ]);
+  if (!before || !after)
+    return { same: false, note: "its patch can't be read to compare" };
+  const [x, y] = await Promise.all([idOf(repo, before), idOf(repo, after)]);
+  if (x && x === y) return { same: true, note: "same patch" };
+  return { same: false, note: describeChange(before, after) };
+}

package/lib/orchestrator/rebase.ts

@@ -29,6 +29,7 @@ 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 { comparePatches } from "./patch";
 import { outputOf, type Runner } from "../stacks/git";
 import { restackedHeads, stackNotice } from "../stacks/restack";
 import { getCheck, putCheck } from "./checks";
@@ -306,25 +307,6 @@ async function rebaseAt(
   }
 }
 
-// The PR's own patch against the base, as `git patch-id` sees it.
-async function patchId(repo: string, range: string): Promise<string | null> {
-  const diff = await runGit(repo, [
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--full-index",
-    range,
-  ]).catch(() => null);
-  if (!diff) return null;
-  return runGit(repo, ["patch-id", "--verbatim"], {
-    input: diff,
-    timeout: 30000,
-  }).then(
-    (out) => out.split(" ")[0] || null,
-    () => null
-  );
-}
-
 // The review of the head before the rebase, carried to the new head when
 // the PR's own patch is the same, else a fresh review of the new head.
 async function carryReview(
@@ -339,11 +321,7 @@ async function carryReview(
   const prior = getCheck(task.id, from, "review");
   const scope = getCheck(task.id, from, "scope");
   const repo = repoOf(task);
-  const [before, after] = await Promise.all([
-    patchId(repo, `${onto}...${from}`),
-    patchId(repo, `${onto}...${to}`),
-  ]);
-  const same = !!before && before === after;
+  const { same } = await comparePatches(repo, onto, from, to);
   if (
     same &&
     prior?.status === "pass" &&

package/lib/orchestrator/signoff.ts

@@ -29,6 +29,7 @@ import { evaluateGates, holdingEscalations, type GateInput } from "./gates";
 import { addNote } from "./notes";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
+import { carryApproval } from "./approval-carry";
 import { heldVerdict } from "./held";
 import { mergeApprovalsOn } from "./merge-approvals";
 import { isPaused } from "./pause";
@@ -170,7 +171,20 @@ export async function gateVerdict(
   // its stack parent merged: the orchestrator wrote that ask, and no answer
   // to it stands in for those. An approval of the gates' own ask on a held
   // task merges as it always has (heldVerdict).
-  const approval = latestApproval(workspaceId, workSubject(work.id));
+  let approval = latestApproval(workspaceId, workSubject(work.id));
+  // The head moved since he approved: his approval follows it when the PR's
+  // own patch is unchanged (a rebase), else the re-ask says what changed.
+  let moved: string | undefined;
+  if (approval?.sha && approval.sha !== sha) {
+    const carried = await carryApproval(
+      workspaceId,
+      work,
+      { ...approval, sha: approval.sha },
+      sha
+    );
+    if (carried.approval) approval = carried.approval;
+    else moved = carried.note;
+  }
   if (
     approval?.sha === sha &&
     (approval.raised_by === "orchestrator" || !held.length)
@@ -187,7 +201,7 @@ export async function gateVerdict(
     return { ok: true, sha, pr: pr.number, approval: approval.id };
   }
   if (held.length)
-    return heldVerdict(workspaceId, work, held, pr.url, sha, pr.number);
+    return heldVerdict(workspaceId, work, held, pr.url, sha, pr.number, moved);
 
   const base = await fetchRefs(repo, work.refs);
   const files = await changedFiles(repo, base, sha);

package/lib/orchestrator/tools.ts

@@ -74,7 +74,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "Run a LumifyHub board's open cards as stacked tasks (each start braked), or with plan_only just show the plan.",
   stack_status: "One stack's items, PRs and progress.",
   land: "Merge a whole stack bottom-up, each PR through the sign-off gates at its current head.",
-  drop: "Reject a task: close its PR and remove its worktree. Logged with the reason.",
+  drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   add_project:

package/lib/orchestrator/watcher.ts

@@ -16,6 +16,7 @@ import { BRAKE_SUBJECT, openAsks } from "./asks";
 import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
+import { followAskHeads } from "./ask-heads";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
 import { awayTick } from "../away/run";
@@ -75,6 +76,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await wakeTasks(workspaceId, facts).catch((error) =>
       console.error(`Waking tasks in ${workspaceId}:`, error)
     );
+    await followAskHeads(workspaceId, facts).catch((error) =>
+      console.error(`Following ask heads in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/tasks/queue.ts

@@ -161,11 +161,19 @@ export function hasFinished(taskId: string): boolean {
   return !q || (q.status !== "queued" && q.status !== "starting");
 }
 
+// Still something to wait for under "any": in flight, and not a task whose
+// PR was closed or merged and which nobody finished (that one never will).
+function stillWorking(taskId: string): boolean {
+  if (hasFinished(taskId)) return false;
+  const s = sessionOf(taskId);
+  return !s || (s.pr_status !== "closed" && s.pr_status !== "merged");
+}
+
 export function afterMet(r: QueueRow): boolean {
   if (r.after_task && !hasFinished(r.after_task)) return false;
   if (r.after_any) {
     const ids = JSON.parse(r.after_any) as string[];
-    if (ids.length && !ids.some(hasFinished)) return false;
+    if (ids.length && !ids.some((id) => !stillWorking(id))) return false;
   }
   return true;
 }
@@ -244,9 +252,17 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   let afterTask: string | null = null;
   let afterAny: string[] | null = null;
   const after = req.after?.trim();
-  if (after && after.toLowerCase() === "any")
-    afterAny = runningIn({ workspaceId, projectId: project.id });
-  else if (after)
+  // "any" with nothing working is nothing to wait for: it starts at once.
+  let waits = !!after;
+  if (after && after.toLowerCase() === "any") {
+    afterAny = runningIn({ workspaceId, projectId: project.id }).filter(
+      stillWorking
+    );
+    if (!afterAny.length) {
+      afterAny = null;
+      waits = false;
+    }
+  } else if (after)
     afterTask = resolveAfter(after, req.originWorkspaceId ?? workspaceId).id;
   const full =
     limit !== null &&
@@ -255,7 +271,7 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
       startingIn(workspaceId) >=
       limit ||
       waitingIn(workspaceId) > 0);
-  if (!after && !full) return null;
+  if (!waits && !full) return null;
   if (!req.prompt.trim()) throw new Error("Describe the task");
   const id = randomUUID();
   db.prepare(
@@ -588,6 +604,36 @@ export async function startQueuedNow(id: string): Promise<StartOutcome> {
   return startRow(r, { force: true });
 }
 
+// A task still waiting in the line (or failed to start) by id, an id prefix
+// of 4+ characters or, when asked, its name; in one workspace.
+export function findQueued(
+  workspaceId: string,
+  ref: string,
+  opts: { byName?: boolean } = {}
+): QueueRow | null {
+  const want = ref.trim();
+  const rows = db
+    .prepare(
+      `SELECT q.* FROM task_queue q JOIN projects p ON p.id = q.project_id
+       WHERE p.workspace_id = ? AND q.status IN ('queued', 'failed')`
+    )
+    .all(workspaceId) as QueueRow[];
+  const lower = want.toLowerCase();
+  const hits = rows.filter(
+    (r) =>
+      r.id === want ||
+      (want.length >= 4 && r.id.startsWith(want)) ||
+      (opts.byName && label(r).toLowerCase() === lower)
+  );
+  if (hits.length > 1)
+    throw new Error(
+      `"${ref}" matches ${hits.length} queued tasks: ${hits.map((h) => `${label(h)} (${h.id.slice(0, 8)})`).join(", ")}`
+    );
+  return hits[0] ?? null;
+}
+
+export const queuedLabel = label;
+
 export function removeQueued(id: string): void {
   const changed = db
     .prepare(

package/package.json

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