@saadnvd1/agent-os 0.3.567 → 0.3.569

package/components/Usage/WindowCard.tsx

@@ -19,29 +19,40 @@ export function WindowCard({
   window: WindowView | null | undefined;
 }) {
   const level = w ? meterLevel(w.pct) : "ok";
+  const stale = !!w?.stale;
   return (
     <div className="bg-foreground/[0.03] space-y-2 rounded-xl p-3">
       <div className="flex items-baseline justify-between gap-2">
         <span className="text-muted-foreground text-xs">{label}</span>
-        <span className="text-lg font-semibold tabular-nums">
+        <span
+          className={cn(
+            "text-lg font-semibold tabular-nums",
+            stale && "text-muted-foreground"
+          )}
+        >
           {w ? `${w.estimated ? "~" : ""}${w.pct}%` : "–"}
         </span>
       </div>
       <div className="bg-foreground/10 h-1.5 overflow-hidden rounded-full">
         <div
-          className={cn("h-full rounded-full", BAR[level])}
+          className={cn(
+            "h-full rounded-full",
+            stale ? "bg-foreground/30" : BAR[level]
+          )}
           style={{ width: `${Math.min(w?.pct ?? 0, 100)}%` }}
         />
       </div>
       <p className="text-muted-foreground text-[11px]">
         {w?.estimated && "Estimate from recorded usage · "}
         {!w
-          ? "Not available"
-          : w.capsIn
-            ? `Runs out in ${formatDuration(w.capsIn)} at this rate`
-            : w.resetsIn !== null
-              ? `Resets in ${formatDuration(w.resetsIn)}`
-              : "Used"}
+          ? "Not sampled"
+          : w.stale
+            ? `Last seen ${w.ageSec !== undefined ? `${formatDuration(w.ageSec)} ago` : "a while ago"}${w.resetsIn !== null ? ` · resets in ${formatDuration(w.resetsIn)}` : ""}`
+            : w.capsIn
+              ? `Runs out in ${formatDuration(w.capsIn)} at this rate`
+              : w.resetsIn !== null
+                ? `Resets in ${formatDuration(w.resetsIn)}`
+                : "Used"}
       </p>
     </div>
   );

package/lib/git-remote.ts

@@ -0,0 +1,47 @@
+// Which GitHub repository a folder is a clone of ("owner/repo", lower
+// case), read from its origin's URL as configured, with no gh call. Kept free
+// of the task and orchestrator modules so plan checks can use it.
+
+import { git, gitSync } from "./git-exec";
+
+const GITHUB_REMOTE =
+  /^(?:https?:\/\/(?:[^@/]+@)?|ssh:\/\/(?:[^@/]+@)?|[^@/:]+@)github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i;
+
+export function slugOfRemote(url: string | null | undefined): string | null {
+  const m = GITHUB_REMOTE.exec((url ?? "").trim());
+  return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
+}
+
+// A remote's URL doesn't change under a running server often enough to ask
+// git on every lookup.
+const SLUG_TTL_MS = 5 * 60 * 1000;
+const slugs = new Map<string, { at: number; slug: string | null }>();
+
+export async function repoSlug(dir: string): Promise<string | null> {
+  const hit = slugs.get(dir);
+  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
+  const url = await git(dir, ["config", "--get", "remote.origin.url"], {
+    timeout: 10000,
+  }).catch(() => "");
+  const slug = slugOfRemote(url);
+  slugs.set(dir, { at: Date.now(), slug });
+  return slug;
+}
+
+// The same, without waiting: a cached local `git config` read for callers that
+// can't be async. Null when the folder isn't a GitHub clone.
+export function repoSlugSync(dir: string): string | null {
+  const hit = slugs.get(dir);
+  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
+  let url = "";
+  try {
+    url = gitSync(dir, ["config", "--get", "remote.origin.url"], {
+      timeout: 5000,
+    });
+  } catch {
+    url = "";
+  }
+  const slug = slugOfRemote(url);
+  slugs.set(dir, { at: Date.now(), slug });
+  return slug;
+}

package/lib/orchestrator/brief.ts

@@ -8,7 +8,7 @@ import { mergeApprovalsOn } from "./merge-approvals";
 import { noApprovalsOn } from "../approvals/no-approvals";
 import { buildDigest } from "./digest";
 
-const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or can't be read at all. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
+const BRAKES_ON = `Starting work (\`start_task\`, \`start_session\`, \`stack\`) is braked: at most a set number of sessions running in this workspace (4 by default), at most a set number of starts an hour (6 by default), and nothing new once the account's usage window would run out before it resets, or isn't being sampled and was near its cap when last seen. Each card of a stack you start counts as a start of its own; a braked card waits in the stack. A brake refuses the start with its reason and writes one note; running work carries on. Don't retry a braked start in a loop: carry on with reviews, answers and merges, and start again when a later event gives you reason to.`;
 
 const BRAKES_OFF = `Starting work has no limits right now: no cap on running sessions or starts, and no usage-window check. Saad's Pause still stops new starts; the start tools say so when it's on.`;
 

