brainclaw 1.28.2 → 1.28.4

package/dist/core/loops/next-expected.js

@@ -1,3 +1,18 @@
+import { evaluatePhaseAdvanceGate } from './verbs.js';
+/** Participants eligible to speak in the current phase. Ideation reuses the
+ * same durable slots across rounds: critics converse during critique, while
+ * the champion revises and synthesizes. Other protocols retain their legacy
+ * phase binding semantics. */
+function eligiblePhaseSlots(loop) {
+    if (loop.kind === 'ideation') {
+        if (loop.current_phase === 'critique')
+            return loop.slots.filter((slot) => slot.role === 'critic');
+        if (loop.current_phase === 'proposal' || loop.current_phase === 'revision' || loop.current_phase === 'synthesis') {
+            return loop.slots.filter((slot) => slot.role === 'champion');
+        }
+    }
+    return loop.slots.filter((slot) => (slot.phase ?? loop.current_phase) === loop.current_phase);
+}
 export function computeNextExpected(loop) {
     if (loop.status === 'completed' || loop.status === 'cancelled' || loop.status === 'blocked') {
         return null;
@@ -18,7 +33,7 @@ export function computeNextExpected(loop) {
     if (loop.status === 'paused') {
         return null;
     }
-    const currentPhaseSlots = loop.slots.filter((s) => (s.phase ?? loop.current_phase) === loop.current_phase);
+    const currentPhaseSlots = eligiblePhaseSlots(loop);
     const openSlots = currentPhaseSlots.filter((s) => s.status === 'open');
     if (openSlots.length > 0) {
         const first = openSlots[0];
@@ -42,6 +57,46 @@ export function computeNextExpected(loop) {
             blocking_on: assignedOrWorking.map((s) => s.slot_id),
         };
     }
+    // A completed ideation slot is reusable in the next phase/iteration. Pick
+    // the first participant that has not yet contributed to THIS round. This is
+    // what turns critique A → critique B → critique C → champion revision
+    // into an actual conversation instead of replaying slot A forever.
+    if (loop.kind === 'ideation') {
+        const awaitingRound = currentPhaseSlots.find((slot) => slot.status === 'done'
+            && (slot.last_completed_phase !== loop.current_phase
+                || slot.last_completed_iteration !== loop.iteration_count));
+        if (awaitingRound) {
+            return {
+                action: 'turn',
+                intent: 'bclaw_loop.turn',
+                reason: 'next sequential participant in the current ideation round',
+                phase: loop.current_phase,
+                slot_id: awaitingRound.slot_id,
+                role: awaitingRound.role,
+                blocking_on: [awaitingRound.slot_id],
+            };
+        }
+    }
+    const currentPhase = loop.phases.find((phase) => phase.name === loop.current_phase);
+    const gate = evaluatePhaseAdvanceGate(loop, currentPhase?.advance_gate);
+    if (!gate.advance) {
+        // A failed/malformed worker result must lead back to a real evidence-bearing
+        // turn. Under strict evidence policy, add_artifact is audit-only and cannot
+        // satisfy the gate, so never suggest the champion/advance path here.
+        const replayable = currentPhaseSlots.filter((slot) => slot.status === 'failed');
+        const target = replayable[0] ?? currentPhaseSlots[0];
+        if (target) {
+            return {
+                action: 'turn',
+                intent: 'bclaw_loop.turn',
+                reason: `phase_gate_unmet: ${gate.gate_reason ?? 'required evidence is missing'}; replay a real slot turn (manual add_artifact does not count under strict evidence)`,
+                phase: loop.current_phase,
+                slot_id: target.slot_id,
+                role: target.role,
+                blocking_on: replayable.length > 0 ? replayable.map((slot) => slot.slot_id) : [target.slot_id],
+            };
+        }
+    }
     const phaseNames = loop.phases.map((p) => p.name);
     const currentIndex = phaseNames.indexOf(loop.current_phase);
     if (currentIndex >= 0 && currentIndex + 1 < phaseNames.length) {

package/dist/core/loops/reconcile-turn.js

@@ -506,6 +506,14 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
         // ── §6 reducer: validated result → loop artifacts + slot outcome. ──
         const reducerInput = { lane, phase: reservation.phase, critiques: input.critiques };
         const reduced = reducerForKind(loop.kind)(reducerInput, reservation);
+        if (reduced.slot_outcome === 'retryable') {
+            return {
+                reconciled: false,
+                reason: `repairable worker result: ${reduced.failure_reason ?? 'result does not satisfy the phase artifact contract'}; slot remains assigned and may be re-harvested or replayed`,
+                artifacts_added: 0,
+                loop_status: loop.status,
+            };
+        }
         artifacts_added = reduced.artifacts.length;
         slot_outcome = reduced.slot_outcome;
         // Record artifacts + complete the turn (crash-atomic WAL via complete_turn).

package/dist/core/loops/result-reducers.js

@@ -28,11 +28,11 @@ export const reviewReducer = (input, attempt) => {
     }
     if (phase === 'author_response') {
         if (lane.artifact_type !== 'author_response') {
-            return { artifacts: [], slot_outcome: 'failed', failure_reason: "review author_response requires artifact_type 'author_response'" };
+            return { artifacts: [], slot_outcome: 'retryable', failure_reason: "review author_response requires artifact_type 'author_response'" };
         }
         const response = (lane.body ?? '').trim();
         if (!response) {
-            return { artifacts: [], slot_outcome: 'failed', failure_reason: 'review author_response produced no body' };
+            return { artifacts: [], slot_outcome: 'retryable', failure_reason: 'review author_response produced no body' };
         }
         return {
             artifacts: [{ phase, type: 'author_response', body: capLoopArtifactBody(response), produced_by: attempt.agent }],
@@ -43,7 +43,7 @@ export const reviewReducer = (input, attempt) => {
         return { artifacts: [], slot_outcome: 'failed', failure_reason: `review phase '${phase}' has no worker-result contract` };
     }
     if (!lane.review_verdict) {
-        return { artifacts: [], slot_outcome: 'failed', failure_reason: 'review lane completed without a review_verdict — cannot converge the loop' };
+        return { artifacts: [], slot_outcome: 'retryable', failure_reason: 'review lane completed without a review_verdict — cannot converge the loop' };
     }
     const summary = (lane.review_summary ?? '').trim();
     const body = capLoopArtifactBody(lane.review_verdict === 'approve'
@@ -71,24 +71,26 @@ export const ideationReducer = (input, attempt) => {
             return { artifacts: [], slot_outcome: 'failed', failure_reason: `ideation phase '${phase}' has no result contract` };
         }
         if (lane.artifact_type !== artifactType) {
-            return { artifacts: [], slot_outcome: 'failed', failure_reason: `ideation phase '${phase}' expected artifact_type '${artifactType}', got '${lane.artifact_type}'` };
+            return { artifacts: [], slot_outcome: 'retryable', failure_reason: `ideation phase '${phase}' expected artifact_type '${artifactType}', got '${lane.artifact_type}'` };
         }
         const body = (lane.body ?? lane.summary).trim();
         if (!body)
-            return { artifacts: [], slot_outcome: 'failed', failure_reason: `ideation ${phase} produced no body` };
+            return { artifacts: [], slot_outcome: 'retryable', failure_reason: `ideation ${phase} produced no body` };
         if (artifactType === 'plan_draft') {
             const addresses = [
-                ...(lane.artifacts ?? []).filter((id) => /^art_[0-9a-z]+$/.test(id)),
+                ...(lane.artifacts ?? [])
+                    .map((item) => typeof item === 'string' ? item : item.ref)
+                    .filter((id) => /^art_[0-9a-z]+$/.test(id)),
                 ...(critiques ?? []).flatMap((c) => c.addresses_critique ?? []),
             ];
             const uniqueAddresses = [...new Set(addresses)];
             if (uniqueAddresses.length === 0) {
-                return { artifacts: [], slot_outcome: 'failed', failure_reason: 'ideation synthesis must cite critique artifact ids in lane.artifacts' };
+                return { artifacts: [], slot_outcome: 'retryable', failure_reason: 'ideation synthesis must cite critique artifact ids in lane.artifacts' };
             }
             if (!lane.implementation_verify) {
                 return {
                     artifacts: [],
-                    slot_outcome: 'failed',
+                    slot_outcome: 'retryable',
                     failure_reason: 'ideation synthesis must declare implementation_verify for deterministic downstream verification',
                 };
             }
@@ -107,10 +109,10 @@ export const ideationReducer = (input, attempt) => {
         return { artifacts: [{ phase, type: artifactType, body: capLoopArtifactBody(body), produced_by: attempt.agent }], slot_outcome: 'done' };
     }
     if (lane.artifact_type !== 'critique') {
-        return { artifacts: [], slot_outcome: 'failed', failure_reason: "ideation critique requires artifact_type 'critique'" };
+        return { artifacts: [], slot_outcome: 'retryable', failure_reason: "ideation critique requires artifact_type 'critique'" };
     }
     if (!critiques || critiques.length === 0) {
-        return { artifacts: [], slot_outcome: 'failed', failure_reason: 'ideation critique lane produced no critiques (bare summary) — gate stays shut' };
+        return { artifacts: [], slot_outcome: 'retryable', failure_reason: 'ideation critique lane produced no critiques (bare summary) — correct the lane result or replay this slot; gate stays shut' };
     }
     return {
         artifacts: critiques.map((c) => ({
@@ -148,7 +150,7 @@ function typedPhaseReducer(kind, artifactByPhase) {
         if (lane.artifact_type !== expectedType) {
             return {
                 artifacts: [],
-                slot_outcome: 'failed',
+                slot_outcome: 'retryable',
                 failure_reason: `${kind} phase '${phase}' expected artifact_type '${expectedType}', got '${lane.artifact_type}'`,
             };
         }
@@ -156,7 +158,7 @@ function typedPhaseReducer(kind, artifactByPhase) {
         // summary can never masquerade as a gate-driving repro or verify report.
         const body = (lane.body ?? lane.summary).trim();
         if (!body) {
-            return { artifacts: [], slot_outcome: 'failed', failure_reason: `${kind} phase '${phase}' produced no artifact body` };
+            return { artifacts: [], slot_outcome: 'retryable', failure_reason: `${kind} phase '${phase}' produced no artifact body` };
         }
         return {
             artifacts: [{ phase, type: expectedType, body: capLoopArtifactBody(body), produced_by: attempt.agent }],

package/dist/core/loops/store.js

@@ -68,6 +68,7 @@ function buildSlot(partial) {
         role: partial.role,
         agent: partial.agent,
         agent_id: partial.agent_id,
+        perspective: partial.perspective,
         assignment_id: partial.assignment_id,
         claim_id: partial.claim_id,
         phase: partial.phase,
@@ -76,6 +77,9 @@ function buildSlot(partial) {
         plan_ids: partial.plan_ids,
         step_ids: partial.step_ids,
         status: partial.status ?? 'open',
+        current_turn_id: partial.current_turn_id,
+        last_completed_phase: partial.last_completed_phase,
+        last_completed_iteration: partial.last_completed_iteration,
     };
 }
 export function appendEvent(loopId, event, cwd, 

package/dist/core/loops/types.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export const LOOP_ARTIFACT_BODY_MAX_BYTES = 4096;
+/** Ideation proposals are caller-authored task contracts, not worker summaries. */
+export const LOOP_PROPOSAL_BODY_MAX_BYTES = 32 * 1024;
 export const LOOP_KINDS = ['review', 'ideation', 'implementation', 'research', 'debug'];
 export const LOOP_STATUSES = ['open', 'paused', 'completed', 'blocked', 'cancelled'];
 export const REVIEW_MODES = ['asymmetric', 'symmetric'];
@@ -130,6 +132,8 @@ export const LoopVerifyConfigSchema = z.object({
 });
 export const LoopProtocolConfigSchema = z.object({
     review_mode: z.enum(REVIEW_MODES).optional(),
+    /** Whether ideation participants take ordered turns or fan out together. */
+    ideation_schedule: z.enum(['sequential', 'parallel']).optional(),
     iteration: LoopIterationSchema.optional(),
     /** pln#632 — engine-run verify command (opener-provided; makes command_green real). */
     verify: LoopVerifyConfigSchema.optional(),
@@ -160,6 +164,8 @@ export const LoopSlotSchema = z.object({
     role: z.string().min(1),
     agent: z.string().optional(),
     agent_id: z.string().optional(),
+    /** Stable point of view/instruction for this participant across rounds. */
+    perspective: z.string().min(1).max(1000).optional(),
     assignment_id: z.string().optional(),
     claim_id: z.string().optional(),
     phase: z.string().optional(),
@@ -178,6 +184,9 @@ export const LoopSlotSchema = z.object({
      * reusable slot. Additive; wired onto the dispatch path in a later PR.
      */
     current_turn_id: z.string().optional(),
+    /** Last successful contribution, used to rotate reusable slots each round. */
+    last_completed_phase: z.string().optional(),
+    last_completed_iteration: z.number().int().nonnegative().optional(),
 });
 // ───────────────────────────────────────────────────────────────────────
 // pln#508 step 1 — bootstrap loop foundation: operator-interaction schemas
@@ -495,10 +504,13 @@ export const LoopArtifactSchema = z
     evidence: EvidenceEnvelopeSchema.optional(),
 })
     .superRefine((artifact, ctx) => {
-    if (artifact.body !== undefined && Buffer.byteLength(artifact.body, 'utf8') > LOOP_ARTIFACT_BODY_MAX_BYTES) {
+    const bodyLimit = artifact.type === 'proposal'
+        ? LOOP_PROPOSAL_BODY_MAX_BYTES
+        : LOOP_ARTIFACT_BODY_MAX_BYTES;
+    if (artifact.body !== undefined && Buffer.byteLength(artifact.body, 'utf8') > bodyLimit) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: `LoopArtifact.body must be ≤ ${LOOP_ARTIFACT_BODY_MAX_BYTES} bytes; use a ref for larger content`,
+            message: `LoopArtifact.body must be ≤ ${bodyLimit} bytes; use a ref for larger content`,
             path: ['body'],
         });
     }

package/dist/core/loops/verbs.js

@@ -662,7 +662,14 @@ function completeTurnCommit(input, cwd) {
     // Map outcome → terminal slot.status so observers reading the thread can
     // distinguish done/failed/cancelled without replaying the event journal.
     const terminalStatus = outcome;
-    const updatedSlots = current.slots.map((s) => s.slot_id === slot.slot_id ? { ...s, status: terminalStatus } : s);
+    const updatedSlots = current.slots.map((s) => s.slot_id === slot.slot_id ? {
+        ...s,
+        status: terminalStatus,
+        ...(terminalStatus === 'done' ? {
+            last_completed_phase: slot.phase ?? current.current_phase,
+            last_completed_iteration: current.iteration_count,
+        } : {}),
+    } : s);
     // A negative convergence signal is only valid after the critic window has
     // causally closed. The last trusted critic completion records that boundary;
     // mere absence of critique artifacts while a turn is open is never enough.

package/dist/core/loops/worker-reply-contract.js

@@ -81,7 +81,7 @@ export function renderWorkerReplyProse(contract) {
         `- MCP path: call \`${action.tool}\` with ${JSON.stringify(action.args)}`,
         `- The body must be NON-EMPTY: an artifact without usable content does not count toward the gate.`,
         `- Body cap: ${contract.body_max_bytes} bytes. If your output is larger, write the full version to a markdown file in your worktree and put a dense summary plus the file path in the body.`,
-        `- File fallback (no MCP): in LANE-RESULT.json set "artifact_type":"${contract.requirements[0].type}" and put your full output in "body" — the harvester records it under this contract.`,
+        `- File fallback (no MCP): write the worktree-root filename exactly as \`LANE-RESULT.json\` (uppercase, hyphen, no suffix or subdirectory); set "artifact_type":"${contract.requirements[0].type}" and put your full output in "body" — the harvester records it under this contract.`,
         `- This contract is FROZEN for loop version ${contract.loop_version}, phase "${contract.phase}". If your submit reports a version conflict or the loop has advanced, your work is still recorded under phase "${contract.phase}" — do not re-target a newer phase.`,
     ];
     if (contract.other_conditions.length > 0) {

package/dist/core/protocol-tool-policy.js

@@ -69,6 +69,7 @@ export const MCP_HEADLESS_AUTO_TOOL_NAMES = [
     'bclaw_assignment_update',
     'bclaw_assignment_action',
     'bclaw_harvest_candidates',
+    'bclaw_harvest',
     'bclaw_find',
     'bclaw_get',
 ];

package/dist/core/review-loop-turn-dispatch.js

@@ -402,6 +402,7 @@ export async function dispatchReviewLoopTurn(input) {
                 attempt_epoch: turnEcho.attempt_epoch,
                 workspace_digest: turnEcho.workspace_digest,
             } : undefined,
+            artifactType: phase === 'author_response' ? 'author_response' : 'verdict',
             cwd, // pln#638 PR-6b — the context envelope reads the store
         });
         const msg = sendMessage({

package/dist/core/schema.js

@@ -144,6 +144,16 @@ export const ProvenanceSchema = z.discriminatedUnion('kind', [
  * entity-operations.ts which enforces the typed shape.
  */
 export const ProvenancePassthroughSchema = z.unknown().optional();
+/** Replayable empirical assertion attached to a perishable memory claim. */
+export const MemoryVerificationSchema = z.object({
+    kind: z.enum(['command', 'query']),
+    input: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+    expected: z.string().min(1),
+    observed: z.string().optional(),
+    verified_at: z.string().datetime(),
+    outcome: z.enum(['pass', 'fail']),
+    max_age_days: z.number().positive().optional(),
+});
 export const ConstraintSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
@@ -163,6 +173,8 @@ export const ConstraintSchema = z.object({
     related_paths: z.array(z.string()).optional(),
     plan_id: z.string().optional(),
     expires_at: z.string().optional(),
+    verified_at: z.string().optional(),
+    verify_cmd: z.string().optional(),
     // pln#544 — memory-lifecycle (confirm/decay/reinforce). Symmetric across
     // constraint/decision/trap. `verified_at` (pln#530 perishable-fact
     // re-verification) is kept as a narrower legacy signal alongside.
@@ -175,6 +187,7 @@ export const ConstraintSchema = z.object({
     /** Bounded event log (most recent N) — older events are dropped, the
      *  counts remain accurate. Empty / absent means "never confirmed". */
     confirmations: z.array(MemoryConfirmationEventSchema).optional(),
+    verification: MemoryVerificationSchema.optional(),
     provenance: ProvenancePassthroughSchema,
 });
 export const DecisionSchema = z.object({
@@ -207,6 +220,7 @@ export const DecisionSchema = z.object({
     saved_me_count: z.number().int().nonnegative().optional(),
     misled_me_count: z.number().int().nonnegative().optional(),
     confirmations: z.array(MemoryConfirmationEventSchema).optional(),
+    verification: MemoryVerificationSchema.optional(),
     provenance: ProvenancePassthroughSchema,
 });
 export const TrapSchema = z.object({
@@ -243,6 +257,7 @@ export const TrapSchema = z.object({
     saved_me_count: z.number().int().nonnegative().optional(),
     misled_me_count: z.number().int().nonnegative().optional(),
     confirmations: z.array(MemoryConfirmationEventSchema).optional(),
+    verification: MemoryVerificationSchema.optional(),
     provenance: ProvenancePassthroughSchema,
 });
 export const HandoffContractSchema = z.object({
@@ -1068,6 +1083,14 @@ export const RuntimeEventTypeSchema = z.enum([
  * durable runtime event before a loop closer applies its smaller display cap.
  */
 export const LANE_RESULT_BODY_MAX_BYTES = 64 * 1024;
+export const LaneResultArtifactSchema = z.union([
+    z.string().min(1),
+    z.object({
+        type: z.string().min(1),
+        ref: z.string().min(1),
+        description: z.string().optional(),
+    }),
+]);
 export const LaneResultSchema = z.object({
     assignment_id: z.string(),
     /**
@@ -1089,7 +1112,7 @@ export const LaneResultSchema = z.object({
     status: z.enum(['completed', 'blocked', 'failed']),
     summary: z.string(),
     /** Paths or refs the worker produced (commits, files, docs). */
-    artifacts: z.array(z.string()).optional(),
+    artifacts: z.array(LaneResultArtifactSchema).optional(),
     /** Files the worker changed in the worktree. */
     files_changed: z.array(z.string()).optional(),
     /** Free-form notes (blockers, follow-ups). */

package/dist/core/search.js

@@ -1,6 +1,7 @@
 import { loadState } from './state.js';
 import { listCandidates } from './candidates.js';
 import { listSequences } from './sequence.js';
+import { isTrapActive } from './traps.js';
 const K1 = 1.5;
 const B = 0.75;
 function tokenize(text) {
@@ -23,11 +24,11 @@ function buildCorpus(state, includePending, cwd, includeLegacy = false) {
         const textParts = [item.text, item.author ?? '', ...(item.tags ?? []), ...(item.related_paths ?? [])];
         docs.push({ ...item, section, terms: tokenize(textParts.join(' ')) });
     };
-    for (const c of state.active_constraints)
+    for (const c of state.active_constraints.filter((item) => item.status === 'active'))
         add('constraints', c);
     for (const d of state.recent_decisions)
         add('decisions', d);
-    for (const t of state.known_traps)
+    for (const t of state.known_traps.filter((item) => isTrapActive(item)))
         add('traps', { ...t, text: t.text });
     for (const h of state.open_handoffs)
         add('handoffs', { ...h, text: `${h.from} -> ${h.to}: ${h.text}` });

package/dist/core/spawn-check.js

@@ -96,7 +96,15 @@ export async function checkAgentSpawn(agent, options = {}) {
         const stderrRaw = readLogTail(root, assignmentId, 'stderr', 800).trim();
         const stderrTail = stderrRaw ? stderrRaw.split(/\r?\n/).filter(Boolean) : undefined;
         if (completed) {
-            return { agent, binary, status: 'ok', delivered, completed: true, duration_ms, detail: 'ack + completed round-trip' };
+            return {
+                agent,
+                binary,
+                status: 'ok',
+                delivered,
+                completed: true,
+                duration_ms,
+                detail: `validation probe: ack + completed round-trip (${invoke.promptDelivery}, ${invoke.promptText?.length ?? 0} prompt bytes)`,
+            };
         }
         if (failed) {
             const tail = stderrRaw || readLogTail(root, assignmentId, 'stdout', 400).trim();

package/dist/core/worktree.js

@@ -968,11 +968,9 @@ export function createWorktree(mainWorktreePath, branchName, options = {}) {
     // the dispatch brief can tell the worker the truth. A failed install/copy is
     // best-effort (non-fatal) but the worker must then install itself — the brief
     // must NOT claim "node_modules is real, do not reinstall" over a failure.
-    let depsProvisioned;
     if (provisionDeps) {
         const provisionWarnings = provisionWorktreeDeps(depsMode, mainWorktreePath, targetPath, nodeModulesPaths);
         symlinkWarnings.push(...provisionWarnings);
-        depsProvisioned = provisionWarnings.length === 0;
     }
     else if (depsMode === 'link') {
         // trp_37b05a15 (field report, Next.js 16 / Turbopack) — the node_modules link
@@ -992,6 +990,15 @@ export function createWorktree(mainWorktreePath, branchName, options = {}) {
             logger.warn(`[worktree] ${msg}`);
         }
     }
+    // Record observed availability, not only the requested provisioning mode.
+    // This is deliberately evaluated after link/install/copy so dispatch briefs
+    // cannot claim a main-repo dependency tree that never existed.
+    const depsPaths = [...new Set([
+            ...requested.filter(isNodeModulesPath),
+            ...detectWorkspaceNodeModules(targetPath),
+        ])]
+        .filter((relativePath) => fs.existsSync(path.join(targetPath, relativePath)));
+    const depsProvisioned = depsMode === 'none' ? false : depsPaths.length > 0;
     // NOTE: .brainclaw/ is intentionally NOT symlinked.
     // Symlinking .brainclaw/ causes hooks and session_start to trigger on the
     // shared store, creating session conflicts and potentially blocking agents
@@ -1033,11 +1040,11 @@ export function createWorktree(mainWorktreePath, branchName, options = {}) {
         // trp_37b05a15: how JS deps were provisioned (link junction / real install /
         // copy / none) — non-default modes are recorded so a worker/supervisor knows
         // whether node_modules is an out-of-root link (dev-server caveat) or in-root.
-        // `deps_provisioned` (install/copy only) records whether the in-root
-        // provisioning actually succeeded — false means best-effort failed and the
-        // worker must install itself (Codex review P1).
-        ...(depsMode !== 'link' ? { deps_mode: depsMode } : {}),
-        ...(depsProvisioned !== undefined ? { deps_provisioned: depsProvisioned } : {}),
+        // `deps_provisioned` and `deps_paths` record observed availability. They are
+        // emitted for link mode too: requested capacity is not executable capacity.
+        deps_mode: depsMode,
+        deps_provisioned: depsProvisioned,
+        deps_paths: depsPaths,
         // pln#523: surface any shared-path link failures (e.g. node_modules junction
         // that could not be created) so the worker / supervisor can see why a build
         // might fail, instead of an invisible degradation.

package/dist/facts.js

@@ -1,11 +1,11 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.28.2 on 2026-08-25T18:22:09.950Z
+// Source: brainclaw v1.28.4 on 2026-08-28T07:25:30.486Z
 export const FACTS = {
-  "version": "1.28.2",
-  "generated_at": "2026-08-25T18:22:09.950Z",
+  "version": "1.28.4",
+  "generated_at": "2026-08-28T07:25:30.486Z",
   "tools": {
-    "count": 70,
-    "published_count": 68,
+    "count": 71,
+    "published_count": 69,
     "names": [
       "bclaw_bootstrap",
       "bclaw_release_notes",
@@ -70,6 +70,7 @@ export const FACTS = {
       "bclaw_assignment_update",
       "bclaw_assignment_action",
       "bclaw_harvest_candidates",
+      "bclaw_harvest",
       "bclaw_find",
       "bclaw_get",
       "bclaw_create",
@@ -478,7 +479,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-25T18:22:07.761Z",
+    "generated_at": "2026-08-28T07:25:28.367Z",
     "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -487,7 +488,7 @@ export const FACTS = {
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 82,
+        "duration_ms_median": 80,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -495,7 +496,7 @@ export const FACTS = {
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 132,
+        "duration_ms_median": 124,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -503,7 +504,7 @@ export const FACTS = {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 13,
+        "duration_ms_median": 11,
         "payload_chars_median": 1629,
         "payload_tokens_est_median": 407
       }

package/dist/facts.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.28.2",
-  "generated_at": "2026-08-25T18:22:09.950Z",
+  "version": "1.28.4",
+  "generated_at": "2026-08-28T07:25:30.486Z",
   "tools": {
-    "count": 70,
-    "published_count": 68,
+    "count": 71,
+    "published_count": 69,
     "names": [
       "bclaw_bootstrap",
       "bclaw_release_notes",
@@ -68,6 +68,7 @@
       "bclaw_assignment_update",
       "bclaw_assignment_action",
       "bclaw_harvest_candidates",
+      "bclaw_harvest",
       "bclaw_find",
       "bclaw_get",
       "bclaw_create",
@@ -476,7 +477,7 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-25T18:22:07.761Z",
+    "generated_at": "2026-08-28T07:25:28.367Z",
     "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -485,7 +486,7 @@
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 82,
+        "duration_ms_median": 80,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -493,7 +494,7 @@
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 132,
+        "duration_ms_median": 124,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -501,7 +502,7 @@
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 13,
+        "duration_ms_median": 11,
         "payload_chars_median": 1629,
         "payload_tokens_est_median": 407
       }

package/docs/cli.md

@@ -639,11 +639,11 @@ Full reference (freshness model, supported languages, WASM bundling): [docs/code
 
 ### `brainclaw code-map status [--cascade]`
 
-Store presence, freshness badge (`fresh` / `stale_changed_files` / `stale_extractor` / `stale_grammar` / `partial` / `missing_index`), and index stats (files, nodes, edges). Read-only. In a multi-project workspace, `--cascade` adds a per-child recap (which nested projects have a built index vs `missing_index`, plus an aggregate count).
+Store presence, freshness badge (`fresh` / `stale_changed_files` / `stale_extractor` / `stale_grammar` / `partial` / `missing_index`), and index stats (files, nodes, edges). Read-only. In a multi-project workspace, `--cascade` adds compact coverage counts and names only non-fresh projects. On the MCP surface, the equivalent `bclaw_code_status(cascade=true)` also follows the latest durable cascade job.
 
 ### `brainclaw code-map refresh [--all|--changed] [--cascade]`
 
-Build or update the index. `--changed` (default) re-parses only touched files; `--all` does a full re-index. Run this when status shows `missing_index` or a stale badge. Fails fast (never blocks) if another writer holds the project lock. In a multi-project workspace, `--cascade` refreshes **every nested project** into its own store plus a root store scoped to the files no child owns (zero double-indexing) — one command at the root indexes the whole monorepo per-project. See [docs/code-map.md](code-map.md#cascading-a-multi-project-workspace---cascade).
+Build or update the index. `--changed` (default) re-parses only touched files; `--all` does a full re-index. Run this when status shows `missing_index` or a stale badge. Fails fast (never blocks) if another writer holds the project lock. In a multi-project workspace, `--cascade` synchronously refreshes each discovered project into its own store plus a root store scoped to files no child owns (zero double-indexing). The MCP equivalent starts a durable background job instead; follow it with `bclaw_code_status(cascade=true)`. See [docs/code-map.md](code-map.md#cascading-a-multi-project-workspace---cascade).
 
 ### `brainclaw code-map find <query> [--limit <n>]`
 
@@ -1185,6 +1185,39 @@ brainclaw update-handoff hnd_001 --review-verdict request_changes --reviewed-by
 
 ---
 
+## Worker result harvest
+
+### `brainclaw harvest [assignment_id]`
+
+Ingest a worker's `LANE-RESULT.json`, reconcile any bound loop turn, and report
+the exact continuation. Pass one assignment id or use `--all`; this is distinct
+from `harvest-candidates`, which imports proposed memory items.
+
+| Option | Description |
+|---|---|
+| `--all` | Scan every managed worktree |
+| `--integrate` | Also commit a sandboxed worker's worktree diff and settle its lifecycle |
+| `--orphaned` | Recover a dead worker that left no lane result, without deleting/resetting work |
+| `--base <ref>` | Base ref used by orphan recovery (default `master`) |
+| `--dry-run` | Preview without writing events or markers |
+| `--worktree <path>` | Explicit worktree to scan; repeatable |
+| `--json` | Return lane results, warnings, and loop continuations as JSON |
+
+```bash
+brainclaw harvest asgn_123
+brainclaw harvest --all --json
+brainclaw harvest --integrate asgn_123
+```
+
+The exact filename is `LANE-RESULT.json`. A unique root-level JSON file whose
+schema and `assignment_id` match can be recovered when a worker chose the wrong
+name; Brainclaw refuses ambiguous candidates. `artifacts` accepts either string
+refs or `{type, ref, description?}` objects, while loop workers must also emit
+the `artifact_type` named in their brief. A repairable schema/contract error
+keeps the real turn replayable and eligible for corrected re-harvest.
+
+---
+
 ## Dispatch
 
 The `dispatch` command group manages the local agent dispatcher: it analyzes the active sequence for lane readiness and assigns work to available agents.