brainclaw 1.12.0 → 1.14.0

package/dist/commands/session-start.js

@@ -16,7 +16,9 @@ import { releaseStaleClaimsFromOtherAgents } from '../core/claims.js';
 import { SessionSnapshotSchema } from '../core/schema.js';
 import { auditLocalAgentWorkspaceFiles } from '../core/agent-files.js';
 import { buildAgentInventory, loadAgentInventory, saveAgentInventory, diffInventory } from '../core/agent-inventory.js';
-import { checkMemoryPressure, enforceRuntimeNoteRetention } from '../core/gc-semantic.js';
+import { checkMemoryPressure, enforceRuntimeNoteRetention, parkClosedAutoHandoffs } from '../core/gc-semantic.js';
+import { sweepAssignments } from '../core/assignment-sweeper.js';
+import { loadHygienePolicy } from '../core/hygiene-policy.js';
 import { maybeCreateCheckpoint } from '../core/events/checkpoint.js';
 import { pullSignalsFromLinkedProjects, markSignalProcessed } from '../core/federation-transport.js';
 import { pullSignalsFromCloud, isCloudSyncEnabled } from '../core/federation-cloud.js';
@@ -207,6 +209,19 @@ export async function startSession(options = {}) {
             enforceRuntimeNoteRetention({ cwd: options.cwd });
         }
         catch { /* non-fatal — retention sweep must never block session start */ }
+        // pln#602 — coordination hygiene pass. Converge orphan offered/accepted
+        // assignments (workers that died without a self-report — fable-audit-2026-07
+        // witnesses) and park closed auto-generated handoffs so bclaw_work stops
+        // serving debris. Runs at session-start ONLY (not on the hot read path);
+        // opt-out via config.hygiene.disabled honoured through the policy load.
+        try {
+            const policy = loadHygienePolicy(options.cwd);
+            if (!policy.disabled) {
+                sweepAssignments(options.cwd, { actor: 'session-start', policy });
+                parkClosedAutoHandoffs(options.cwd ?? process.cwd(), Math.floor(policy.handoff_closed_ttl_ms / (24 * 60 * 60 * 1000)));
+            }
+        }
+        catch { /* non-fatal — hygiene sweep must never block session start */ }
         // pln#566 Inc0 — keep a recent journal-derived checkpoint available off the
         // hot path so the (capability-gated, OFF by default) checkpointRead read
         // path has something to serve once enabled. Gated by a growth threshold so

package/dist/core/agent-capability.js

