@open-mercato/cezar 0.9.2-pr782.1076 → 0.9.2-pr786.1090

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patryk Lewczuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -19,7 +19,7 @@ your phone, working your backlog while you're away.
 
 [A look inside](#a-look-inside) · [What cezar does best](#what-cezar-does-best) · [What it solves](#what-it-solves) · [Who it's for](#who-its-for) · [Quick start](#quick-start) · [How it works](#how-it-works) · [Core concepts](#core-concepts) · [Cockpit tour](#cockpit-tour) · [Agent backends](#coding-agent-backends) · [Remote access](#remote-access-host-cezar-on-a-server)
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](#license)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 ![Node 20+](https://img.shields.io/badge/Node-20%2B-339933)
 ![TypeScript 7.x](https://img.shields.io/badge/TypeScript-7.x-3178c6)
 ![Zero config](https://img.shields.io/badge/config-zero-success)
@@ -712,4 +712,4 @@ Start here; graduate to cezar when a team needs shared visibility.
 
 ## License
 
-**MIT** © Patryk Lewczuk
+**MIT** © Patryk Lewczuk — full text in [LICENSE](LICENSE).

package/dist/contract/index.js

@@ -204,12 +204,11 @@ var diffStatSchema = z4.object({
   adds: z4.number(),
   dels: z4.number(),
   files: z4.number(),
-  /** Additive since #751, and present ONLY when true: the numbers were measured against a
-   *  branch the agent checked out into the task's worktree, as the run found it, because the
-   *  worktree's HEAD had been repointed off the task's own branch (every review/QA run does
-   *  this) and the merge-base anchor would otherwise have reported that branch's entire diff
-   *  as this task's. Absent on every normal run and on every record written before #751 — a
-   *  consumer that ignores it sees exactly the old shape. */
+  /** Additive since #751, and present ONLY when true: the numbers cover uncommitted work
+   *  alone, because the worktree's HEAD had been repointed off the task's own branch (every
+   *  review/QA run does this) and the merge-base anchor would otherwise have reported the
+   *  checked-out branch's entire diff as this task's. Absent on every normal run and on every
+   *  record written before #751 — a consumer that ignores it sees exactly the old shape. */
   repointed: z4.boolean().optional()
 });
 var queuedMessageSchema = z4.object({
@@ -356,6 +355,40 @@ var runRecordSchema = z4.object({
 var apiRunSchema = runRecordSchema.extend({
   usage: processUsageSchema.optional()
 });
+var runIndexEntrySchema = z4.object({
+  /** The registered project this run belongs to. Joins against `GET /projects`. */
+  projectId: z4.string(),
+  id: z4.string(),
+  title: z4.string(),
+  titleSummary: z4.string().optional(),
+  titleOrigin: z4.enum(["user", "auto", "marker"]).optional(),
+  status: runStatusSchema,
+  activity: runActivitySchema.optional(),
+  createdAt: z4.string(),
+  finishedAt: z4.string().optional(),
+  /** With `status`/`finishedAt`/`archived`, the four inputs `isUnread` reads — what lets the
+   *  palette lead with "finished while you weren't looking" across every project, not just the
+   *  one you happen to be standing in. */
+  seenAt: z4.string().optional(),
+  /** Always present, like `RunRecord.archived`: absent would read as "not archived", and the
+   *  unread rule treats archiving as a stronger "done with this" than reading. */
+  archived: z4.boolean(),
+  /** A run parked by a provider usage limit is `failed` on the record with a resume booked
+   *  (spec 2026-08-03-auto-resume-after-usage-limit). Both `deriveAttention` and `isUnread` read
+   *  it, so without it here a cross-project row would show a red "failed" dot and land in
+   *  Recently finished for work that is simply waiting for its appointment. */
+  autoResumeAt: z4.string().optional()
+});
+var runsIndexResponseSchema = z4.object({
+  /** Newest first, across every registered project. Archived runs are included — `GET /runs`
+   *  carries them for the project you are standing in, and a finder that dropped them elsewhere
+   *  would make a task vanish the moment you left its project. */
+  runs: z4.array(runIndexEntrySchema),
+  /** The per-project cap that produced this list. */
+  perProjectLimit: z4.number(),
+  /** Ids of the projects that had more runs than the cap allowed. */
+  truncated: z4.array(z4.string())
+});
 var createRunResponseSchema = z4.union([
   runRecordSchema,
   z4.object({ runs: z4.array(runRecordSchema) })
@@ -929,9 +962,11 @@ var workspaceLastLocationSchema = z8.strictObject({
   hash: z8.string().max(2048).startsWith("#").optional()
 });
 var workspaceUiStateSchema = z8.looseObject({
-  /** The sidebar's per-project collapse map (step 3.3) — `true` collapses a group, `false` pins
-   *  it open, absent means the default (the active project expands, the rest collapse). Loose for
-   *  the same round-trip reason as its parent. */
+  /** LEGACY — the sidebar's per-project collapse map (step 3.3). Still accepted and still
+   *  round-tripped so an older cockpit sharing this home keeps working, but the current cockpit
+   *  neither reads nor writes it: which groups are shut describes the WINDOW, not the workspace,
+   *  so it lives in that browser's localStorage (`packages/web/src/lib/sidebar-collapse.ts`).
+   *  One shared answer meant a phone collapsing a group collapsed it on the desktop too. */
   sidebar: z8.looseObject({ collapsed: z8.record(z8.string(), z8.boolean()).optional() }).optional(),
   /** Dismissed runtime-auth incident IDs, keyed by provider. An ID is only dismissed until the
    *  provider reports a different incident, so this stays workspace-global with the browser
@@ -947,8 +982,10 @@ var workspaceUiStateSchema = z8.looseObject({
   /** Settings → Notifications, GLOBAL since step 3.5 — one answer for the whole workspace, since
    *  the delivering browser is one browser whichever project you are looking at. */
   notifications: z8.looseObject({ enabled: z8.boolean().optional() }).optional(),
-  /** Last settled project-scoped page. Used only when entering at the exact bare root;
-   *  explicit deep links always win. */
+  /** LEGACY, exactly like `sidebar` above — the last settled project-scoped page, restored when
+   *  entering at the exact bare root. The shape is unchanged and still accepted, but the current
+   *  cockpit keeps it in localStorage (`packages/web/src/lib/last-location.ts`): stored here, the
+   *  last client to navigate decided where every OTHER client's next launch landed. */
   lastLocation: workspaceLastLocationSchema.optional(),
   /** The user's curated selection of default (vendor) skills. Tri-state: ABSENT means "not
    *  curated", so every default skill shows; a PRESENT array (even `[]`) means only those names
@@ -1563,12 +1600,14 @@ export {
   runCommitSchema,
   runCommitsResponseSchema,
   runEventSchema,
+  runIndexEntrySchema,
   runRecordSchema,
   runStatusSchema,
   runnerModelCatalogResponseSchema,
   runnerModelOptionSchema,
   runnerModelsSchema,
   runnerSchema,
+  runsIndexResponseSchema,
   saveWorkflowInputSchema,
   saveWorkflowResponseSchema,
   selectAgentProfileInputSchema,

package/dist/contract/runs.d.ts

@@ -445,6 +445,92 @@ export declare const apiRunSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ApiRun = z.infer<typeof apiRunSchema>;
+/**
+ * One run in the WORKSPACE-level index (`GET /api/v1/workspace/runs-index`) — the ⌘K palette's
+ * "find a task in any project" list.
+ *
+ * Deliberately a separate, slim shape rather than `ApiRun`. The index answers for every
+ * registered project at once, and `runRecordSchema` carries `steps[]` and `workflowDef` — a fat
+ * record whose cost is fine per project and absurd multiplied by the registry. These are exactly
+ * the fields a palette row renders: `runTitle`'s three (`title`, `titleSummary`, `titleOrigin`),
+ * `deriveAttention`'s `AttentionInput`, `isUnread`'s `ReadStateInput`, and the timestamps
+ * `shortAge` reads. Adding a field here is cheap; adding the whole record is what this exists to
+ * avoid — but note that widening either of those two `Pick`s means widening this too, or the
+ * palette's cross-project rows silently answer differently from every other surface.
+ *
+ * `projectId` is the join key, NOT the project name: the registry is already on the client and is
+ * authoritative for display names, and duplicating one here would let a renamed project show two
+ * different labels in one palette.
+ */
+export declare const runIndexEntrySchema: z.ZodObject<{
+    projectId: z.ZodString;
+    id: z.ZodString;
+    title: z.ZodString;
+    titleSummary: z.ZodOptional<z.ZodString>;
+    titleOrigin: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        marker: "marker";
+        user: "user";
+    }>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        queued: "queued";
+        review: "review";
+        running: "running";
+        waiting: "waiting";
+    }>;
+    activity: z.ZodOptional<z.ZodEnum<{
+        monitoring: "monitoring";
+    }>>;
+    createdAt: z.ZodString;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    seenAt: z.ZodOptional<z.ZodString>;
+    archived: z.ZodBoolean;
+    autoResumeAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunIndexEntry = z.infer<typeof runIndexEntrySchema>;
+/**
+ * `GET /workspace/runs-index`.
+ *
+ * `truncated` is not decoration: the index caps each project's contribution, and a capped list
+ * that says nothing reads as "your task is not here" when the honest answer is "not in the
+ * newest N". Naming the projects that hit the cap is what lets a consumer say so.
+ */
+export declare const runsIndexResponseSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        id: z.ZodString;
+        title: z.ZodString;
+        titleSummary: z.ZodOptional<z.ZodString>;
+        titleOrigin: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            marker: "marker";
+            user: "user";
+        }>>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            review: "review";
+            running: "running";
+            waiting: "waiting";
+        }>;
+        activity: z.ZodOptional<z.ZodEnum<{
+            monitoring: "monitoring";
+        }>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        seenAt: z.ZodOptional<z.ZodString>;
+        archived: z.ZodBoolean;
+        autoResumeAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    perProjectLimit: z.ZodNumber;
+    truncated: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RunsIndexResponse = z.infer<typeof runsIndexResponseSchema>;
 /**
  * `POST /runs` (201) — one record for ×1, a group for ×2/×3.
  *

package/dist/git-diff-base.d.ts

@@ -6,47 +6,22 @@
  * to the task's own commits even after the base branch moves on, and even
  * after the task merges the base back in.
  *
- * Two things break that answer, and both are fixed here:
- *
- * **A stale local base ref.** `RunRecord.baseBranch` is a NAME (`main`),
- * resolved to a ref once, when the worktree was created. Nothing ever
- * fast-forwards the user's local `main` — cezar's agents only ever `git fetch`,
- * which moves `origin/main` — so on a repo the user does not pull, the local
- * ref drifts arbitrarily far behind. The merge-base then collapses onto that
- * stale tip and every upstream commit the task forked from or merged in counts
- * as the task's own work: an eight-line fix measured `+59514 −12160` against a
- * `main` that was 98 commits and one monorepo restructure behind origin. So the
- * base is re-resolved to the freshest ref it names at every call
- * (`freshestBaseRef`) — the read-time twin of `resolveBaseRef`, which does the
- * same thing at worktree-creation time and cannot know what happens later.
- *
- * **A repointed HEAD.** cezar hands the agent a worktree on the task's own
- * branch, but nothing stops the agent from checking out another branch in it —
- * every `review/pr-NNN` and QA run does exactly that, and so does every skill
- * that opens its work on a named `feat/…` branch. The merge-base then silently
- * redefines "this task's diff" as *the whole checked-out branch*, which is how
- * a task that committed nothing came to report `+22505 −2628`. #591 and #751
- * answered that with `HEAD` — uncommitted work only — which is right for a
- * pure review and badly wrong for the far more common case of an agent that
- * committed real work on a branch it created itself: those runs reported
- * `+0 −0` for changes that were genuinely theirs.
- *
- * The honest anchor for a repointed HEAD is the branch as it stood **when this
- * run first saw it** — its `<branch>@{<run start>}` reflog state. Diffing
- * against that attributes exactly what the run did to the tree and nothing
- * that was already there: a review run gets its `+0`, and a run that branched
- * off the base and committed gets its real numbers. Where that baseline is
- * itself stale — the run merged the base branch in afterwards, dragging the
- * whole upstream delta behind it — the ordinary merge-base is the tighter
- * answer, so the two candidates compete and the one that attributes FEWER
- * CHANGED LINES to the task wins. The reported number is then never more than
- * the least either measure can defend.
- *
- * It lives here so a third surface cannot get it wrong again — callers hand in
- * their own `git` runner (`git-worktree.ts` and `server/git-changes.ts` each
- * own a private one, and `git-changes` needs its scratch-`GIT_INDEX_FILE`
- * variant), so this module stays a pure decision with no process-spawning of
- * its own.
+ * The exception is a **repointed HEAD**. cezar hands the agent a worktree on
+ * the task's own branch, but nothing stops the agent from checking out some
+ * other branch in it — every `review/pr-NNN`, QA, and "continue someone
+ * else's branch" run does exactly that. Anchoring at the merge-base then
+ * silently redefines "this task's diff" as *the whole reviewed branch*, which
+ * is how a task that committed nothing came to report `+22505 −2628`. When
+ * HEAD is not on the task's branch the honest anchor is `HEAD` itself: the
+ * uncommitted work in the tree is the only part this task can be said to have
+ * produced.
+ *
+ * #591 established that rule for the Changes tab; #751 found the sidebar and
+ * Tasks-table numbers still on the old anchor. It lives here so a third
+ * surface cannot get it wrong again — callers hand in their own `git` runner
+ * (`git-worktree.ts` and `server/git-changes.ts` each own a private one, and
+ * `git-changes` needs its scratch-`GIT_INDEX_FILE` variant), so this module
+ * stays a pure decision with no process-spawning of its own.
  */
 /** What a caller's `git` runner must answer with. Both existing runners are wider than this. */
 export interface GitRunResult {
@@ -63,23 +38,23 @@ export interface RepointedHead {
 export interface TaskDiffBase {
     /** The ref to diff against. */
     base: string;
-    /** Present only when HEAD left the task's branch — the reason `base` is what it is. */
+    /** Present only when HEAD left the task's branch — the reason `base` is `HEAD`. */
     repointedHead?: RepointedHead;
 }
 /**
- * Resolve the diff anchor for a task worktree. Never throws: a failing git call
- * degrades to the base branch name, which is what the un-guarded callers did
- * before this helper existed.
+ * Resolve the diff anchor for a task worktree. Never throws: a failing git
+ * call degrades to the base branch name, which is what the un-guarded callers
+ * did before this helper existed.
  *
  * `taskBranch` is optional because not every caller has one (the main working
- * tree has no task branch at all). Without it there is nothing to compare HEAD
- * against, so the merge-base anchor is used unchanged.
+ * tree has no task branch at all). Without it there is nothing to compare
+ * HEAD against, so the merge-base anchor is used unchanged — that is the
+ * pre-#751 behavior, preserved exactly.
  *
- * `runStartedAt` is what makes the repointed-HEAD answer a measurement instead
- * of a guess; without it the anchor stays `HEAD` (uncommitted work only), the
- * conservative #751 answer that can never claim someone else's commits.
+ * A detached HEAD (`rev-parse --abbrev-ref HEAD` → `HEAD`) counts as
+ * repointed: it is by definition not the task's branch, so the same
+ * uncommitted-only anchor is the honest one.
  */
 export declare function resolveTaskDiffBase(runGit: GitRunner, baseBranch: string, opts?: {
     taskBranch?: string;
-    runStartedAt?: string;
 }): Promise<TaskDiffBase>;

package/dist/git-diff-base.js

@@ -6,175 +6,49 @@
  * to the task's own commits even after the base branch moves on, and even
  * after the task merges the base back in.
  *
- * Two things break that answer, and both are fixed here:
- *
- * **A stale local base ref.** `RunRecord.baseBranch` is a NAME (`main`),
- * resolved to a ref once, when the worktree was created. Nothing ever
- * fast-forwards the user's local `main` — cezar's agents only ever `git fetch`,
- * which moves `origin/main` — so on a repo the user does not pull, the local
- * ref drifts arbitrarily far behind. The merge-base then collapses onto that
- * stale tip and every upstream commit the task forked from or merged in counts
- * as the task's own work: an eight-line fix measured `+59514 −12160` against a
- * `main` that was 98 commits and one monorepo restructure behind origin. So the
- * base is re-resolved to the freshest ref it names at every call
- * (`freshestBaseRef`) — the read-time twin of `resolveBaseRef`, which does the
- * same thing at worktree-creation time and cannot know what happens later.
- *
- * **A repointed HEAD.** cezar hands the agent a worktree on the task's own
- * branch, but nothing stops the agent from checking out another branch in it —
- * every `review/pr-NNN` and QA run does exactly that, and so does every skill
- * that opens its work on a named `feat/…` branch. The merge-base then silently
- * redefines "this task's diff" as *the whole checked-out branch*, which is how
- * a task that committed nothing came to report `+22505 −2628`. #591 and #751
- * answered that with `HEAD` — uncommitted work only — which is right for a
- * pure review and badly wrong for the far more common case of an agent that
- * committed real work on a branch it created itself: those runs reported
- * `+0 −0` for changes that were genuinely theirs.
- *
- * The honest anchor for a repointed HEAD is the branch as it stood **when this
- * run first saw it** — its `<branch>@{<run start>}` reflog state. Diffing
- * against that attributes exactly what the run did to the tree and nothing
- * that was already there: a review run gets its `+0`, and a run that branched
- * off the base and committed gets its real numbers. Where that baseline is
- * itself stale — the run merged the base branch in afterwards, dragging the
- * whole upstream delta behind it — the ordinary merge-base is the tighter
- * answer, so the two candidates compete and the one that attributes FEWER
- * CHANGED LINES to the task wins. The reported number is then never more than
- * the least either measure can defend.
- *
- * It lives here so a third surface cannot get it wrong again — callers hand in
- * their own `git` runner (`git-worktree.ts` and `server/git-changes.ts` each
- * own a private one, and `git-changes` needs its scratch-`GIT_INDEX_FILE`
- * variant), so this module stays a pure decision with no process-spawning of
- * its own.
- */
-import { isSafeGitRef } from './git-refs.js';
-/**
- * ISO-8601 instants only, for the `<branch>@{<date>}` revision below. The
- * timestamp comes from a stored run record, and a git revision expression is
- * the one place a stray value would be interpreted rather than compared —
- * `@{-1}` is "the previously checked-out branch", not a date. Anything that is
- * not plainly a timestamp simply disables the baseline anchor.
+ * The exception is a **repointed HEAD**. cezar hands the agent a worktree on
+ * the task's own branch, but nothing stops the agent from checking out some
+ * other branch in it — every `review/pr-NNN`, QA, and "continue someone
+ * else's branch" run does exactly that. Anchoring at the merge-base then
+ * silently redefines "this task's diff" as *the whole reviewed branch*, which
+ * is how a task that committed nothing came to report `+22505 −2628`. When
+ * HEAD is not on the task's branch the honest anchor is `HEAD` itself: the
+ * uncommitted work in the tree is the only part this task can be said to have
+ * produced.
+ *
+ * #591 established that rule for the Changes tab; #751 found the sidebar and
+ * Tasks-table numbers still on the old anchor. It lives here so a third
+ * surface cannot get it wrong again — callers hand in their own `git` runner
+ * (`git-worktree.ts` and `server/git-changes.ts` each own a private one, and
+ * `git-changes` needs its scratch-`GIT_INDEX_FILE` variant), so this module
+ * stays a pure decision with no process-spawning of its own.
  */
-const ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
 /**
- * The freshest ref the configured base branch names: `origin/<base>` when the
- * local branch is behind it (or missing entirely), the local branch otherwise.
- *
- * Same rule as `resolveBaseRef` (`git-worktree.ts`), which picks the fork point
- * when the worktree is created; this one re-applies it every time a diff is
- * measured, because that is when the local ref's staleness actually shows up.
- * A base that is already remote-tracking, a commit sha pinned from a detached
- * HEAD, or a repo with no `origin` all fall through unchanged.
- */
-async function freshestBaseRef(runGit, base) {
-    if (!isSafeGitRef(base) || base === 'HEAD' || base.startsWith('origin/'))
-        return base;
-    const remote = `origin/${base}`;
-    const hasRemote = await runGit(['rev-parse', '--verify', '--quiet', `${remote}^{commit}`]);
-    if (!hasRemote.ok)
-        return base;
-    // Exits 0 iff local is equal to or ahead of origin — the case where the local
-    // ref carries unpushed base commits and is the better answer.
-    const localCurrent = await runGit(['merge-base', '--is-ancestor', remote, base]);
-    return localCurrent.ok ? base : remote;
-}
-/**
- * Where the repointed branch stood when this run started — `git rev-parse
- * <branch>@{<runStartedAt>}`, i.e. its own reflog, read at a point in time.
- *
- * Git answers this generously by design: a timestamp older than the whole
- * reflog resolves to the branch's OLDEST recorded state, which for a branch the
- * agent created during the run is its creation commit — exactly the fork point
- * we want. A branch that already existed resolves to the tip it had before the
- * run touched it, so the previous author's commits stay theirs.
- *
- * Null (→ the caller keeps the conservative `HEAD` anchor) when there is no run
- * start to read at, when HEAD is detached (no branch reflog to consult), or
- * when reflogs are unavailable — a guess is worse than the narrow answer.
- */
-async function checkoutBaseline(runGit, headBranch, runStartedAt) {
-    if (!runStartedAt || !ISO_INSTANT.test(runStartedAt))
-        return null;
-    if (headBranch === 'HEAD' || !isSafeGitRef(headBranch))
-        return null;
-    const at = await runGit([
-        'rev-parse',
-        '--verify',
-        '--quiet',
-        `${headBranch}@{${runStartedAt}}^{commit}`,
-    ]);
-    const sha = at.ok ? at.stdout.trim() : '';
-    return sha || null;
-}
-/**
- * How many changed lines an anchor attributes to the task — the comparison that
- * picks between two candidates, never a number anyone sees (the callers do their
- * own parsing for that, `parseShortstat`). Both candidates cover the same
- * uncommitted work, so the comparison is fair whatever the index holds.
- *
- * This is the one part of the decision that reads the index rather than just
- * refs, and `git diff` rewrites the index it reads (a stat refresh). Callers
- * that keep their diffs off an index they do not own — `collectChanges` and its
- * scratch `GIT_INDEX_FILE` — must therefore hand this module a runner carrying
- * that same environment, and the two probes below run one after the other so
- * they never refresh one index file concurrently.
- */
-async function changedLines(runGit, ref) {
-    const res = await runGit(['diff', '--shortstat', ref]);
-    if (!res.ok)
-        return null;
-    let total = 0;
-    for (const m of res.stdout.matchAll(/(\d+) (?:insertions?\(\+\)|deletions?\(-\))/g)) {
-        total += Number(m[1]);
-    }
-    return total;
-}
-/**
- * Resolve the diff anchor for a task worktree. Never throws: a failing git call
- * degrades to the base branch name, which is what the un-guarded callers did
- * before this helper existed.
+ * Resolve the diff anchor for a task worktree. Never throws: a failing git
+ * call degrades to the base branch name, which is what the un-guarded callers
+ * did before this helper existed.
  *
  * `taskBranch` is optional because not every caller has one (the main working
- * tree has no task branch at all). Without it there is nothing to compare HEAD
- * against, so the merge-base anchor is used unchanged.
+ * tree has no task branch at all). Without it there is nothing to compare
+ * HEAD against, so the merge-base anchor is used unchanged — that is the
+ * pre-#751 behavior, preserved exactly.
  *
- * `runStartedAt` is what makes the repointed-HEAD answer a measurement instead
- * of a guess; without it the anchor stays `HEAD` (uncommitted work only), the
- * conservative #751 answer that can never claim someone else's commits.
+ * A detached HEAD (`rev-parse --abbrev-ref HEAD` → `HEAD`) counts as
+ * repointed: it is by definition not the task's branch, so the same
+ * uncommitted-only anchor is the honest one.
  */
 export async function resolveTaskDiffBase(runGit, baseBranch, opts = {}) {
-    const base = await freshestBaseRef(runGit, baseBranch);
-    const mergeBase = async () => {
-        const res = await runGit(['merge-base', base, 'HEAD']);
-        return res.ok && res.stdout.trim() ? res.stdout.trim() : base;
-    };
-    if (!opts.taskBranch)
-        return { base: await mergeBase() };
-    const headBranchResult = await runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
-    const headBranch = headBranchResult.ok ? headBranchResult.stdout.trim() : '';
-    // An unreadable HEAD (no commits yet, broken worktree) is NOT evidence of a
-    // repoint — fall through to the merge-base anchor rather than narrowing on a
-    // guess. A detached HEAD, on the other hand, is by definition not the task's
-    // branch and takes the repointed path below.
-    if (!headBranch || headBranch === opts.taskBranch)
-        return { base: await mergeBase() };
-    const repointedHead = { headBranch, taskBranch: opts.taskBranch };
-    const baseline = await checkoutBaseline(runGit, headBranch, opts.runStartedAt);
-    if (!baseline)
-        return { base: 'HEAD', repointedHead };
-    // Two defensible anchors, so report the tighter one: the number must never
-    // claim more than the least either measure attributes to this task. The
-    // baseline is usually it — but not when the run merged the base branch in
-    // afterwards, which drags the whole upstream delta past a pre-merge baseline
-    // and leaves the merge-base as the only anchor that still measures the task.
-    const anchor = await mergeBase();
-    const viaBaseline = await changedLines(runGit, baseline);
-    if (viaBaseline === null)
-        return { base: anchor, repointedHead };
-    const viaMergeBase = await changedLines(runGit, anchor);
-    if (viaMergeBase === null || viaBaseline <= viaMergeBase)
-        return { base: baseline, repointedHead };
-    return { base: anchor, repointedHead };
+    if (opts.taskBranch) {
+        const headBranchResult = await runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+        const headBranch = headBranchResult.ok ? headBranchResult.stdout.trim() : '';
+        // An unreadable HEAD (no commits yet, broken worktree) is NOT evidence of a
+        // repoint — fall through to the merge-base anchor rather than narrowing on a
+        // guess.
+        if (headBranch && headBranch !== opts.taskBranch) {
+            return { base: 'HEAD', repointedHead: { headBranch, taskBranch: opts.taskBranch } };
+        }
+    }
+    const mergeBase = await runGit(['merge-base', baseBranch, 'HEAD']);
+    return { base: mergeBase.ok && mergeBase.stdout.trim() ? mergeBase.stdout.trim() : baseBranch };
 }
 //# sourceMappingURL=git-diff-base.js.map

package/dist/git-diff-base.js.map

@@ -1 +1 @@
-{"version":3,"file":"git-diff-base.js","sourceRoot":"","sources":["../src/git-diff-base.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"git-diff-base.js","sourceRoot":"","sources":["../src/git-diff-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAwBH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAiB,EACjB,UAAkB,EAClB,IAAI,GAA4B,EAAE;IAElC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,MAAM,gBAAgB,GAAG,MAAM,MAAM,CAAC,CAAC,WAAW,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;QAC7E,MAAM,UAAU,GAAG,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7E,4EAA4E;QAC5E,6EAA6E;QAC7E,SAAS;QACT,IAAI,UAAU,IAAI,UAAU,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;YACjD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;QACtF,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,CAAC,YAAY,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IACnE,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;AAClG,CAAC"}

package/dist/git-worktree.d.ts

@@ -22,11 +22,6 @@ export declare function branchFor(runId: string): string;
  * 142k-line diff. `origin/<base>` is the source of truth for a review base, so
  * only keep the local ref when it is equal to or ahead of origin (unpushed base
  * commits); otherwise use origin.
- *
- * This answers the question once, when the worktree is forked. The local ref
- * goes stale AFTERWARDS too — agents fetch, they never pull — so every diff
- * re-applies the same rule at read time through `freshestBaseRef`
- * (`git-diff-base.ts`). Keep the two in agreement.
  */
 export declare function resolveBaseRef(repoRoot: string, base: string): Promise<string | null>;
 export declare function worktreePathFor(repoRoot: string, runId: string): string;
@@ -119,10 +114,9 @@ export interface DiffStat {
     adds: number;
     dels: number;
     files: number;
-    /** Set only when the numbers were narrowed to what this run did on a branch it checked
-     *  out into its worktree, because HEAD had been repointed off the task's branch (#751).
-     *  Absent — never `false` — on a normal run, so the persisted shape is unchanged for
-     *  every task that behaved. */
+    /** Set only when the numbers were narrowed to uncommitted work because the worktree's
+     *  HEAD had been repointed off the task's branch (#751). Absent — never `false` — on a
+     *  normal run, so the persisted shape is unchanged for every task that behaved. */
     repointed?: boolean;
 }
 /**
@@ -138,11 +132,9 @@ export declare function parseShortstat(s: string): DiffStat;
  * behind `RunRecord.diffStat`, which is what the sidebar quick list and the
  * Tasks table show. Same intent-to-add as `worktreeDiff`, but the anchor comes
  * from the shared `resolveTaskDiffBase` rule (`git-diff-base.ts`): pass the
- * run's own `taskBranch` and `runStartedAt`, and a worktree whose HEAD was
- * repointed onto another branch reports what this run did to that branch
- * instead of claiming the branch's whole diff as this task's (#751 — the #591
- * guard, on this surface). The same rule re-resolves a stale local base ref,
- * so the number never counts upstream history the task merely forked from.
+ * run's own `taskBranch` and a worktree whose HEAD was repointed onto another
+ * branch reports its uncommitted work only, instead of claiming that whole
+ * branch's diff as this task's (#751 — the #591 guard, on this surface).
  *
  * `repointed: true` rides along on the returned stat exactly when that
  * narrowing happened, so the UI can say why the number is what it is. Null on
@@ -151,7 +143,6 @@ export declare function parseShortstat(s: string): DiffStat;
  */
 export declare function worktreeShortstat(worktreePath: string, baseBranch: string, opts?: {
     taskBranch?: string;
-    runStartedAt?: string;
 }): Promise<DiffStat | null>;
 /**
  * Startup reconcile: `git worktree prune` + remove every directory under