@saadnvd1/agent-os 0.3.502 → 0.3.503

package/components/Pane/DesktopTabBar.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { SessionPrStage } from "@/components/PrStageBadge";
 import { ViewSwitch } from "@/components/Chat/ViewSwitch";
 import { ContextMeter } from "@/components/Chat/ContextMeter";
 import { Button } from "@/components/ui/button";
@@ -155,6 +156,7 @@ export function DesktopTabBar({
       <div className="flex shrink-0 items-center gap-1.5">
         <HostBadge hostId={session?.host_id} />
         <ContextMeter sessionId={session?.id} />
+        <SessionPrStage sessionId={session?.id} />
         <ViewSwitch session={session} />
         {session?.working_directory && (
           <PaneViewToggle

package/components/Pane/MobileTabBar.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { SessionPrStage } from "@/components/PrStageBadge";
 import { ViewSwitch } from "@/components/Chat/ViewSwitch";
 import { paletteActions } from "@/stores/palette";
 import { newDraft } from "@/stores/drafts";
@@ -317,6 +318,7 @@ export function MobileTabBar({
       >
         <Plus className="h-4 w-4" />
       </Button>
+      <SessionPrStage sessionId={session?.id} />
       <ViewSwitch session={session} />
 
       {/* View mode toggle */}

package/components/PrStageBadge.tsx

@@ -0,0 +1,69 @@
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { Loader2 } from "lucide-react";
+import { statusKeys } from "@/data/sessions/keys";
+import {
+  PR_STAGE_BUSY,
+  prStageText,
+  type PrStage,
+  type PrStageName,
+} from "@/lib/tasks/pr-stage";
+import { cn } from "@/lib/utils";
+
+const TONE: Record<PrStageName, string> = {
+  merged: "bg-purple-500/15 text-purple-700 dark:text-purple-400",
+  conflicts: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
+  "ci-failed": "bg-red-500/15 text-red-700 dark:text-red-400",
+  "ci-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "ci-settling": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "review-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "review-blocked": "bg-red-500/15 text-red-700 dark:text-red-400",
+  waiting: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
+  armed: "bg-green-500/15 text-green-700 dark:text-green-400",
+  open: "bg-muted text-muted-foreground",
+};
+
+// Where a task's PR is in the gates, linking to the PR. `compact` drops the
+// "PR #n" for the sidebar row's tight space (the number stays in the title).
+export function PrStageBadge({
+  stage,
+  compact = false,
+}: {
+  stage?: PrStage;
+  compact?: boolean;
+}) {
+  if (!stage) return null;
+  const text = prStageText(stage);
+  return (
+    <a
+      href={stage.url}
+      target="_blank"
+      rel="noreferrer"
+      title={`${text}${stage.sha ? ` · ${stage.sha}` : ""}`}
+      aria-label={text}
+      onClick={(e) => e.stopPropagation()}
+      className={cn(
+        "inline-flex shrink-0 items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] font-semibold whitespace-nowrap hover:underline",
+        TONE[stage.stage]
+      )}
+    >
+      {PR_STAGE_BUSY.has(stage.stage) && (
+        <Loader2 className="h-3 w-3 animate-spin" aria-hidden />
+      )}
+      {compact ? text.replace("PR ", "") : text}
+    </a>
+  );
+}
+
+// The badge for one session, read from the status the sidebar already holds.
+export function SessionPrStage({ sessionId }: { sessionId?: string | null }) {
+  const { data } = useQuery<{
+    statuses: Record<string, { prStage?: PrStage }>;
+  }>({ queryKey: statusKeys.all, enabled: false });
+  return (
+    <PrStageBadge
+      stage={sessionId ? data?.statuses[sessionId]?.prStage : undefined}
+    />
+  );
+}

package/components/SessionList/SessionList.types.ts

@@ -1,3 +1,4 @@
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { SessionNeed } from "@/lib/sidebar/shelves";
 
 export interface SessionStatus {
@@ -11,6 +12,7 @@ export interface SessionStatus {
   unread?: boolean;
   stalled?: boolean;
   compacting?: { since: number; before?: number };
+  prStage?: PrStage;
 }
 
 export interface SessionListProps {

package/components/SessionList/SessionRow.tsx

@@ -12,6 +12,7 @@ import { QuickChangeRow } from "./QuickChangeRow";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowShell, type RowMenuKind } from "./RowShell";
+import { PrStageBadge } from "@/components/PrStageBadge";
 import { RowBadge, RowDot, RowRename } from "./RowParts";
 import { RowSubtitle } from "./RowSubtitle";
 import { OrchestratorAsks } from "./OrchestratorAsks";
@@ -96,6 +97,7 @@ export const SessionRow = memo(function SessionRow({
         trailing={
           <>
             <RowBadge row={row} />
+            {!row.need && <PrStageBadge stage={row.status?.prStage} compact />}
             {!row.need && <TimeAgo at={session.updated_at} />}
           </>
         }

package/components/views/types.ts

@@ -1,3 +1,4 @@
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { SessionNeed } from "@/lib/sidebar/shelves";
 import type { Session } from "@/lib/db";
 import type { ProjectWithDevServers } from "@/lib/projects";
@@ -15,6 +16,7 @@ export interface SessionStatus {
   unread?: boolean;
   // A chat summarising its context; status stays "running".
   compacting?: { since: number; before?: number };
+  prStage?: PrStage;
   claudeSessionId?: string | null;
   // From a program's OSC 7501 report: untrusted, rendered as plain text.
   detail?: string | null;

package/lib/orchestrator/armed.ts

@@ -12,6 +12,7 @@
  * database, so it survives a restart.
  */
 
+import { notifyStatusChanged } from "../status/hub";
 import { db, type Session } from "../db";
 import type { TaskPR } from "../tasks/state";
 import { latestApproval } from "./ask-approvals";
@@ -37,6 +38,7 @@ export function setArmed(sessionId: string, armed: boolean): void {
        merge_armed_seen = NULL WHERE id = ?`
   ).run(sessionId);
   looked.delete(sessionId);
+  notifyStatusChanged();
 }
 
 // The workspace a task's PR merges through when armed: its project's, with

package/lib/orchestrator/checks.ts

@@ -5,6 +5,7 @@
  */
 
 import { db } from "../db";
+import { notifyStatusChanged } from "../status/hub";
 
 // ci: when the check count on a commit last changed, for settling.
 export type CheckKind = "review" | "scope" | "ci";
@@ -57,6 +58,7 @@ export function putCheck(row: {
     row.status,
     row.detail ?? null
   );
+  notifyStatusChanged();
   return getCheck(row.sessionId, row.sha, row.kind)!;
 }
 

package/lib/orchestrator/facts.ts

@@ -200,6 +200,7 @@ export async function statusOf(s: Session): Promise<{
 
 // A commit's time never changes: read once per sha.
 const committed = new Map<string, number>();
+export const knownCommitTime = (sha: string) => committed.get(sha) ?? 0;
 
 export async function settleIn(
   workspaceId: string,

package/lib/orchestrator/task-state.ts

@@ -114,6 +114,20 @@ async function peerChatWaiting(
 // check has registered on it for 2 minutes. Seconds still to wait.
 export const SETTLE_S = 120;
 
+// When the check count last changed, as ciSettleIn stored it.
+const lastSeen = (detail: string | null | undefined) =>
+  detail ? (JSON.parse(detail) as { count: number; at: number }) : null;
+
+const settleLeft = (
+  last: { count: number; at: number } | null,
+  checkCount: number,
+  committedAt: number,
+  now: number
+) => {
+  const changedAt = last && last.count === checkCount ? last.at : now;
+  return Math.max(0, Math.max(committedAt, changedAt) + SETTLE_S - now);
+};
+
 export function ciSettleIn(input: {
   workspaceId: string;
   taskId: string;
@@ -123,11 +137,7 @@ export function ciSettleIn(input: {
   now?: number;
 }): number {
   const now = Math.floor((input.now ?? Date.now()) / 1000);
-  const seen = getCheck(input.taskId, input.sha, "ci");
-  const last = seen?.detail
-    ? (JSON.parse(seen.detail) as { count: number; at: number })
-    : null;
-  const changedAt = last && last.count === input.checkCount ? last.at : now;
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
   if (!last || last.count !== input.checkCount)
     putCheck({
       workspaceId: input.workspaceId,
@@ -137,8 +147,21 @@ export function ciSettleIn(input: {
       status: "pass",
       detail: JSON.stringify({ count: input.checkCount, at: now }),
     });
-  const settledAt = Math.max(input.committedAt, changedAt) + SETTLE_S;
-  return Math.max(0, settledAt - now);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
+}
+
+// The same answer from what ciSettleIn stored, writing nothing: for a
+// status that only looks.
+export function ciSettleLeft(input: {
+  taskId: string;
+  sha: string;
+  checkCount: number;
+  committedAt: number;
+  now?: number;
+}): number {
+  const now = Math.floor((input.now ?? Date.now()) / 1000);
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
 }
 
 // A head with no checks for this long after its PR became mergeable, in a

package/lib/sidebar/shelves.ts

@@ -2,6 +2,7 @@
 // orchestrator, Pinned, Needs you, Working, then Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { TaskState } from "@/lib/tasks/state";
 
 // Why a session is blocked on you.
@@ -33,6 +34,7 @@ export interface RowStatus {
   // A chat summarising its context (status stays "running").
   compacting?: { since: number; before?: number };
   asks?: number;
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
 }
@@ -264,6 +266,9 @@ function sameStatus(a: RowStatus | undefined, b: RowStatus | undefined) {
     (a.compacting?.since ?? null) === (b.compacting?.since ?? null) &&
     (a.compacting?.before ?? null) === (b.compacting?.before ?? null) &&
     a.asks === b.asks &&
+    (a.prStage?.stage ?? null) === (b.prStage?.stage ?? null) &&
+    (a.prStage?.number ?? null) === (b.prStage?.number ?? null) &&
+    (a.prStage?.sha ?? null) === (b.prStage?.sha ?? null) &&
     (a.detail ?? null) === (b.detail ?? null)
   );
 }

package/lib/status/collect.ts

@@ -30,6 +30,8 @@ import {
   terminalStatus,
 } from "../needs-you";
 import type { SessionNeed } from "../sidebar/shelves";
+import type { PrStage } from "../tasks/pr-stage";
+import { addPrStages } from "./pr-stages";
 import type { Compacting } from "../chat/events";
 import { openAskCount } from "../orchestrator/asks";
 import { lastUserTask } from "../chat/store";
@@ -65,6 +67,8 @@ export interface SessionStatusResponse {
   stalled?: boolean;
   // A chat whose agent is summarising its context ("status" stays running).
   compacting?: Compacting;
+  // Where a task's PR is in the gates (lib/tasks/pr-stage.ts).
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
   progress?: number | null;
@@ -477,6 +481,8 @@ async function collect(): Promise<StatusSnapshot> {
     };
   }
 
+  addPrStages(statusMap);
+
   // Cleanup old trackers
   statusDetector.cleanup();
 

package/lib/status/pr-stages.ts

@@ -0,0 +1,55 @@
+// A task's PR stage for the sidebar, from state AgentOS already holds: the
+// PR as the last poll saw it, the stored review and CI checks, escalations,
+// asks and the armed flag. Nothing here asks GitHub.
+import { db, type Session } from "../db";
+import { cachedPR, storedPR } from "../tasks/session";
+import { derivePrStage } from "../tasks/pr-stage";
+import { getCheck } from "../orchestrator/checks";
+import { holdingEscalations } from "../orchestrator/gates";
+import { openBySubject, workSubject } from "../orchestrator/asks";
+import { ciSettleLeft } from "../orchestrator/task-state";
+import { knownCommitTime } from "../orchestrator/facts";
+import type { SessionStatusResponse } from "./collect";
+
+type TaskRow = Session & { workspace_id: string };
+
+export function addPrStages(
+  statuses: Record<string, SessionStatusResponse>
+): void {
+  const tasks = db
+    .prepare(
+      `SELECT s.*, p.workspace_id FROM sessions s
+         JOIN projects p ON p.id = s.project_id
+        WHERE s.task_status = 'running' AND s.pr_number IS NOT NULL
+          AND s.archived_at IS NULL`
+    )
+    .all() as TaskRow[];
+  for (const t of tasks) {
+    const status = statuses[t.id];
+    if (!status) continue;
+    try {
+      const pr = cachedPR(t.id) ?? storedPR(t);
+      const head = pr?.head;
+      const stage = derivePrStage({
+        pr,
+        settleIn:
+          pr?.checks === "pass" && head
+            ? ciSettleLeft({
+                taskId: t.id,
+                sha: head,
+                checkCount: pr.checkCount ?? 0,
+                committedAt: knownCommitTime(head),
+              })
+            : 0,
+        review: head ? (getCheck(t.id, head, "review")?.status ?? null) : null,
+        held:
+          holdingEscalations(t.id).length > 0 ||
+          !!openBySubject(t.workspace_id, workSubject(t.id)),
+        armed: !!t.merge_armed_at,
+      });
+      if (stage) status.prStage = stage;
+    } catch (error) {
+      console.error(`[status] PR stage of ${t.id.slice(0, 8)}:`, error);
+    }
+  }
+}

package/lib/tasks/pr-stage.ts

@@ -0,0 +1,92 @@
+// Where a task's PR is in the gates, as one word for the UI. Pure: the
+// inputs are what AgentOS already tracks for the PR (tasks/state.ts,
+// orchestrator/checks.ts), so nothing here asks GitHub or a model.
+
+export const PR_STAGES = [
+  "merged",
+  "conflicts",
+  "ci-failed",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+  "review-blocked",
+  "waiting",
+  "armed",
+  "open",
+] as const;
+
+export type PrStageName = (typeof PR_STAGES)[number];
+
+export interface PrStage {
+  stage: PrStageName;
+  number: number;
+  url: string;
+  // The PR's head, 7 characters.
+  sha?: string;
+}
+
+export interface PrStageInput {
+  pr: {
+    number: number;
+    url: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    checks: "pass" | "fail" | "pending" | "none";
+    head?: string;
+    mergeable?: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  } | null;
+  // Seconds until CI on the head counts as settled (0 or unset: settled).
+  settleIn?: number;
+  // The newest review of the head commit.
+  review?: "running" | "pass" | "block" | "error" | null;
+  // Escalated to Saad, or an ask of his open on it.
+  held?: boolean;
+  armed?: boolean;
+}
+
+// In priority order: the first that applies wins, so a conflict hides the
+// CI behind it and a failed CI hides a review that would be moot.
+export function derivePrStage(input: PrStageInput): PrStage | null {
+  const { pr } = input;
+  if (!pr || pr.state === "CLOSED") return null;
+  const base = {
+    number: pr.number,
+    url: pr.url,
+    ...(pr.head && { sha: pr.head.slice(0, 7) }),
+  };
+  const at = (stage: PrStageName): PrStage => ({ stage, ...base });
+  if (pr.state === "MERGED") return at("merged");
+  if (pr.mergeable === "CONFLICTING") return at("conflicts");
+  if (pr.checks === "fail") return at("ci-failed");
+  if (pr.checks === "pending") return at("ci-running");
+  if (pr.checks === "pass" && (input.settleIn ?? 0) > 0)
+    return at("ci-settling");
+  if (input.review === "running") return at("review-running");
+  if (input.review === "block") return at("review-blocked");
+  if (input.held) return at("waiting");
+  if (input.armed) return at("armed");
+  return at("open");
+}
+
+// Stages still moving on their own: the badge spins for these.
+export const PR_STAGE_BUSY: ReadonlySet<PrStageName> = new Set([
+  "conflicts",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+]);
+
+export const PR_STAGE_LABEL: Record<PrStageName, string> = {
+  merged: "merged",
+  conflicts: "rebasing",
+  "ci-failed": "CI failed",
+  "ci-running": "CI running",
+  "ci-settling": "CI settling",
+  "review-running": "reviewing",
+  "review-blocked": "review blocked",
+  waiting: "waiting on you",
+  armed: "armed",
+  open: "open",
+};
+
+export const prStageText = (s: Pick<PrStage, "stage" | "number">) =>
+  `PR #${s.number} · ${PR_STAGE_LABEL[s.stage]}`;

package/lib/tasks/session.ts

@@ -9,6 +9,7 @@ import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
+import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
@@ -128,6 +129,15 @@ export const isoUTC = (t: string) =>
 
 const prCache = new Map<string, { at: number; pr: TaskPR | null }>();
 
+const prSignature = (pr: TaskPR | null | undefined) =>
+  pr
+    ? `${pr.number}|${pr.state}|${pr.checks}|${pr.head}|${pr.mergeable}|${pr.checkCount}`
+    : "";
+
+// The PR as the last poll saw it, with no gh call; undefined before one.
+export const cachedPR = (sessionId: string): TaskPR | null | undefined =>
+  prCache.get(sessionId)?.pr;
+
 // strict: a gh failure throws instead of reading as "no PR".
 export async function prFor(
   session: Session,
@@ -167,7 +177,10 @@ export async function prFor(
     }
   }
   if (renamed && !refused) moveBranch(session, renamed);
+  const before = prCache.get(session.id)?.pr;
   prCache.set(session.id, { at: Date.now(), pr });
+  // A PR whose stage inputs moved is news for the sidebar's badge.
+  if (prSignature(before) !== prSignature(pr)) notifyStatusChanged();
   if (pr) {
     db.prepare(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`

package/package.json

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