brainclaw 1.28.3 → 1.28.4

package/dist/core/lane-result-file.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { LANE_RESULT_BODY_MAX_BYTES, LaneResultSchema, } from './schema.js';
+export const LANE_RESULT_FILENAME = 'LANE-RESULT.json';
+const MAX_RESULT_FILE_BYTES = LANE_RESULT_BODY_MAX_BYTES + 16 * 1024;
+function parseLaneResultFile(file) {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MAX_RESULT_FILE_BYTES)
+        return undefined;
+    return LaneResultSchema.parse(JSON.parse(fs.readFileSync(file, 'utf-8')));
+}
+/**
+ * Resolve a worker's terminal result without trusting arbitrary paths.
+ *
+ * The protocol filename is exact and remains authoritative. When an agent
+ * nevertheless renames it, recover only a UNIQUE schema-valid JSON file at the
+ * worktree root (never recursively, never through a symlink), optionally bound
+ * to the requested assignment id. Ambiguity is surfaced instead of guessed.
+ */
+export function resolveLaneResultFile(worktreePath, assignmentId) {
+    const canonicalPath = path.join(worktreePath, LANE_RESULT_FILENAME);
+    let foreignCanonical;
+    if (fs.existsSync(canonicalPath)) {
+        try {
+            const lane = parseLaneResultFile(canonicalPath);
+            if (!lane) {
+                return { kind: 'invalid', path: canonicalPath, error: 'file is not a regular bounded lane-result file' };
+            }
+            const found = { kind: 'found', path: canonicalPath, lane, canonical: true };
+            if (!assignmentId || lane.assignment_id === assignmentId)
+                return found;
+            foreignCanonical = found;
+        }
+        catch (err) {
+            return {
+                kind: 'invalid',
+                path: canonicalPath,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(worktreePath, { withFileTypes: true });
+    }
+    catch {
+        return foreignCanonical ?? { kind: 'absent' };
+    }
+    const recovered = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.json') || entry.name === LANE_RESULT_FILENAME)
+            continue;
+        const candidatePath = path.join(worktreePath, entry.name);
+        try {
+            const lane = parseLaneResultFile(candidatePath);
+            if (lane && (!assignmentId || lane.assignment_id === assignmentId)) {
+                recovered.push({ path: candidatePath, lane });
+            }
+        }
+        catch {
+            // Ordinary project JSON and malformed non-canonical files are not lane results.
+        }
+    }
+    if (recovered.length === 1) {
+        return { kind: 'found', ...recovered[0], canonical: false };
+    }
+    if (recovered.length > 1) {
+        return { kind: 'ambiguous', paths: recovered.map((item) => item.path).sort() };
+    }
+    return foreignCanonical ?? { kind: 'absent' };
+}
+//# sourceMappingURL=lane-result-file.js.map

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

@@ -82,6 +82,7 @@ export async function dispatchLoopTurn(input) {
     const phaseBrief = buildIdeationBrief({
         thread: loop,
         slotRole: slot.role,
+        slotPerspective: slot.perspective,
         memoryProvider: provider,
         seedText: input.task,
         scopeHints: slot.scope_hint ? slot.scope_hint.split(',').map((value) => value.trim()) : [],
@@ -180,6 +181,7 @@ export async function dispatchLoopTurn(input) {
                 attempt_epoch: prepared.attempt_epoch,
                 workspace_digest: prepared.workspace_digest,
             } : undefined,
+            artifactType: policy.expected_artifacts?.[0]?.loop_artifact_type,
             cwd: input.cwd,
         });
         const message = sendMessage({

package/dist/core/loops/brief-assembly.js

@@ -45,7 +45,7 @@ const LOOP_INTERNAL_CATEGORIES = new Set([
     'synthesis_artifact',
 ]);
 export function buildIdeationBrief(input) {
-    const { thread, slotRole, memoryProvider, maxChars = DEFAULT_MAX_CHARS, topKPerCategory = DEFAULT_TOP_K_PER_CATEGORY, seedText, scopeHints = [], } = input;
+    const { thread, slotRole, slotPerspective, memoryProvider, maxChars = DEFAULT_MAX_CHARS, topKPerCategory = DEFAULT_TOP_K_PER_CATEGORY, seedText, scopeHints = [], } = input;
     const proposal = findProposalArtifact(thread);
     const proposalText = seedText?.trim() || proposal?.body?.trim() || '(no proposal seed found)';
     // Resolve which memory categories the current phase wants. If the
@@ -64,13 +64,15 @@ export function buildIdeationBrief(input) {
         }
     }
     // Loop-internal categories: pulled from thread.artifacts directly.
-    // critique_history → all critique artifacts in iterations < current.
-    // revision_history → all revision artifacts in iterations < current.
+    // Critique history includes contributions already made in the current
+    // round. Sequential ideation depends on this: participant B challenges A,
+    // then C sees both, instead of producing isolated first impressions.
+    // Revision history similarly includes the latest available revision.
     // synthesis_artifact → the most recent synthesis output (if any).
     const priorArtifactsBlock = includesLoopInternal
         ? renderPriorArtifactsBlock(thread, requestedCategories)
         : '';
-    const header = renderHeader(thread, slotRole, currentPhaseDef?.name ?? thread.current_phase);
+    const header = renderHeader(thread, slotRole, currentPhaseDef?.name ?? thread.current_phase, slotPerspective);
     const proposalBlock = renderProposalBlock(proposalText);
     const memoryBlock = renderMemoryBlock(fetchedItemsByCategory);
     const closing = renderClosingInstructions(slotRole, thread.current_phase);
@@ -114,7 +116,7 @@ function expandUserFacingCategories(requested) {
     // Drop loop-internal categories — they're handled separately.
     return requested.filter((c) => !LOOP_INTERNAL_CATEGORIES.has(c) && c !== '*');
 }
-function renderHeader(thread, slotRole, phase) {
+function renderHeader(thread, slotRole, phase, perspective) {
     const lines = [
         `# ${thread.kind}_loop brief`,
         `loop: ${thread.id}`,
@@ -125,6 +127,8 @@ function renderHeader(thread, slotRole, phase) {
     ];
     if (thread.goal)
         lines.push(`goal: ${thread.goal}`);
+    if (perspective)
+        lines.push(`perspective: ${perspective}`);
     return lines.join('\n');
 }
 function normalizeScope(value) {
@@ -168,9 +172,9 @@ function renderPriorArtifactsBlock(thread, requested) {
     const wantsSynthesis = requested.includes('*') || requested.includes('synthesis_artifact');
     const sections = [];
     if (wantsCritique) {
-        const priorCritique = thread.artifacts.filter((a) => a.type === 'critique' && (a.iteration ?? 0) < thread.iteration_count);
+        const priorCritique = thread.artifacts.filter((a) => a.type === 'critique' && (a.iteration ?? 0) <= thread.iteration_count);
         if (priorCritique.length > 0) {
-            const lines = ['### critique_history (prior iterations)'];
+            const lines = ['### critique_history (conversation so far)'];
             for (const a of priorCritique) {
                 lines.push(`- [${a.artifact_id}] (iter ${a.iteration ?? 0}) ${truncateLine(a.body)}`);
             }
@@ -178,7 +182,7 @@ function renderPriorArtifactsBlock(thread, requested) {
         }
     }
     if (wantsRevision) {
-        const priorRevision = thread.artifacts.filter((a) => a.phase === 'revision' && (a.iteration ?? 0) < thread.iteration_count);
+        const priorRevision = thread.artifacts.filter((a) => a.phase === 'revision' && (a.iteration ?? 0) <= thread.iteration_count);
         if (priorRevision.length > 0) {
             const lines = ['### revision_history (prior iterations)'];
             for (const a of priorRevision) {
@@ -200,12 +204,16 @@ function renderPriorArtifactsBlock(thread, requested) {
     return ['## prior loop artifacts', ...sections].join('\n\n');
 }
 function renderClosingInstructions(slotRole, phase) {
-    return [
+    const lines = [
         `## what to produce`,
         `- Phase "${phase}" expects you to act in role "${slotRole}".`,
         `- Emit findings as LoopArtifacts via bclaw_loop intent='complete_turn' or 'add_artifact'.`,
-        `- Cite the memory ids you relied on so the synthesis can audit coverage.`,
-    ].join('\n');
+    ];
+    if (phase === 'critique') {
+        lines.push(`- Treat memory items as investigation leads, never as proof that the current worktree still behaves that way.`, `- Verify every finding about the current implementation against the worktree. Cite at least one concrete file path plus a line, symbol, assertion, or test/command result.`, `- If you cannot verify a memory-backed concern in the worktree, label it as an unverified question instead of reporting it as a finding.`);
+    }
+    lines.push(`- Cite the memory ids you relied on so the synthesis can audit coverage.`);
+    return lines.join('\n');
 }
 function truncateLine(s, maxLen = 200) {
     if (!s)

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/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.