package/lib/orchestrator/repo-slug.ts

@@ -4,33 +4,11 @@
 // of its projects'.
 
 import type { Project } from "../db";
-import { git } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { workspaceProjects } from "./brief";
+import { repoSlug } from "../git-remote";
 
-const GITHUB_REMOTE =
-  /^(?:https?:\/\/(?:[^@/]+@)?|ssh:\/\/(?:[^@/]+@)?|[^@/:]+@)github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i;
-
-export function slugOfRemote(url: string | null | undefined): string | null {
-  const m = GITHUB_REMOTE.exec((url ?? "").trim());
-  return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
-}
-
-// A remote's URL doesn't change under a running server often enough to ask
-// git on every lookup.
-const SLUG_TTL_MS = 5 * 60 * 1000;
-const slugs = new Map<string, { at: number; slug: string | null }>();
-
-export async function repoSlug(dir: string): Promise<string | null> {
-  const hit = slugs.get(dir);
-  if (hit && Date.now() - hit.at < SLUG_TTL_MS) return hit.slug;
-  const url = await git(dir, ["config", "--get", "remote.origin.url"], {
-    timeout: 10000,
-  }).catch(() => "");
-  const slug = slugOfRemote(url);
-  slugs.set(dir, { at: Date.now(), slug });
-  return slug;
-}
+export { repoSlug, repoSlugSync, slugOfRemote } from "../git-remote";
 
 export interface WorkspaceRepo {
   project: Project;

package/lib/orchestrator/usage.ts

@@ -1,17 +1,20 @@
 /**
  * Where the account's 5-hour usage window stands, ported from dispatch's
- * `account_limit`. The statusline in ~/dev/dev-settings samples the window's
- * used percentage into limits.json, keyed on when it resets; this only reads
- * it. A sample that's a little stale or about a window that already reset
- * says nothing about the burn rate, so the projection is skipped. But a
- * file that's missing, unreadable or not sampled for 15 minutes means the
- * window can't be checked at all, and then starts are refused: the brake
- * fails closed.
+ * `account_limit`. Two things sample it: AgentOS's own agents (every
+ * rate-limit event a chat worker sees is stored in `rate_limit_readings`) and
+ * the terminal statusline, which writes limits.json. This reads both and uses
+ * whichever was sampled last, never mixing their samples. A sample that's a
+ * little stale or about a window that already reset says nothing about the
+ * burn rate, so the projection is skipped. Past 15 minutes without a sample
+ * the window is unknown: that is said plainly, with the last value seen, and
+ * a start is refused only when nothing was ever sampled or the last value was
+ * near the cap and its window hasn't reset.
  */
 
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { lastAgentActivity, windowSamples } from "../usage/rate-limits";
 
 export const LIMITS_FILE =
   process.env.AGENTOS_LIMITS_FILE ??
@@ -72,31 +75,110 @@ export function usageWindow(
 
 // Past this the window can't be vouched for at all (seconds).
 const UNKNOWN_AFTER = 15 * 60;
+// A start is refused on an unknown window only when it was this full.
+const STALE_REFUSE_PCT = 90;
 
-export type UsageState = { window: UsageWindow | null } | { unknown: string };
+// What was last seen of the window, however long ago (seconds).
+export interface LastSeen {
+  pct: number;
+  resetsAt: number | null;
+  sampledAt: number;
+}
 
-export function readUsage(
-  file = LIMITS_FILE,
-  nowSec = Date.now() / 1000
-): UsageState {
-  let state: LimitsFile;
+export type UsageState =
+  | { window: UsageWindow | null }
+  | { unknown: string; last?: LastSeen | null };
+
+export interface Series {
+  window: number | null;
+  samples: [number, number][];
+}
+
+function readLimitsFile(file: string): LimitsFile | null {
   try {
-    state = JSON.parse(fs.readFileSync(file, "utf8")) as LimitsFile;
+    return JSON.parse(fs.readFileSync(file, "utf8")) as LimitsFile;
   } catch {
-    return { unknown: `the usage window can't be read (${file})` };
+    return null;
   }
-  const samples = Array.isArray(state.samples)
+}
+
+function toSeries(state: LimitsFile | null): Series | null {
+  const samples = Array.isArray(state?.samples)
     ? (state.samples as unknown[][])
+        .map((s) => [Number(s[0]), Number(s[1])] as [number, number])
+        .filter(([at, pct]) => Number.isFinite(at) && Number.isFinite(pct))
     : [];
-  const newest = Number(samples.at(-1)?.[0]);
-  if (!Number.isFinite(newest))
-    return { unknown: "the usage window has no samples" };
-  const age = nowSec - newest;
-  if (age > UNKNOWN_AFTER)
-    return {
-      unknown: `the usage window was last sampled ${minutes(age)} ago, so it can't be checked`,
-    };
-  return { window: usageWindow(state, nowSec) };
+  if (!samples.length) return null;
+  return {
+    window: typeof state?.window === "number" ? state.window : null,
+    samples,
+  };
+}
+
+function storedSeries(): Series | null {
+  const { resetsAt, samples } = windowSamples("five_hour");
+  return samples.length
+    ? { window: resetsAt === null ? null : resetsAt / 1000, samples }
+    : null;
+}
+
+// A ledger that can't be read is a source with nothing in it.
+const quietly = <T>(read: () => T | null): T | null => {
+  try {
+    return read();
+  } catch {
+    return null;
+  }
+};
+
+const clock = (sec: number, nowSec: number): string => {
+  const d = new Date(sec * 1000);
+  const time = d.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+  return d.toDateString() === new Date(nowSec * 1000).toDateString()
+    ? time
+    : `${d.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${time}`;
+};
+
+// Why the window isn't known: nothing was ever sampled, no agent has run
+// since the last sample, or agents ran without reporting it.
+export function unknownText(
+  sampledAt: number | null,
+  activityAt: number | null,
+  nowSec: number
+): string {
+  if (sampledAt === null)
+    return "No agent has reported the usage window yet, so usage isn't sampled";
+  if (activityAt === null || activityAt / 1000 <= sampledAt + 60)
+    return `No agent has run since ${clock(sampledAt, nowSec)}, so usage isn't sampled`;
+  return `Agents ran at ${clock(activityAt / 1000, nowSec)} but didn't report the usage window; it was last sampled at ${clock(sampledAt, nowSec)}`;
+}
+
+export function readUsage(
+  file = LIMITS_FILE,
+  nowSec = Date.now() / 1000,
+  stored: () => Series | null = storedSeries,
+  activity: () => number | null = lastAgentActivity
+): UsageState {
+  const newestAt = (s: Series) => s.samples[s.samples.length - 1][0];
+  const sources = [toSeries(readLimitsFile(file)), quietly(stored)].filter(
+    (s): s is Series => s !== null
+  );
+  const chosen = sources.sort((a, b) => newestAt(b) - newestAt(a))[0] ?? null;
+  const sampledAt = chosen ? newestAt(chosen) : null;
+  if (chosen && sampledAt !== null && nowSec - sampledAt <= UNKNOWN_AFTER)
+    return { window: usageWindow(chosen, nowSec) };
+  const activityAt = quietly(activity);
+  const newest = chosen && chosen.samples[chosen.samples.length - 1];
+  return {
+    unknown: unknownText(sampledAt, activityAt, nowSec),
+    last:
+      chosen && newest && sampledAt !== null
+        ? { pct: Math.trunc(newest[1]), resetsAt: chosen.window, sampledAt }
+        : null,
+  };
 }
 
 function minutes(seconds: number): string {
@@ -104,11 +186,21 @@ function minutes(seconds: number): string {
   return m >= 60 ? `${Math.floor(m / 60)}h${m % 60}m` : `${m}m`;
 }
 
-// Why the window refuses a new start, or null.
+// Why the window refuses a new start, or null. An unknown window refuses
+// unless it was last seen low or its window has since reset: nothing is
+// sampling, so the figure can't have moved, and the next start's own run
+// samples it again.
 export function windowRefusal(
-  state: UsageState | UsageWindow | null
+  state: UsageState | UsageWindow | null,
+  nowSec = Date.now() / 1000
 ): string | null {
-  if (state && "unknown" in state) return state.unknown;
+  if (state && "unknown" in state) {
+    const last = state.last;
+    if (!last) return state.unknown;
+    if (last.resetsAt !== null && last.resetsAt <= nowSec) return null;
+    if (last.pct < STALE_REFUSE_PCT) return null;
+    return `${state.unknown}; it was ${last.pct}% used when last seen${last.resetsAt === null ? "" : ` and resets at ${clock(last.resetsAt, nowSec)}`}`;
+  }
   const w = state && "window" in state ? state.window : state;
   if (!w) return null;
   if (w.pct >= 100)

package/lib/plans/features.ts

@@ -7,6 +7,7 @@ import path from "path";
 import { randomUUID } from "crypto";
 import { db, type Session } from "../db";
 import { loadProjectConfig } from "../project-config";
+import { repoSlugSync, slugOfRemote } from "../git-remote";
 import {
   applyEdits,
   checkPieces,
@@ -77,6 +78,33 @@ function ref(id: string): ProjectRef | null {
   return { id: p.id, name: p.name, deploys: !!deploy?.deployed };
 }
 
+// A repo named in a plan resolves by project name, then by the repo's folder
+// name, then by its GitHub owner/name (or just the name part), ignoring case.
+// A folder or GitHub match must be a single project: two would be a guess.
+export function resolveRepo<
+  T extends { id: string; name: string; working_directory: string },
+>(rows: T[], token: string): T | null {
+  const want = token
+    .trim()
+    .replace(/^https?:\/\/github\.com\//i, "")
+    .replace(/\.git$/i, "")
+    .replace(/\/+$/, "")
+    .toLowerCase();
+  if (!want) return null;
+  const named = rows.filter((r) => r.name.toLowerCase() === want);
+  if (named.length) return named.length === 1 ? named[0] : null;
+  const folder = (r: T) =>
+    path.basename(expandHome(r.working_directory)).toLowerCase();
+  const byFolder = rows.filter((r) => folder(r) === want);
+  if (byFolder.length) return byFolder.length === 1 ? byFolder[0] : null;
+  const asSlug = slugOfRemote(`https://github.com/${want}`) ?? null;
+  const bySlug = rows.filter((r) => {
+    const slug = repoSlugSync(expandHome(r.working_directory));
+    return slug && (slug === asSlug || slug.split("/")[1] === want);
+  });
+  return bySlug.length === 1 ? bySlug[0] : null;
+}
+
 export function checkContext(
   s: Pick<Session, "project_id">
 ): CheckContext | null {
@@ -84,16 +112,14 @@ export function checkContext(
   if (!own) return null;
   const rows = db
     .prepare(
-      `SELECT id, name FROM projects
+      `SELECT id, name, working_directory FROM projects
        WHERE workspace_id = (SELECT workspace_id FROM projects WHERE id = ?)`
     )
-    .all(own.id) as { id: string; name: string }[];
+    .all(own.id) as { id: string; name: string; working_directory: string }[];
   return {
     own,
     find: (name) => {
-      const hit = rows.find(
-        (r) => r.name.toLowerCase() === name.trim().toLowerCase()
-      );
+      const hit = resolveRepo(rows, name);
       return hit ? ref(hit.id) : null;
     },
   };
@@ -122,10 +148,25 @@ export function piecesOf(featureId: string): FeaturePiece[] {
 
 export function pieceOfSession(sessionId: string): FeaturePiece | undefined {
   return db
-    .prepare(`SELECT * FROM feature_pieces WHERE session_id = ?`)
+    .prepare(
+      `SELECT * FROM feature_pieces WHERE session_id = ? ORDER BY position`
+    )
     .get(sessionId) as FeaturePiece | undefined;
 }
 
+// The PR a piece's task merged, when it is in the piece's own repository: a
+// session's PR is always in its project's repo, so another project's merge is
+// not this piece's work.
+export function prOf(p: FeaturePiece): number | null {
+  if (!p.session_id) return null;
+  const s = db
+    .prepare(`SELECT pr_number, project_id FROM sessions WHERE id = ?`)
+    .get(p.session_id) as
+    | { pr_number: number | null; project_id: string | null }
+    | undefined;
+  return s && s.project_id === p.project_id ? s.pr_number : null;
+}
+
 export function featureOfPlan(sessionId: string): Feature | undefined {
   return db
     .prepare(`SELECT * FROM features WHERE plan_session_id = ?`)

package/lib/plans/pieces.ts

@@ -208,7 +208,7 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
     const found = ctx.find(r.repo);
     if (!found)
       errors.push(
-        `"${r.name}": (repo: ${r.repo}) is not a project of this workspace`
+        `"${r.name}": (repo: ${r.repo}) doesn't match one project of this workspace (by name, folder or GitHub repo)`
       );
     return found ?? ctx.own;
   });

package/lib/plans/release.ts

@@ -9,13 +9,14 @@ import { createTask } from "../tasks";
 import { startOrQueue } from "../tasks/queue";
 import { braked, BrakeRefused } from "../orchestrator/brakes";
 import { queueEvent, queueEventOnce } from "../orchestrator/events";
-import { amendBrief } from "../orchestrator/amendments";
+import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
 import { usageRows } from "../session-logs/gather";
 import { pieceBrief } from "./pieces";
 import {
   getFeature,
   planPathOf,
   piecesOf,
+  prOf,
   type Feature,
   type FeaturePiece,
 } from "./features";
@@ -46,8 +47,10 @@ const setPiece = (id: number, status: string, note: string | null = null) =>
     .prepare(`UPDATE feature_pieces SET status = ?, note = ? WHERE id = ?`)
     .run(status, note, id);
 
+const RELEASED_ANYWAY = "released anyway";
+
 // What a piece's task did: merged, or ended some other way.
-function syncPieces(pieces: FeaturePiece[]): void {
+function syncPieces(feature: Feature, pieces: FeaturePiece[]): void {
   for (const p of pieces) {
     if (p.status !== "building") continue;
     const s = sessionOf(p.session_id);
@@ -65,8 +68,19 @@ function syncPieces(pieces: FeaturePiece[]): void {
       else if (!q) setPiece(p.id, "blocked", "its task is gone");
       continue;
     }
-    if (s.task_status === "merged") setPiece(p.id, "merged");
-    else if (s.task_status === "dropped" || s.task_status === "done")
+    if (s.task_status === "merged") {
+      // A PR counts only for a piece in its own repository.
+      if (s.project_id && s.project_id !== p.project_id) {
+        const where = getProject(s.project_id)?.name ?? "another project";
+        const note = `its task merged #${s.pr_number ?? "?"} in ${where}, not in ${getProject(p.project_id)?.name ?? "this piece's project"}`;
+        setPiece(p.id, "blocked", note);
+        say(
+          feature,
+          `wrong-repo-${p.id}`,
+          `Feature "${feature.name}": piece ${p.position} ${p.name} ${note}. If that PR already built it, drop the piece; otherwise release it anyway.`
+        );
+      } else setPiece(p.id, "merged");
+    } else if (s.task_status === "dropped" || s.task_status === "done")
       setPiece(p.id, "dropped", `its task was ${s.task_status}`);
   }
 }
@@ -141,11 +155,77 @@ function beforeLines(all: FeaturePiece[], upTo: number): string[] {
   return all
     .filter((p) => p.position < upTo && p.status === "merged")
     .map((p) => {
-      const pr = sessionOf(p.session_id)?.pr_number;
+      const pr = prOf(p);
       return `${p.position} ${p.name} merged${pr ? ` as #${pr}` : ""}`;
     });
 }
 
+// The planning task's own merge covers what it built in its repository: its
+// own piece there, else every piece still waiting there. A recorded scope
+// change means it may have built only part, so nothing is credited and the
+// duplicate guard asks a person instead.
+function creditParentMerge(feature: Feature, all: FeaturePiece[]): void {
+  const parent = sessionOf(feature.plan_session_id);
+  if (!parent || parent.task_status !== "merged" || !parent.project_id) return;
+  if (
+    all.some(
+      (p) => p.session_id === parent.id && p.project_id === parent.project_id
+    )
+  )
+    return;
+  if (amendmentsOf(parent.id).length) return;
+  const covered = all.filter(
+    (p) => p.status === "waiting" && p.project_id === parent.project_id
+  );
+  if (!covered.length) return;
+  for (const p of covered)
+    db.prepare(
+      `UPDATE feature_pieces SET status = 'merged', session_id = ?, note = ?
+       WHERE id = ? AND status = 'waiting'`
+    ).run(
+      parent.id,
+      `built by the planning task in #${parent.pr_number ?? "?"}`,
+      p.id
+    );
+  queueEventOnce(
+    feature.workspace_id,
+    `feature:parent-built-${feature.id}-${parent.pr_number}`,
+    feature.plan_session_id,
+    `Feature "${feature.name}": the planning task's own PR #${parent.pr_number} built ${covered.map((p) => `${p.position} ${p.name}`).join(", ")}, so ${covered.length === 1 ? "that piece is" : "those pieces are"} marked merged and won't start again.`
+  );
+}
+
+// A merged PR from this feature in the piece's repository that no merged
+// piece there accounts for may already contain the piece's work.
+function unaccountedMerge(
+  feature: Feature,
+  all: FeaturePiece[],
+  piece: FeaturePiece
+): Session | null {
+  const ids = new Set<string>([
+    feature.plan_session_id,
+    ...all.map((p) => p.session_id).filter((id): id is string => !!id),
+  ]);
+  for (const id of ids) {
+    const s = sessionOf(id);
+    if (
+      !s ||
+      s.task_status !== "merged" ||
+      !s.pr_number ||
+      s.project_id !== piece.project_id
+    )
+      continue;
+    const accounted = all.some(
+      (p) =>
+        p.status === "merged" &&
+        p.session_id === id &&
+        p.project_id === piece.project_id
+    );
+    if (!accounted) return s;
+  }
+  return null;
+}
+
 async function releaseOne(
   feature: Feature,
   all: FeaturePiece[],
@@ -183,6 +263,20 @@ async function releaseOne(
       }
     }
   }
+  if (piece.note !== RELEASED_ANYWAY) {
+    const dup = unaccountedMerge(feature, all, piece);
+    if (dup) {
+      const where = getProject(piece.project_id)?.name ?? "its project";
+      const note = `${where} already has #${dup.pr_number} merged from this feature; check it doesn't already build this`;
+      setPiece(piece.id, "blocked", note);
+      say(
+        feature,
+        `duplicate-${piece.id}`,
+        `Feature "${feature.name}": piece ${piece.position} ${piece.name} is held: ${note}. Release it anyway to start it, or drop it.`
+      );
+      return;
+    }
+  }
   const claimed = db
     .prepare(
       `UPDATE feature_pieces SET status = 'building', session_id = ?, note = NULL
@@ -229,8 +323,8 @@ function close(feature: Feature, all: FeaturePiece[], deps: ReleaseDeps): void {
     return;
   }
   if (live.some((p) => p.status !== "merged")) return;
-  const sessions = live
-    .map((p) => sessionOf(p.session_id))
+  const sessions = [...new Set(live.map((p) => p.session_id))]
+    .map((id) => sessionOf(id))
     .filter(Boolean) as Session[];
   const cost = sessions.reduce(
     (n, s) => n + usageRows(s.id).reduce((m, r) => m + r.costUsd, 0),
@@ -265,7 +359,7 @@ function close(feature: Feature, all: FeaturePiece[], deps: ReleaseDeps): void {
   say(
     feature,
     `done-${feature.id}`,
-    `Feature "${feature.name}" is merged: ${live.length} ${live.length === 1 ? "PR" : "PRs"}.${short}`
+    `Feature "${feature.name}" is merged: ${sessions.length} ${sessions.length === 1 ? "PR" : "PRs"}.${short}`
   );
   deps.pushFeatureMerged(feature);
 }
@@ -302,7 +396,8 @@ export async function releasePieces(
     .prepare(`SELECT * FROM features WHERE status = 'building'`)
     .all() as Feature[];
   for (const feature of features) {
-    syncPieces(piecesOf(feature.id));
+    syncPieces(feature, piecesOf(feature.id));
+    creditParentMerge(feature, piecesOf(feature.id));
     const all = piecesOf(feature.id);
     for (const piece of all.filter((p) => p.status === "waiting"))
       await releaseOne(feature, piecesOf(feature.id), piece, deps).catch((e) =>
@@ -319,9 +414,9 @@ export function releaseAnyway(pieceId: number): boolean {
     db
       .prepare(
         `UPDATE feature_pieces SET status = 'waiting', after_position = NULL,
-           after_kind = NULL, note = NULL WHERE id = ? AND status = 'blocked'`
+           after_kind = NULL, note = ? WHERE id = ? AND status = 'blocked'`
       )
-      .run(pieceId).changes > 0
+      .run(RELEASED_ANYWAY, pieceId).changes > 0
   );
 }
 

package/lib/plans/view.ts

@@ -2,7 +2,7 @@
 // is, and each piece's state in one line.
 
 import { db } from "../db";
-import { piecesOf, type Feature, type FeaturePiece } from "./features";
+import { piecesOf, prOf, type Feature, type FeaturePiece } from "./features";
 
 export interface PieceView {
   id: number;
@@ -40,13 +40,7 @@ const LINE = {
 };
 
 function pieceView(p: FeaturePiece): PieceView {
-  const pr = p.session_id
-    ? ((
-        db
-          .prepare(`SELECT pr_number FROM sessions WHERE id = ?`)
-          .get(p.session_id) as { pr_number: number | null } | undefined
-      )?.pr_number ?? null)
-    : null;
+  const pr = prOf(p);
   return {
     id: p.id,
     position: p.position,

package/lib/usage/rate-limits.ts

@@ -32,23 +32,38 @@ const num = (v: unknown) =>
 const eventPercent = (fraction: number) => fraction * 100;
 
 // Readings in what the CLI emits: a rate_limit_event's info, or a plan's
-// per-window object. Anything else gives none.
+// per-window object. Anything else gives none. An event's top-level reading
+// is only there when a threshold was crossed, while its `unifiedWindows`
+// (read from the same response headers) carries both windows every time, so
+// that one wins for a window both name.
 export function parseRateLimit(info: unknown): Reading[] {
   if (!info || typeof info !== "object") return [];
   const i = info as Record<string, unknown>;
-  const out: Reading[] = [];
+  const out = new Map<LimitWindow, Reading>();
   const status = typeof i.status === "string" ? i.status : null;
-  const type = i.rateLimitType;
-  const raw = num(i.utilization);
-  if ((type === "five_hour" || type === "seven_day") && raw !== null) {
-    const reset = num(i.resetsAt);
-    out.push({
-      window: type,
+  const eventReading = (
+    window: LimitWindow,
+    fraction: unknown,
+    resetsAt: unknown
+  ) => {
+    const raw = num(fraction);
+    if (raw === null) return;
+    const reset = num(resetsAt);
+    out.set(window, {
+      window,
       utilization: eventPercent(raw),
       raw,
       resetsAt: reset === null ? null : reset * 1000,
       status,
     });
+  };
+  const type = i.rateLimitType;
+  if (type === "five_hour" || type === "seven_day")
+    eventReading(type, i.utilization, i.resetsAt);
+  const unified = i.unifiedWindows as Record<string, unknown> | undefined;
+  for (const w of WINDOWS) {
+    const o = unified?.[w] as Record<string, unknown> | null | undefined;
+    if (o && typeof o === "object") eventReading(w, o.utilization, o.resetsAt);
   }
   for (const w of WINDOWS) {
     const o = i[w] as Record<string, unknown> | null | undefined;
@@ -56,7 +71,7 @@ export function parseRateLimit(info: unknown): Reading[] {
     if (!o || u === null || u === undefined) continue;
     const reset =
       typeof o.resets_at === "string" ? Date.parse(o.resets_at) : NaN;
-    out.push({
+    out.set(w, {
       window: w,
       utilization: u,
       raw: u,
@@ -64,11 +79,16 @@ export function parseRateLimit(info: unknown): Reading[] {
       status,
     });
   }
-  return out;
+  return [...out.values()];
 }
 
+// An unchanged reading refreshes the last row's time at most this often, so
+// the newest row's `at` is when the value was last seen, not when it moved.
+const REFRESH_MS = 60_000;
+
 // Stores a reading only when it differs from that window's last, so a busy
-// day adds a handful of rows, not one per response.
+// day adds a handful of rows, not one per response. A reading that hasn't
+// moved only touches the last row's time. Returns the rows added.
 export function recordReadings(
   readings: Reading[],
   source: string,
@@ -79,19 +99,31 @@ export function recordReadings(
   for (const r of readings) {
     const last = db
       .prepare(
-        `SELECT utilization, resets_at, status FROM rate_limit_readings
+        `SELECT id, at, utilization, resets_at, status FROM rate_limit_readings
          WHERE window = ? ORDER BY id DESC LIMIT 1`
       )
       .get(r.window) as
-      | { utilization: number; resets_at: number | null; status: string | null }
+      | {
+          id: number;
+          at: number;
+          utilization: number;
+          resets_at: number | null;
+          status: string | null;
+        }
       | undefined;
     if (
       last &&
       last.utilization === r.utilization &&
       last.resets_at === r.resetsAt &&
       last.status === r.status
-    )
+    ) {
+      if (at - last.at >= REFRESH_MS)
+        db.prepare(`UPDATE rate_limit_readings SET at = ? WHERE id = ?`).run(
+          at,
+          last.id
+        );
       continue;
+    }
     db.prepare(
       `INSERT INTO rate_limit_readings (at, window, utilization, raw, resets_at, status, session_id, source)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
@@ -135,6 +167,38 @@ export function lastReading(
     : null;
 }
 
+// A window's readings in its current reset period over the hour up to the
+// newest, oldest first as [epoch seconds, percent]: the series a burn rate
+// is fitted to. Empty when there are none.
+export function windowSamples(
+  window: LimitWindow,
+  spanMs = 3_600_000
+): { resetsAt: number | null; samples: [number, number][] } {
+  const newest = lastReading(window);
+  if (!newest) return { resetsAt: null, samples: [] };
+  const rows = db
+    .prepare(
+      `SELECT at, utilization FROM rate_limit_readings
+       WHERE window = ? AND resets_at IS ? AND at >= ? ORDER BY at, id`
+    )
+    .all(window, newest.resetsAt, newest.at - spanMs) as {
+    at: number;
+    utilization: number;
+  }[];
+  return {
+    resetsAt: newest.resetsAt,
+    samples: rows.map((r) => [r.at / 1000, r.utilization]),
+  };
+}
+
+// When any agent call was last recorded.
+export function lastAgentActivity(): number | null {
+  const r = db.prepare(`SELECT MAX(at) AS at FROM usage_calls`).get() as {
+    at: number | null;
+  };
+  return r.at;
+}
+
 const WEEK = 7 * 24 * 3600 * 1000;
 
 export function weightedBetween(from: number, to: number): number {

package/lib/usage/turns.ts

@@ -33,7 +33,7 @@ function savedTotals(sessionId: string): UsageTotals | null {
 }
 
 // The plan's 5-hour window when a turn on it ended, for its share of the
-// plan (lib/usage/compare): unknown when the statusline isn't sampling.
+// plan (lib/usage/compare): unknown when nothing is sampling it.
 export function planWindowPct(): number | null {
   const u = readUsage();
   return "window" in u && u.window ? u.window.pct : null;

package/lib/usage/windows.ts

@@ -1,15 +1,23 @@
 /**
- * The account's rolling usage windows. The 5-hour one comes from the
- * statusline's samples (lib/orchestrator/usage.ts), which also give its burn
- * rate; the weekly one only the agent knows, so it's asked through a
- * short-lived agent start (no turn is spent) and kept for a few minutes.
+ * The account's rolling usage windows. The 5-hour one comes from the samples
+ * in lib/orchestrator/usage.ts (AgentOS's own agents and the terminal
+ * statusline, whichever is fresher), which also give its burn rate; the
+ * weekly one from the readings AgentOS's agents store, else the plan's answer
+ * to a short-lived agent start (no turn is spent), kept for a few minutes.
+ * With nothing fresh, the last value seen is shown as such.
  */
 
 import os from "os";
 import { query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import { InputQueue } from "../chat/queue";
-import { readUsage } from "../orchestrator/usage";
-import { currentWindow, type WindowReading } from "./rate-limits";
+import { readUsage, type LastSeen } from "../orchestrator/usage";
+import {
+  currentWindow,
+  lastReading,
+  parseRateLimit,
+  recordReadings,
+  type WindowReading,
+} from "./rate-limits";
 
 export interface WindowView {
   pct: number;
@@ -20,6 +28,11 @@ export interface WindowView {
   burnPerMin?: number | null;
   // Worked out from recorded usage, not read from the account.
   estimated?: boolean;
+  // Not sampled lately: the last value seen, and when (epoch ms).
+  stale?: boolean;
+  sampledAt?: number;
+  // Seconds since then, when this was worked out.
+  ageSec?: number;
 }
 
 export interface UsageWindows {
@@ -71,7 +84,12 @@ async function askAgent(): Promise<PlanLimits | null> {
         );
       }),
     ]);
-    return usage.rate_limits_available ? (usage.rate_limits ?? null) : null;
+    const limits = usage.rate_limits_available
+      ? ((usage.rate_limits ?? null) as PlanLimits | null)
+      : null;
+    // A plan answer is a reading too: keep it for the screens and brakes.
+    if (limits) recordReadings(parseRateLimit(limits), "plan");
+    return limits;
   } finally {
     clearTimeout(timer);
     input.end();
@@ -125,6 +143,34 @@ const fromReading = (
       }
     : null;
 
+// The last value seen, shown as such, while its window is still open.
+export function fromLast(
+  last: LastSeen | null | undefined,
+  nowSec = Date.now() / 1000
+): WindowView | null {
+  if (!last || (last.resetsAt !== null && last.resetsAt <= nowSec)) return null;
+  return {
+    pct: last.pct,
+    resetsIn:
+      last.resetsAt === null ? null : Math.round(last.resetsAt - nowSec),
+    stale: true,
+    sampledAt: Math.round(last.sampledAt * 1000),
+    ageSec: Math.max(0, Math.round(nowSec - last.sampledAt)),
+  };
+}
+
+function lastWeekly(nowMs: number): WindowView | null {
+  const r = lastReading("seven_day");
+  return fromLast(
+    r && {
+      pct: Math.round(r.utilization),
+      resetsAt: r.resetsAt === null ? null : r.resetsAt / 1000,
+      sampledAt: r.at / 1000,
+    },
+    nowMs / 1000
+  );
+}
+
 export async function usageWindows(): Promise<UsageWindows> {
   const sampled = readUsage();
   const read = (w: "five_hour" | "seven_day") => {
@@ -144,14 +190,23 @@ export async function usageWindows(): Promise<UsageWindows> {
           capsIn: sampled.window.capsIn,
           burnPerMin: sampled.window.burnPerMin,
         }
-      : (fromPlan(plan.limits?.five_hour) ?? read("five_hour"));
-  const sevenDay = fromPlan(plan.limits?.seven_day) ?? read("seven_day");
+      : (fromPlan(plan.limits?.five_hour) ??
+        read("five_hour") ??
+        ("unknown" in sampled ? fromLast(sampled.last) : null));
+  let sevenDay: WindowView | null = null;
+  try {
+    sevenDay =
+      fromPlan(plan.limits?.seven_day) ??
+      read("seven_day") ??
+      lastWeekly(Date.now());
+  } catch {
+    // No readings to show.
+  }
   const note =
-    !sevenDay || !fiveHour
-      ? (plan.error ??
-        ("unknown" in sampled
-          ? sampled.unknown
-          : "the plan's limits aren't available for this login"))
-      : undefined;
+    "unknown" in sampled && (!fiveHour || fiveHour.stale)
+      ? sampled.unknown
+      : !sevenDay || !fiveHour
+        ? (plan.error ?? "the plan's limits aren't available for this login")
+        : undefined;
   return { fiveHour, sevenDay, note };
 }

package/package.json

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