brainclaw 1.11.1 → 1.13.0

package/dist/commands/release-claim.js

@@ -3,16 +3,36 @@ import { mutate } from '../core/mutation-pipeline.js';
 import { loadClaim, listClaims, releaseClaim } from '../core/claims.js';
 import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState, mutateState } from '../core/state.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
 export function runReleaseClaim(id, options = {}) {
     if (!memoryExists(options.cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
     try {
+        // Surface split (trp#928 follow-up): the ownership gate lives on the MCP
+        // surface (bclaw_release_claim / bclaw_transition), where agent callers
+        // carry a session-bound identity. The CLI `release-claim <id>` is the
+        // operator/scripting surface and keeps its historic unguarded semantics —
+        // the e2e contract (collaboration.test.ts) has always released cross-agent
+        // claims from an env-identified CLI. Deriving an ambient identity here and
+        // gating on it turned every operator release into a false ownership
+        // mismatch (silent-default anti-pattern, pln#607). `--coordinator-override`
+        // stays available to make a cross-agent release explicit and audited.
+        let releaseAuth;
+        if (options.coordinatorOverride) {
+            const identity = requireRegisteredAgentIdentity({ cwd: options.cwd, allowCurrent: true, allowEnv: true });
+            requireMinimumTrustLevel(identity, 'trusted');
+            releaseAuth = {
+                agent: identity.agent_name,
+                agent_id: identity.agent_id,
+                override: true,
+            };
+        }
         let claim = loadClaim(id, options.cwd);
         mutate({ cwd: options.cwd }, () => {
             const existing = loadClaim(id, options.cwd);
-            claim = releaseClaim(id, options.cwd);
+            claim = releaseClaim(id, options.cwd, releaseAuth);
             if (existing.plan_id) {
                 const updated = mutateState((state) => {
                     const plan = state.plan_items.find((item) => item.id === existing.plan_id);

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/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 });

package/dist/core/entity-operations.js

@@ -15,7 +15,7 @@ import path from 'node:path';
 import { loadState, mutateState } from './state.js';
 import { archiveCandidate, listCandidates, loadCandidate, saveCandidate, } from './candidates.js';
 import { addCrossProjectLink, removeCrossProjectLink, resolveCrossProjectLinks, } from './cross-project.js';
-import { listClaims, loadClaim, saveClaim } from './claims.js';
+import { findActiveClaimsForPlan, listClaims, loadClaim, logCascadeReleaseResult, markClaimStale, releaseClaimsCascade, releaseClaimWithCascade, saveClaim, } from './claims.js';
 import { listActionRequired } from './actions.js';
 import { deleteAssignment, listAssignments, loadAssignment, saveAssignment, transitionAssignment } from './assignments.js';
 import { listAgentRuns } from './agentruns.js';
@@ -599,8 +599,7 @@ export function removeEntity(name, id, cwd, purge = false) {
             throw new EntityOperationUnsupportedError(name, 'remove');
     }
 }
-// ─── TRANSITION ───────────────────────────────────────────────────────
-export function transitionEntity(name, id, to, cwd, _reason) {
+export function transitionEntity(name, id, to, cwd, _reason, auth) {
     const spec = ENTITY_REGISTRY[name];
     if (!spec.statusField) {
         throw new Error(`${name} has no lifecycle (statusField is undefined)`);
@@ -619,6 +618,32 @@ export function transitionEntity(name, id, to, cwd, _reason) {
     switch (name) {
         case 'plan': {
             updatePlan({ id, status: to }, cwd);
+            // trp#928 — implement the `release_linked_claims_if_last` cascade tag.
+            // Before this landing the tag was advertised by the entity registry but
+            // the imperative cascade never ran, so a plan closed while its worker
+            // claims stayed active (ghost claims). The cascade now:
+            //  - runs only on plan → done (the tag's actual trigger)
+            //  - releases each active claim linked via plan_id
+            //  - LOGS per claim (released / skipped+reason / error) via the runtime
+            //    event journal so `bclaw_find(entity=agent_run)` and dashboards can
+            //    observe silent ownership failures instead of guessing at them.
+            // Ownership check: this path runs from bclaw_transition, so it inherits
+            // the caller's TransitionAuth (populated for entity='claim' but not for
+            // entity='plan'). auth undefined = system convergence (bypass ownership),
+            // matching the historical implicit contract for plan cascades.
+            if (to === 'done') {
+                const linked = findActiveClaimsForPlan(id, cwd);
+                if (linked.length > 0) {
+                    const cascade = releaseClaimsCascade(linked.map((c) => c.id), { cwd });
+                    logCascadeReleaseResult({
+                        actor: 'system',
+                        trigger: 'plan_done',
+                        plan_id: id,
+                        cascade,
+                        cwd,
+                    });
+                }
+            }
             return { entity: name, id, from, to, side_effects: sideEffects };
         }
         case 'decision':
@@ -656,6 +681,29 @@ export function transitionEntity(name, id, to, cwd, _reason) {
             updateSequence({ id, status: to }, cwd);
             return { entity: name, id, from, to, side_effects: sideEffects };
         }
+        case 'claim': {
+            // trp#928 — the entity registry advertised `active → released|stale` but
+            // transitionEntity never routed for entity=claim. The isValidTransition
+            // check above passed for anyone calling `bclaw_transition(entity='claim',
+            // to='released')`, but the transition then fell through to the
+            // EntityOperationUnsupportedError default. Now: released hits the same
+            // cascade path bclaw_release_claim uses (audit + plan-done cascade); stale
+            // uses markClaimStale (audit + `stale` terminal status). Reuses ReleaseClaimAuth
+            // so a trusted+ coordinator can release across ownership with override.
+            const releaseAuth = auth
+                ? { agent: auth.agent, agent_id: auth.agent_id, session_id: auth.session_id, override: auth.override }
+                : undefined;
+            if (to === 'released') {
+                releaseClaimWithCascade(id, { planStatus: _reason === 'done' ? 'done' : undefined, cwd, auth: releaseAuth });
+                return { entity: name, id, from, to, side_effects: sideEffects };
+            }
+            if (to === 'stale') {
+                markClaimStale(id, cwd, releaseAuth);
+                return { entity: name, id, from, to, side_effects: sideEffects };
+            }
+            // isValidTransition already excluded every other target — belt-and-braces:
+            throw new InvalidTransitionError(name, from, to);
+        }
         default:
             throw new EntityOperationUnsupportedError(name, 'transition', `Lifecycle transitions for ${name} not yet wired.`);
     }

package/dist/core/loops/store.js

@@ -5,6 +5,7 @@ import { memoryDir, writeFileAtomic } from '../io.js';
 import { nowISO } from '../ids.js';
 import { logger } from '../logger.js';
 import { convergeAssignmentToTerminal, loadAssignment } from '../assignments.js';
+import { logCascadeReleaseResult, releaseClaimsCascade } from '../claims.js';
 import { gcWorktreeIfHarvested } from '../worktree.js';
 import { writeProjectMdSafe } from './hooks/bootstrap-write.js';
 import { notifyOperatorOnInputRequested } from './hooks/notify-operator.js';
@@ -435,6 +436,38 @@ export function closeLoop(input, cwd) {
         }
         catch { /* never block loop close on assignment convergence */ }
     }
+    // trp#928 — cascade-release claims linked to slots + slot-linked assignments.
+    // Before this landing, loop close converged the assignment lifecycle but left
+    // reviewer claims active indefinitely (dogfooding 2026-07: 23 ghost claims,
+    // most from closed review loops). System-actor release: no auth → the
+    // ownership check is skipped, matching convergeAssignmentToTerminal's contract
+    // above (loop close is a system action, not a user-driven release).
+    const claimIdsFromSlots = [];
+    for (const slot of next.slots) {
+        if (slot.claim_id)
+            claimIdsFromSlots.push(slot.claim_id);
+        if (slot.assignment_id) {
+            try {
+                const assignment = loadAssignment(slot.assignment_id, cwd);
+                if (assignment?.claim_id)
+                    claimIdsFromSlots.push(assignment.claim_id);
+            }
+            catch { /* assignment gone — skip */ }
+        }
+    }
+    if (claimIdsFromSlots.length > 0) {
+        try {
+            const cascade = releaseClaimsCascade(claimIdsFromSlots, { cwd });
+            logCascadeReleaseResult({
+                actor: input.actor,
+                trigger: 'loop_close',
+                loop_id: input.id,
+                cascade,
+                cwd,
+            });
+        }
+        catch { /* never block loop close on cascade release */ }
+    }
     // pln#594: GC the dispatched sub-agent worktrees now the loop is done, so
     // review/dispatch worktrees stop accumulating under ~/.brainclaw/worktrees/.
     // Only on a COMPLETED close — cancelled/blocked keep their worktree (+ run

package/dist/core/reputation.js

@@ -281,6 +281,24 @@ export function buildReputationSnapshot(cwd) {
         resume_weight: 0.35,
         mcp_exposure: false,
     };
+    // pln#578 — disabled reputation (the default) must not pay for the sweep.
+    // Every consumer already treats a disabled snapshot as empty: agents is []
+    // (line below gates on enabled), so ranking bonuses are 0 and the resume
+    // summary is undefined. Yet the full signal sweep (pending + archived
+    // candidates, all runtime notes, all claims, a complete loadState) was still
+    // running — two of the four full-store read passes a single buildContext
+    // performed on a large store. Exit before any store read when disabled.
+    if (!reputationConfig.enabled) {
+        return {
+            enabled: false,
+            visibility: reputationConfig.visibility,
+            window_days: reputationConfig.decay_days,
+            generated_at: nowISO(),
+            project_id: config.project_id,
+            current_agent_id: resolveCurrentAgentIdentity(cwd)?.agent_id,
+            agents: [],
+        };
+    }
     const registered = listAgentIdentities(cwd);
     const currentAgent = resolveCurrentAgentIdentity(cwd);
     const resolvers = buildIdentityResolvers(registered);

package/dist/core/schema.js

@@ -1122,6 +1122,13 @@ export const CurrentSessionStateSchema = z.object({
     branch: z.string().optional(),
     /** Isolation mode: shared-checkout (default) or dedicated-worktree. */
     isolation_mode: IsolationModeSchema.optional(),
+    /**
+     * True when the session was materialized by an auto-repair path (e.g. a
+     * canonical write arriving without a prior session). Tag lets aggressive
+     * harvesting distinguish worker-authored sessions from operator sessions
+     * (pln#602 lesson on the pln#578 887-file blowup).
+     */
+    auto_created: z.boolean().optional(),
 });
 export const MemorySeedKindSchema = z.enum([
     'command',