@@ -175,6 +175,11 @@ const PROFILES = {
         // Aligning with the regular spawn template (workspace-write) is the
         // accepted pattern per agent_spawn_inventory memory.
         invoke_review_template: 'codex exec -c approval_policy="never" --sandbox workspace-write "{prompt}"',
+        // pln#606: `codex exec -m <MODEL>` / `--model` (verified empirically on
+        // codex 0.130). We use the long form `--model` for symmetry with the
+        // other agent profiles and readability.
+        model_flag: '--model',
+        model_flag_insert_index: 2,
     },
     antigravity: {
         name: 'antigravity', category: 'code-agent', workflowModel: 'interactive',
@@ -204,6 +209,10 @@ const PROFILES = {
         invoke_template: 'copilot -p "{prompt}" --allow-all --no-ask-user',
         invoke_binary: 'copilot',
         invoke_review_template: 'copilot -p "{prompt}" --allow-all --no-ask-user',
+        // pln#606: `copilot --model <model>` (verified on Copilot CLI 1.0.35+).
+        // 'auto' lets Copilot pick automatically; concrete ids come from the
+        // entitled catalog fetched by the CLI at startup.
+        model_flag: '--model',
     },
     kilocode: {
         name: 'kilocode', category: 'code-agent', workflowModel: 'interactive',
@@ -564,11 +573,13 @@ export function buildInvokeCommand(name, prompt, options = {}) {
     const rawTokens = parseTemplateString(templateStr);
     if (rawTokens.length === 0)
         return undefined;
-    // pln#520 step 3: inject the resolved model right after the binary so model
-    // choice is decoupled from agent identity. Only when the profile declares a
-    // `model_flag` and the template doesn't already pin a model (don't double it).
+    // pln#520 step 3: inject the resolved model at the profile's model argument
+    // position so model choice is decoupled from agent identity. Only when the
+    // profile declares a `model_flag` and the template doesn't already pin a model
+    // (don't double it).
     if (options.model && profile.model_flag && !rawTokens.includes(profile.model_flag)) {
-        rawTokens.splice(1, 0, profile.model_flag, options.model);
+        const insertIndex = Math.min(Math.max(profile.model_flag_insert_index ?? 1, 1), rawTokens.length);
+        rawTokens.splice(insertIndex, 0, profile.model_flag, options.model);
     }
     const executable = rawTokens[0];
     const interpolatedTokens = rawTokens.slice(1).map((tok) => tok === '{prompt}' ? embeddedPrompt : tok);

package/dist/core/agent-registry.js

@@ -150,7 +150,13 @@ function buildIdentityKey(agentId, env = process.env, forceRegenerate = false) {
     let publicKeyPem;
     if (!forceRegenerate && fs.existsSync(filepath)) {
         const privateKey = crypto.createPrivateKey(fs.readFileSync(filepath, 'utf-8'));
-        publicKeyPem = crypto.createPublicKey(privateKey).export({ type: 'spki', format: 'pem' }).toString();
+        // @types/node 26 dropped the KeyObject overload from createPublicKey's signature
+        // (regression — Node accepts a private KeyObject to derive its public key, as documented).
+        // Cast to a parameter type the .d.ts still accepts; runtime behaviour is unchanged.
+        publicKeyPem = crypto
+            .createPublicKey(privateKey)
+            .export({ type: 'spki', format: 'pem' })
+            .toString();
     }
     else {
         const generated = crypto.generateKeyPairSync('ed25519');

package/dist/core/assignment-sweeper.js

@@ -16,6 +16,7 @@
 import { spawnSync } from 'node:child_process';
 import { listAssignments, transitionAssignment } from './assignments.js';
 import { signalExists, readHeartbeat, latestActivityMs } from './runtime-signals.js';
+import { DEFAULT_HYGIENE_POLICY } from './hygiene-policy.js';
 function lastCommitAgeMs(worktreePath, nowMs) {
     if (!worktreePath)
         return undefined;
@@ -104,28 +105,60 @@ function collectImplicitEvidence(assignment, cwd, nowMs, sinceMs, freshTtlMs) {
  * @param options.actor - Actor name for audit trail (default: 'sweeper')
  */
 export function sweepAssignments(cwd, options) {
+    return sweepAssignmentsFromList(listAssignments(cwd), cwd, options);
+}
+/**
+ * Read-path variant: sweep only the assignments the caller ALREADY loaded
+ * (typically open_work.active_assignments). No `listAssignments` call, so no
+ * additional store scan on the hot bclaw_work path (pln#602 perf guardrail
+ * per the pln#578 read-path optimisation). Use `sweepAssignmentsFromList`
+ * with a bounded slice when a full pass would violate the budget.
+ *
+ * @param assignments - pre-loaded assignments to consider (only non-terminal ones matter)
+ * @param cwd - project root
+ * @param options.nowMs - Override current time for testing
+ * @param options.actor - Actor for the audit trail (default: 'sweeper-readpath')
+ * @param options.policy - Family-level TTL/policy overrides
+ */
+export function sweepAssignmentsFromList(assignments, cwd, options) {
+    const policy = options?.policy;
+    if (policy?.disabled) {
+        return { timed_out: [], expired: [], implicitly_advanced: [] };
+    }
     const now = options?.nowMs ?? Date.now();
     const actor = options?.actor ?? 'sweeper';
     const result = { timed_out: [], expired: [], implicitly_advanced: [] };
-    const all = listAssignments(cwd);
-    for (const assignment of all) {
+    for (const assignment of assignments) {
+        // pln#602 / Codex PR#48 finding 2: when a hygiene `policy` is supplied
+        // (session-start full sweep, bclaw_work read-path), the age comparison,
+        // the implicit-evidence freshness window, AND the status_reason MUST use
+        // the family TTLs (offered 3d / accepted 1d / started 1d by default), NOT
+        // the assignment's embedded heartbeat_ttl_ms/acceptance_ttl_ms (~30/15min).
+        // Otherwise a 20-min offered assignment that `doctor --hygiene` does not
+        // list as a candidate could still be expired here — the exact incoherence
+        // Codex flagged. Without a policy (the dispatcher convergence sweep,
+        // dispatcher.ts), fall back to the embedded TTLs so short-window dispatch
+        // convergence is unchanged.
+        const startedTtl = policy?.assignment_started_ttl_ms ?? assignment.heartbeat_ttl_ms;
+        const acceptedTtl = policy?.assignment_accepted_ttl_ms ?? assignment.acceptance_ttl_ms;
+        const offeredTtl = policy?.assignment_offered_ttl_ms ?? assignment.acceptance_ttl_ms;
         // Check started assignments for heartbeat timeout
         if (assignment.status === 'started') {
             const lastBeat = assignment.last_heartbeat_at ?? assignment.started_at;
             if (!lastBeat)
                 continue;
             const ageMs = now - new Date(lastBeat).getTime();
-            if (ageMs > assignment.heartbeat_ttl_ms) {
+            if (ageMs > startedTtl) {
                 // can_948acfd6: a worker without MCP cannot bump last_heartbeat_at —
                 // its file evidence is the heartbeat. Fresh file activity vetoes the
                 // administrative timeout.
                 const sinceMs = new Date(assignment.started_at ?? assignment.created_at).getTime();
-                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.heartbeat_ttl_ms);
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, startedTtl);
                 if (evidence.fresh)
                     continue;
                 try {
                     transitionAssignment(assignment.id, 'timed_out', {
-                        status_reason: `No heartbeat for ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.heartbeat_ttl_ms / 60_000)}min); implicit evidence: ${evidence.description}`,
+                        status_reason: `No heartbeat for ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(startedTtl / 60_000)}min); implicit evidence: ${evidence.description}`,
                         actor,
                     }, cwd);
                     result.timed_out.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
@@ -139,10 +172,12 @@ export function sweepAssignments(cwd, options) {
             if (!acceptedAt)
                 continue;
             const ageMs = now - new Date(acceptedAt).getTime();
-            // Use acceptance_ttl for accepted→timed_out (same window: agent should start quickly after accepting)
-            if (ageMs > assignment.acceptance_ttl_ms) {
+            // Use the accepted-family TTL for accepted→timed_out (agent should start
+            // soon after accepting; family default 1d, or embedded acceptance_ttl_ms
+            // for the policy-less convergence sweep).
+            if (ageMs > acceptedTtl) {
                 const sinceMs = new Date(acceptedAt).getTime();
-                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.acceptance_ttl_ms);
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, acceptedTtl);
                 if (evidence.fresh) {
                     // Working without MCP — record the implicit start so the FSM matches reality.
                     try {
@@ -171,13 +206,13 @@ export function sweepAssignments(cwd, options) {
             if (!offeredAt)
                 continue;
             const ageMs = now - new Date(offeredAt).getTime();
-            if (ageMs > assignment.acceptance_ttl_ms) {
+            if (ageMs > offeredTtl) {
                 // can_948acfd6: ANY worker evidence (ack sentinel touched pre-exec,
                 // heartbeat written, files edited, commit landed) is an implicit
                 // acceptance — the worker just couldn't say so via MCP. Expiring it
                 // is the false-administrative-death observed three times in sprint 1.
                 const sinceMs = new Date(offeredAt).getTime();
-                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.acceptance_ttl_ms);
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, offeredTtl);
                 if (evidence.any) {
                     try {
                         transitionAssignment(assignment.id, 'accepted', {
@@ -191,7 +226,7 @@ export function sweepAssignments(cwd, options) {
                 }
                 try {
                     transitionAssignment(assignment.id, 'expired', {
-                        status_reason: `Not accepted within ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.acceptance_ttl_ms / 60_000)}min); no implicit evidence`,
+                        status_reason: `Not accepted within ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(offeredTtl / 60_000)}min); no implicit evidence`,
                         actor,
                     }, cwd);
                     result.expired.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
@@ -202,4 +237,50 @@ export function sweepAssignments(cwd, options) {
     }
     return result;
 }
+/**
+ * Pure candidate selection for the bclaw_work read-path sweep (Codex PR#48
+ * finding 3, pln#578 guardrail). Given ONLY the in-memory projections that
+ * buildContext already surfaced, return the ids worth a full loadAssignment:
+ *   - status must be sweepable (offered/accepted/started) — created/terminal
+ *     rows can never transition and are dropped BEFORE any file read, so a
+ *     healthy store full of `created` assignments costs zero extra I/O;
+ *   - among those, only rows whose surfaced heartbeat is older than the
+ *     smallest family TTL (or that carry no heartbeat) are suspicious;
+ *   - capped at read_path_sweep_budget.
+ * Extracted so the hot-path zero-read guarantee is unit-testable without the
+ * MCP handler.
+ */
+export function selectReadPathSweepCandidates(projections, policy, nowMs) {
+    if (policy.disabled)
+        return [];
+    const minTtl = Math.min(policy.assignment_offered_ttl_ms, policy.assignment_accepted_ttl_ms, policy.assignment_started_ttl_ms);
+    return projections
+        .filter((a) => {
+        if (a.status !== 'offered' && a.status !== 'accepted' && a.status !== 'started')
+            return false;
+        const beat = a.last_heartbeat_at;
+        if (!beat)
+            return true;
+        return nowMs - new Date(beat).getTime() > minTtl;
+    })
+        .slice(0, policy.read_path_sweep_budget)
+        .map((a) => a.id);
+}
+export function sweepAssignmentsAtReadPath(assignments, cwd, options) {
+    const policy = options?.policy ?? DEFAULT_HYGIENE_POLICY;
+    if (policy.disabled) {
+        return { timed_out: [], expired: [], implicitly_advanced: [] };
+    }
+    const budget = policy.read_path_sweep_budget;
+    // Prefer offered/accepted (the empirical debris class); the sweep is a no-op
+    // for terminal statuses so filtering is a perf hygiene, not correctness.
+    const eligible = assignments
+        .filter((a) => a.status === 'offered' || a.status === 'accepted' || a.status === 'started')
+        .slice(0, budget);
+    return sweepAssignmentsFromList(eligible, cwd, {
+        ...options,
+        actor: options?.actor ?? 'sweeper-readpath',
+        policy,
+    });
+}
 //# sourceMappingURL=assignment-sweeper.js.map

package/dist/core/claims.js

@@ -153,9 +153,15 @@ function assertReleaseOwnership(claim, auth) {
         return { overrideUsed: false };
     if (auth.override)
         return { overrideUsed: true };
+    // pln#607 rule + trp#928 — the error must be executable as-is: the caller
+    // should be able to copy the coordinator_override:true param straight from the
+    // message into their next bclaw_release_claim call. "Coordinator-level callers
+    // may release with override" was diagnostically useless before — no param name,
+    // no path forward. Ghost claim clm_ed9b8386 stayed active for weeks because
+    // this error was raised, swallowed by a best-effort catch, and never surfaced.
     throw new Error(`claim '${claim.id}' is held by '${claim.agent}'${claim.session_id ? ` (session ${claim.session_id})` : ''}; `
         + `caller '${auth.agent ?? auth.agent_id ?? auth.session_id ?? 'unknown'}' does not own it. `
-        + 'Coordinator-level callers may release with override.');
+        + `Retry with coordinator_override:true (requires trusted+ trust level; the release is audited).`);
 }
 function auditReleaseOverride(claim, auth, cwd) {
     appendAuditEntry({
@@ -184,6 +190,43 @@ export function releaseClaim(id, cwd, auth) {
     }
     return released;
 }
+/**
+ * Mark an active claim as `stale` — a distinct terminal state from `released`
+ * used when a claim is being torn down because its owner is gone (session
+ * expired, worker died, coordinator abandoned the lane). Same ownership rules
+ * as releaseClaim (trusted+ coordinators may override with audit).
+ *
+ * trp#928 — the `active → stale` transition documented on the entity registry
+ * had no imperative path before; callers had to fall back to mass sweeps
+ * (`expireStaleActiveClaims`) or write status directly. Now bclaw_transition
+ * (entity=claim, to='stale') reaches this function via entity-operations.
+ */
+export function markClaimStale(id, cwd, auth) {
+    let overrideUsed = false;
+    const staled = mutate({ cwd }, () => {
+        const claim = loadClaim(id, cwd);
+        overrideUsed = assertReleaseOwnership(claim, auth).overrideUsed;
+        claim.status = 'stale';
+        claim.released_at = nowISO();
+        saveClaimUnlocked(claim, cwd);
+        return claim;
+    });
+    appendAuditEntry({
+        actor: staled.agent,
+        actor_id: staled.agent_id,
+        action: 'release_claim',
+        item_id: staled.id,
+        item_type: 'claim',
+        scope: staled.scope,
+        session_id: staled.session_id,
+        host_id: staled.host_id,
+        after: { status: 'stale' },
+    }, cwd);
+    if (overrideUsed && auth) {
+        auditReleaseOverride(staled, auth, cwd);
+    }
+    return staled;
+}
 /**
  * Release a claim and optionally cascade the status to its linked plan.
  *
@@ -295,6 +338,122 @@ export function isClaimExpired(claim) {
         return false;
     return new Date(claim.expires_at) < new Date();
 }
+/**
+ * Release every ACTIVE claim linked to a given target (plan / assignment / loop
+ * slot claim). trp#928 — the cascade must LOG per-claim (released or
+ * skipped+reason) so a silent ownership failure is observable at the harvest /
+ * loop-close boundary. Ownership follows the same ReleaseClaimAuth contract as
+ * releaseClaim: a system caller (auth undefined) bypasses the check; a caller
+ * with auth honors ownership + coordinator_override.
+ */
+export function releaseClaimsCascade(claimIds, options = {}) {
+    const entries = [];
+    // Deduplicate — callers may pass the same claim id via both an assignment and
+    // a slot; a duplicate would double-audit.
+    const seen = new Set();
+    for (const id of claimIds) {
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        let claim;
+        try {
+            claim = loadClaim(id, options.cwd);
+        }
+        catch {
+            entries.push({ claim_id: id, released: false, reason: 'not_found' });
+            continue;
+        }
+        if (claim.status !== 'active') {
+            entries.push({ claim_id: id, released: false, reason: 'already_terminal' });
+            continue;
+        }
+        try {
+            const rel = releaseClaimWithCascade(id, {
+                planStatus: options.planStatus,
+                cwd: options.cwd,
+                auth: options.auth,
+            });
+            const overrideUsed = options.auth?.override === true
+                && !ownerMatches(claim, options.auth);
+            entries.push({
+                claim_id: id,
+                released: rel.claim.status === 'released',
+                reason: rel.claim.status === 'released' ? 'released' : 'error',
+                ...(overrideUsed ? { override_used: true } : {}),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // The specific ownership-check error thrown by assertReleaseOwnership
+            // gets its own reason bucket so a caller can surface an executable hint
+            // (retry with coordinator_override:true) instead of a generic error.
+            const reason = /coordinator_override/i.test(message) ? 'ownership_denied' : 'error';
+            entries.push({ claim_id: id, released: false, reason, error: message });
+        }
+    }
+    const released_count = entries.filter((e) => e.released).length;
+    const error_count = entries.filter((e) => e.reason === 'error' || e.reason === 'ownership_denied').length;
+    return {
+        entries,
+        released_count,
+        skipped_count: entries.length - released_count - error_count,
+        error_count,
+    };
+}
+/**
+ * Extract of assertReleaseOwnership's owner check without the throw. Used by
+ * releaseClaimsCascade to know whether a successful release used the override
+ * path (so it can be reported in the per-claim log).
+ */
+function ownerMatches(claim, auth) {
+    return ((auth.session_id !== undefined && claim.session_id !== undefined && auth.session_id === claim.session_id)
+        || (auth.agent_id !== undefined && claim.agent_id !== undefined && auth.agent_id === claim.agent_id)
+        || (auth.agent !== undefined && claim.agent === auth.agent));
+}
+/**
+ * Find every active claim linked to a plan (via plan_id). Used by
+ * bclaw_transition(entity='plan', to='done') to implement the
+ * `release_linked_claims_if_last` cascade tag advertised on the entity
+ * registry (before trp#928 the tag was documentation only; the imperative
+ * cascade never ran).
+ */
+export function findActiveClaimsForPlan(planId, cwd) {
+    return listClaims(cwd).filter((c) => c.plan_id === planId && c.status === 'active');
+}
+/**
+ * Emit a runtime event summarising a cascade release outcome, one entry per
+ * claim in the metadata. trp#928 — every cascade caller (plan-done,
+ * loop close, assignment→completed, harvest --integrate) MUST log per-claim
+ * status so silent failures are observable via bclaw_find(entity='agent_run')
+ * / bclaw_find(entity='claim'). Best-effort: never breaks the parent flow.
+ */
+export function logCascadeReleaseResult(input) {
+    const { released_count, skipped_count, error_count, entries } = input.cascade;
+    if (entries.length === 0)
+        return;
+    const text = `cascade[${input.trigger}]: released=${released_count} skipped=${skipped_count} errors=${error_count}`
+        + ` — ${entries.map((e) => `${e.claim_id}:${e.reason}`).join(', ')}`;
+    try {
+        createRuntimeEvent({
+            agent: input.actor,
+            event_type: 'assignment_progress',
+            text,
+            tags: ['cascade', 'claim-release', input.trigger, ...(error_count > 0 ? ['ownership-issue'] : [])],
+            plan_id: input.plan_id,
+            assignment_id: input.assignment_id,
+            claim_id: input.claim_id,
+            metadata: {
+                trigger: input.trigger,
+                released_count,
+                skipped_count,
+                error_count,
+                entries,
+                ...(input.loop_id ? { loop_id: input.loop_id } : {}),
+            },
+        }, input.cwd);
+    }
+    catch { /* best-effort logging — never break the parent flow */ }
+}
 /** Mark active claims past their expires_at as released. Returns count of expired claims. */
 export function expireStaleActiveClaims(cwd) {
     return mutate({ cwd }, () => {

package/dist/core/context.js

@@ -243,8 +243,12 @@ export function buildContext(options = {}) {
             },
         });
     }
+    // pln#578 — single pending-candidates read, reused by the includePending
+    // items, scoped activity, and staleness passes below (same idiom as the
+    // pln#564 runtime-notes reuse: one scan, three consumers).
+    const pendingCandidates = listCandidates('pending', contextCwd);
     if (options.includePending) {
-        for (const p of listCandidates('pending', contextCwd)) {
+        for (const p of pendingCandidates) {
             const meta = [`${p.type}`, `stars:${p.star_count ?? 0}`, `uses:${p.usage_count ?? 0}`];
             if (p.author_id)
                 meta.push(`author_id:${p.author_id}`);
@@ -438,7 +442,7 @@ export function buildContext(options = {}) {
         project,
         state,
         runtimeNotes,
-        pendingCandidates: listCandidates('pending', contextCwd),
+        pendingCandidates,
     });
     // Density reflects what the store HAS, not what the char budget keeps:
     // classify pre-budget so a tight budget_tokens on a rich store never
@@ -585,7 +589,7 @@ export function buildContext(options = {}) {
     // flows through the same surface.
     let staleWarnings;
     try {
-        const pendingCandidatesForStaleness = listCandidates('pending', contextCwd);
+        const pendingCandidatesForStaleness = pendingCandidates;
         // pln#564 step A — reuse the runtime notes already loaded above (line ~316)
         // instead of a second unfiltered full scan of the runtime-note tree. On a
         // store with thousands of notes that 2nd scan dominated buildContext cost
@@ -669,7 +673,10 @@ export function buildContext(options = {}) {
             : undefined,
         estimation_calibration: (() => {
             try {
-                const report = buildEstimationReport({ agent, cwd: contextCwd });
+                // pln#578 — reuse the state loaded at the top of buildContext; the
+                // report only reads plan_items and a fresh loadState here was one of
+                // the four full-store passes per context build.
+                const report = buildEstimationReport({ agent, cwd: contextCwd, state });
                 return report.summary.with_both >= 3 ? report.summary.calibration_hint : undefined;
             }
             catch {

package/dist/core/dispatch-status.js

@@ -34,24 +34,128 @@ const DEFAULT_TAIL = 20;
 const DEFAULT_STALL_MS = 5 * 60_000;
 const DEFAULT_BASE_REF = 'master';
 /**
- * pln#554 — worktree git evidence, the signal that beats process/administrative
- * status: a worker that committed everything to its lane branch has DELIVERED,
- * whatever its pid/heartbeat/assignment.status say. Shared by dispatch-status
- * and `brainclaw dispatch watch`. Returns undefined when there is no worktree
- * or git could not be queried (never conclude "no commits" from a failed read).
+ * trp#926 — read the worktree's recorded creation ref (SHA) from its brainclaw
+ * sidecar so gitEvidence can measure "commits the worker added" against the
+ * anchor the worktree was BORN at, not the caller's moving default (which is
+ * usually `master`). Comparing to master after master advanced was the
+ * observed false-positive on rtn_c5542b05: lane HEAD's commits still appeared
+ * "ahead of master" long after they were squash-merged, so dispatch_status
+ * reported "worker delivered" for a fully integrated lane.
+ *
+ * Returns the SHA when the sidecar records `base_ref_sha`. A legacy sidecar
+ * without that field means "unknown": falling back to the caller's moving
+ * `master` would recreate the false `worker delivered` signal this fixes.
+ */
+function readWorktreeBaseRef(worktreePath) {
+    const sidecar = path.join(worktreePath, '.brainclaw-worktree.json');
+    try {
+        const meta = JSON.parse(fs.readFileSync(sidecar, 'utf-8'));
+        if (typeof meta.base_ref_sha === 'string' && meta.base_ref_sha.length > 0) {
+            return { ref: meta.base_ref_sha, legacySidecar: false };
+        }
+        return { legacySidecar: true };
+    }
+    catch {
+        return { legacySidecar: fs.existsSync(sidecar) };
+    }
+}
+function aggregateChangesMatchIntegrationBase(worktreePath, creationBase, integrationBase) {
+    try {
+        const changed = execFileSync('git', ['-C', worktreePath, 'diff', '--name-only', '-z', creationBase, 'HEAD'], {
+            encoding: 'utf-8', timeout: 15000,
+        });
+        const paths = changed.split('\0').filter(Boolean);
+        if (paths.length === 0)
+            return true;
+        for (let i = 0; i < paths.length; i += 100) {
+            const chunk = paths.slice(i, i + 100);
+            execFileSync('git', ['-C', worktreePath, 'diff', '--quiet', 'HEAD', integrationBase, '--', ...chunk], {
+                encoding: 'utf-8', timeout: 15000,
+            });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * pln#554 + trp#926 — worktree git evidence, the signal that beats process /
+ * administrative status: a worker that committed everything to its lane branch
+ * has DELIVERED, whatever its pid/heartbeat/assignment.status say. Shared by
+ * dispatch-status and `brainclaw dispatch watch`. Returns undefined when there
+ * is no worktree or git could not be queried (never conclude "no commits" from
+ * a failed read).
+ *
+ * The comparison anchor is:
+ *   1. the worktree sidecar's recorded creation SHA (`base_ref_sha`) — the
+ *      truthful anchor a worker was born at;
+ *   2. otherwise `commits_ahead_base` (caller-supplied, default `master`) ONLY
+ *      when there is no brainclaw sidecar at all (plain/non-brainclaw git
+ *      evidence callers).
+ * A legacy sidecar without `base_ref_sha` returns undefined. That is deliberate:
+ * unknown is safer than silently comparing to a moving `master`.
+ * Anchoring on the creation ref is what avoids the "worker delivered"
+ * false-positive after a squash-merge advanced master.
+ *
+ * Additionally, `commitsAhead` is refined via `git cherry <base> HEAD`
+ * (patch-id): a commit whose patch is already on `base` is treated as
+ * integrated even if its SHA is not an ancestor of `base` (squash-merge case).
+ * `commitsAheadRaw` preserves the historical ancestry-only count for callers /
+ * telemetry that need it.
  */
 export function gitEvidence(worktreePath, baseRef) {
     if (!worktreePath)
         return undefined;
+    // Two DIFFERENT anchors:
+    //   - creationBase: sidecar `base_ref_sha`, else caller `baseRef` for
+    //     non-brainclaw paths only. A legacy sidecar without the SHA is unknown.
+    //     stable anchor for "how much did the worker add?" (raw ahead count).
+    //   - integrationBase: caller `baseRef` (default `master`) — the moving
+    //     integration target the patch-id refinement compares against ("still
+    //     un-integrated?"). Using the creation SHA here would falsely count a
+    //     squash-merged commit as un-integrated (its patch is on master, but
+    //     master isn't the creation ref).
+    const recordedBase = readWorktreeBaseRef(worktreePath);
+    if (recordedBase.legacySidecar && !recordedBase.ref) {
+        logger.debug('dispatch status: git evidence unavailable: legacy worktree sidecar lacks base_ref_sha');
+        return undefined;
+    }
+    const creationBase = recordedBase.ref ?? baseRef;
+    const integrationBase = baseRef;
     try {
-        const ahead = execFileSync('git', ['-C', worktreePath, 'rev-list', '--count', `${baseRef}..HEAD`], {
+        const aheadRaw = execFileSync('git', ['-C', worktreePath, 'rev-list', '--count', `${creationBase}..HEAD`], {
             encoding: 'utf-8', timeout: 15000,
         }).trim();
         const status = execFileSync('git', ['-C', worktreePath, 'status', '--short'], {
             encoding: 'utf-8', timeout: 15000,
         });
         const dirty = status.split('\n').filter((l) => l.trim() && !l.startsWith('??')).length;
-        return { commitsAhead: Number.parseInt(ahead, 10) || 0, dirtyTracked: dirty };
+        const rawCount = Number.parseInt(aheadRaw, 10) || 0;
+        // Patch-id refinement against the INTEGRATION base: `git cherry` marks
+        // each commit in `base..HEAD` as `-` (patch on base — squash-merged /
+        // cherry-picked) or `+` (still un-integrated). Refined count = `+` lines.
+        // Best-effort — a failed cherry falls back to the raw ancestry count.
+        let refined = rawCount;
+        if (rawCount > 0) {
+            try {
+                const cherry = execFileSync('git', ['-C', worktreePath, 'cherry', integrationBase, 'HEAD'], {
+                    encoding: 'utf-8', timeout: 15000,
+                });
+                const plusLines = cherry.split(/\r?\n/).filter((l) => l.startsWith('+ '));
+                refined = plusLines.length;
+                if (refined > 0 && aggregateChangesMatchIntegrationBase(worktreePath, creationBase, integrationBase)) {
+                    refined = 0;
+                }
+            }
+            catch { /* keep raw count */ }
+        }
+        return {
+            commitsAhead: refined,
+            commitsAheadRaw: rawCount,
+            dirtyTracked: dirty,
+            baseRef: creationBase,
+        };
     }
     catch (err) {
         logger.debug('dispatch status: git evidence unavailable:', err);
@@ -348,6 +452,8 @@ export function getDispatchStatus(options) {
         last_fs_activity_ms: lastFsActivityMs,
         lane_result: laneResult,
         commits_ahead: evidence?.commitsAhead,
+        commits_ahead_raw: evidence?.commitsAheadRaw,
+        commits_ahead_base: evidence?.baseRef,
         dirty_tracked: evidence?.dirtyTracked,
     };
     let diagnosis = computeDiagnosis(assignment, agentRun, runtime, { stallMs, nowMs });