brainclaw 1.28.3 → 1.28.4

package/dist/commands/mcp-write-memory.js

@@ -20,7 +20,8 @@ import { deleteMemoryItem, updateMemoryItem } from '../core/operations/memory-mu
 import { assessMemoryPressure, buildCompactionTemplate, applyCompaction } from '../core/gc-semantic.js';
 import { createRuntimeNote } from './runtime-note.js';
 import { createCandidateFromInput } from './reflect.js';
-import { harvestCandidates } from './harvest.js';
+import { harvestCandidates, harvestLaneResults, integrateLaneResults } from './harvest.js';
+import { dispatchReviewLoopTurn } from '../core/review-loop-turn-dispatch.js';
 import { ensureTrust, scanMcpWriteText, appendSecurityWarnings } from './mcp-write-support.js';
 import { toolResponse, createToolErrorResponse, } from './mcp-contract.js';
 function scoreKeywordMatches(text, patterns) {
@@ -448,4 +449,89 @@ export function handleBclawHarvestCandidates(payload, _ctx) {
         }),
     };
 }
+/** MCP parity for the CLI lane-result harvest path (distinct from candidates). */
+export async function handleBclawHarvestLane(payload) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const assignmentId = typeof args.assignmentId === 'string' ? args.assignmentId : undefined;
+    const all = args.all === true;
+    if (!assignmentId && !all) {
+        return { response: createToolErrorResponse('validation_error', 'Provide assignmentId, or set all=true to scan every managed lane.') };
+    }
+    if (assignmentId && all) {
+        return { response: createToolErrorResponse('validation_error', 'assignmentId and all=true are mutually exclusive.') };
+    }
+    const worktreePaths = Array.isArray(args.worktreePaths) ? args.worktreePaths.filter((value) => typeof value === 'string') : undefined;
+    const dryRun = args.dryRun === true;
+    const actor = resolved.identity.agent_name;
+    if (args.integrate === true) {
+        const integrated = integrateLaneResults({ assignmentId, worktreePaths, dryRun, cwd, agent: actor });
+        const dispatchedTurns = [];
+        if (!dryRun) {
+            for (const next of integrated.next_turns) {
+                const dispatched = await dispatchReviewLoopTurn({
+                    loopId: next.loop_id,
+                    slot: { slot_id: next.slot_id, role: next.role, agent: next.agent, agent_id: next.agent_id },
+                    phase: next.phase,
+                    task: next.task,
+                    dispatcherAgent: actor,
+                    dispatcherAgentId: resolved.identity.agent_id,
+                    cwd,
+                });
+                dispatchedTurns.push({
+                    loop_id: next.loop_id,
+                    agent: next.agent,
+                    iteration: next.iteration,
+                    execution_status: dispatched.execution_status,
+                    error: dispatched.error,
+                });
+            }
+        }
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Lane integrate${dryRun ? ' (dry-run)' : ''}: ${integrated.integrated.length} integrated, ${dispatchedTurns.length} re-dispatched, ${integrated.errors.length} error(s).` }],
+                ...integrated,
+                dispatched_turns: dispatchedTurns,
+                dry_run: dryRun,
+            }),
+        };
+    }
+    const harvested = harvestLaneResults({ assignmentId, worktreePaths, dryRun, cwd, agent: actor });
+    const continuationActions = harvested.continuations.flatMap((continuation) => {
+        const next = continuation.next_expected;
+        if (!next)
+            return [];
+        if (next.action === 'turn' && next.slot_id) {
+            return [{
+                    tool: 'bclaw_loop',
+                    args: { intent: 'turn', loop_id: continuation.loop_id, slot_id: next.slot_id, dispatch: true },
+                    when: next.reason ?? 'dispatch the next sequential loop participant',
+                }];
+        }
+        if (next.action === 'advance') {
+            return [{ tool: 'bclaw_loop', args: { intent: 'advance', loop_id: continuation.loop_id }, when: 'the current phase gate is satisfied' }];
+        }
+        return [{ tool: 'bclaw_loop', args: { intent: 'get', loop_id: continuation.loop_id }, when: next.reason ?? `inspect the expected ${next.action} action` }];
+    });
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: `✔ Lane harvest${dryRun ? ' (dry-run)' : ''}: ${harvested.harvested.length} harvested, ${harvested.skipped.length} skipped, ${harvested.errors.length} error(s), ${harvested.warnings.length} warning(s).` }],
+            structuredContent: {
+                harvested: harvested.harvested,
+                skipped: harvested.skipped,
+                errors: harvested.errors,
+                warnings: harvested.warnings,
+                continuations: harvested.continuations,
+                dry_run: dryRun,
+                next_actions: [
+                    ...continuationActions,
+                    ...harvested.warnings.flatMap((warning) => warning.next_actions ?? []),
+                ],
+            },
+        }),
+    };
+}
 //# sourceMappingURL=mcp-write-memory.js.map

package/dist/commands/mcp.js

@@ -48,7 +48,7 @@ import { handleBclawClaim, handleBclawReleaseClaim, handleBclawSessionStart, han
 // Sequence write handlers extracted in pln#622 PR4.
 import { handleBclawCreateSequence, handleBclawUpdateSequence, handleBclawDeleteSequence, } from './mcp-write-sequences.js';
 // Memory write handlers extracted in pln#622 PR4.
-import { handleBclawWriteNote, handleBclawQuickCapture, handleBclawCompact, handleBclawDeleteMemory, handleBclawUpdateMemory, handleBclawHarvestCandidates, } from './mcp-write-memory.js';
+import { handleBclawWriteNote, handleBclawQuickCapture, handleBclawCompact, handleBclawDeleteMemory, handleBclawUpdateMemory, handleBclawHarvestCandidates, handleBclawHarvestLane, } from './mcp-write-memory.js';
 // Admin / provisioning write handlers extracted in pln#622 PR4.
 import { handleBclawSetup, handleBclawInitProject, handleBclawAddCapability, handleBclawAddTool, } from './mcp-write-admin.js';
 // Entity write handlers extracted in pln#622 PR4.
@@ -1736,6 +1736,9 @@ async function _executeMcpToolCallInner(payload) {
         if (name === 'bclaw_harvest_candidates') {
             return handleBclawHarvestCandidates(payload, writeMemoryCtx);
         }
+        if (name === 'bclaw_harvest') {
+            return await handleBclawHarvestLane(payload);
+        }
         // ── Canonical CRUD verbs (Phase 3 slice 3b) ──────────────────────
         //
         // Thin wrappers around src/core/entity-operations.ts. Behind
@@ -1835,6 +1838,17 @@ async function _executeMcpToolCallInner(payload) {
                     };
                 }
                 const result = listEntities(entity, targetCwd, filter);
+                const requestedFields = Array.isArray(args.fields)
+                    ? args.fields.filter((field) => typeof field === 'string' && field.length > 0)
+                    : [];
+                if (requestedFields.length > 0) {
+                    result.items = result.items.map((item) => {
+                        if (!item || typeof item !== 'object')
+                            return item;
+                        const row = item;
+                        return Object.fromEntries(requestedFields.filter((field) => row[field] !== undefined).map((field) => [field, row[field]]));
+                    });
+                }
                 // pln#491 — bound the payload (count is already capped by applyPaging;
                 // this caps SIZE) so a verbose result set never overflows the MCP token
                 // cap and silently pushes the agent to the CLI (trp#449). Advertises
@@ -1850,7 +1864,7 @@ async function _executeMcpToolCallInner(payload) {
                     { tool: 'bclaw_get', args: { entity, id: '<id from items>', ...(args.project ? { project: args.project } : {}), ...(args.budget_tokens ? { budget_tokens: args.budget_tokens } : {}) }, when: 'to read one item in full' },
                 ];
                 if (bounded.has_more) {
-                    nextActions.push({ tool: 'bclaw_find', args: { entity, filter: { ...filter, offset: bounded.next_offset }, ...(args.project ? { project: args.project } : {}), ...(args.budget_tokens ? { budget_tokens: args.budget_tokens } : {}) }, when: 'to fetch the next page' });
+                    nextActions.push({ tool: 'bclaw_find', args: { entity, filter: { ...filter, offset: bounded.next_offset }, ...(requestedFields.length ? { fields: requestedFields } : {}), ...(args.project ? { project: args.project } : {}), ...(args.budget_tokens ? { budget_tokens: args.budget_tokens } : {}) }, when: 'to fetch the next page' });
                 }
                 // structuredContent is the canonical MCP return channel that clients
                 // (VS Code extension, Codex, etc.) read for machine-parseable data.

package/dist/core/context.js

@@ -29,6 +29,19 @@ import { isTrapActive, listOperationalTraps } from './traps.js';
 import { buildEstimationReport } from '../commands/estimation-report.js';
 import { detectStaleness } from './staleness.js';
 export const CONTEXT_SCHEMA_VERSION = '1.2';
+function verificationStatus(item) {
+    const verification = item.verification;
+    if (!verification)
+        return undefined;
+    if (verification.outcome === 'fail')
+        return 'verification:fail';
+    if (verification.max_age_days !== undefined) {
+        const ageMs = Date.now() - new Date(verification.verified_at).getTime();
+        if (Number.isFinite(ageMs) && ageMs > verification.max_age_days * 86_400_000)
+            return 'verification:stale';
+    }
+    return 'verification:pass';
+}
 export function buildContext(options = {}) {
     const requestedCwd = options.cwd ?? process.cwd();
     const contextCwd = resolveContextStoreCwd(requestedCwd, options.target);
@@ -95,7 +108,7 @@ export function buildContext(options = {}) {
             related_paths: c.related_paths,
             score: 0,
             reasons: [],
-            extra: c.status,
+            extra: [c.status, verificationStatus(c)].filter(Boolean).join(', '),
             plan_id: c.plan_id,
             provenance: {
                 actor: c.author,
@@ -125,7 +138,7 @@ export function buildContext(options = {}) {
             related_paths: d.related_paths,
             score: 0,
             reasons: [],
-            extra: d.related_paths?.join(', '),
+            extra: [d.related_paths?.join(', '), verificationStatus(d)].filter(Boolean).join(', ') || undefined,
             plan_id: d.plan_id,
             provenance: {
                 actor: d.author,
@@ -155,7 +168,7 @@ export function buildContext(options = {}) {
             related_paths: t.related_paths,
             score: 0,
             reasons: [],
-            extra: `${t.severity}, visibility:${t.visibility ?? 'shared'}`,
+            extra: [`${t.severity}, visibility:${t.visibility ?? 'shared'}, status:${t.status}`, verificationStatus(t)].filter(Boolean).join(', '),
             plan_id: t.plan_id,
             provenance: {
                 actor: t.author,

package/dist/core/dispatch-status.js

@@ -28,9 +28,9 @@ import { loadClaim } from './claims.js';
 import { getLoop, listLoops } from './loops/store.js';
 import { isProcessAlive } from './agentrun-reconciler.js';
 import { findRuntimeNoteById } from './runtime.js';
-import { latestActivityMs, decodeOemAwareBuffer, getRuntimeLogPath, getRuntimeSignalPath } from './runtime-signals.js';
+import { latestActivityMs, decodeOemAwareBuffer, getRuntimeLogPath, getRuntimeSignalPath, readCompletionSignals } from './runtime-signals.js';
 import { currentAttemptRunIdForAssignment } from './loops/attempt-reservation.js';
-import { LaneResultSchema } from './schema.js';
+import { resolveLaneResultFile } from './lane-result-file.js';
 const DEFAULT_TAIL = 20;
 const DEFAULT_STALL_MS = 5 * 60_000;
 const DEFAULT_BASE_REF = 'master';
@@ -291,6 +291,23 @@ function computeDiagnosis(assignment, agentRun, runtime, options) {
                 : `Worker reported "${lr.status}". Read the LANE-RESULT summary + stderr; address the blocker or reroute.`,
         };
     }
+    if (runtime.terminal_signal) {
+        const signal = runtime.terminal_signal;
+        if (signal.status === 'contradictory') {
+            return {
+                health: 'unknown',
+                summary: 'both completed and failed terminal sentinels exist; outcome is contradictory and no terminal projection was inferred',
+                recommended_next_action: 'Inspect LANE-RESULT.json and both log files; preserve the worktree and reconcile the contradiction before retrying.',
+            };
+        }
+        return {
+            health: 'terminal',
+            summary: `worker wrapper emitted the canonical ${signal.status} terminal signal${agentRun && !TERMINAL_RUN_STATUSES.has(agentRun.status) ? ` (agent_run still ${agentRun.status})` : ''}`,
+            recommended_next_action: signal.status === 'completed'
+                ? 'Run bclaw_harvest (or `brainclaw harvest <assignment_id>`) to ingest LANE-RESULT and converge the Assignment/Claim.'
+                : 'Read stderr and LANE-RESULT if present, then replay or reroute the failed slot.',
+        };
+    }
     // pln#554 — git evidence is the #2 signal, ABOVE process sentinels and
     // administrative status: commits ahead of base with a clean tracked tree
     // means the worker delivered everything to the branch, even if its pid is
@@ -359,18 +376,11 @@ function computeDiagnosis(assignment, agentRun, runtime, options) {
                 ?? 'Read .stderr.log for the exit reason; then trigger reconciliation by calling bclaw_find(entity="agent_run") again, or cancel + reroute.',
         };
     }
-    if (runtime.pid_alive === true && stallAge > options.stallMs && fsActive) {
-        return {
-            health: 'healthy',
-            summary: `agent_run alive (pid=${runtime.pid}); last_event_at stale (${Math.round(stallAge / 1000)}s) but filesystem active ${Math.round((fsAge ?? 0) / 1000)}s ago — working through a long op without a heartbeat`,
-            recommended_next_action: 'No action — the worker is actively writing to logs/worktree. Re-check periodically until terminal.',
-        };
-    }
     if (runtime.pid_alive === true && stallAge > options.stallMs) {
         return {
             health: 'stalled',
-            summary: `agent_run alive (pid=${runtime.pid}) but no activity for ${Math.round(stallAge / 1000)}s AND no filesystem writes${fsAge !== undefined ? ` (last fs ${Math.round(fsAge / 1000)}s ago)` : ' (no logs/worktree mtime)'}; last_event_at=${agentRun.last_event_at ?? '(never)'}`,
-            recommended_next_action: 'Worker appears genuinely hung (no log/file writes). Tail stderr to confirm, then kill the pid and reroute.',
+            summary: `agent_run pid=${runtime.pid} is alive but no explicit progress/heartbeat arrived for ${Math.round(stallAge / 1000)}s${fsActive ? `; filesystem activity ${Math.round((fsAge ?? 0) / 1000)}s ago is context, not proof of worker progress` : ''}`,
+            recommended_next_action: 'Inspect stdout/stderr and the expected artifact path. If no phase artifact or progress heartbeat is advancing, replay/reroute the slot; do not treat PID or unrelated filesystem activity as health.',
         };
     }
     if (runtime.pid_alive === true) {
@@ -436,6 +446,9 @@ export function getDispatchStatus(options) {
     const stderrPath = assignmentId
         ? getRuntimeLogPath(projectRoot, assignmentId, 'stderr', runtimeRunId)
         : undefined;
+    const completionSignals = assignmentId
+        ? readCompletionSignals(projectRoot, assignmentId, runtimeRunId)
+        : {};
     // pln#527 — filesystem-activity age: max mtime across the captured logs + the
     // run's worktree files (skipping junctions). The truer liveness signal when
     // the heartbeat / last_event_at is stale during a long single operation.
@@ -460,8 +473,9 @@ export function getDispatchStatus(options) {
     let laneResult;
     let laneResultStale;
     if (worktreeForFs) {
-        try {
-            const parsed = LaneResultSchema.parse(JSON.parse(fs.readFileSync(path.join(worktreeForFs, 'LANE-RESULT.json'), 'utf-8')));
+        const resolvedLaneResult = resolveLaneResultFile(worktreeForFs, assignmentId);
+        if (resolvedLaneResult.kind === 'found') {
+            const parsed = resolvedLaneResult.lane;
             if (parsed.assignment_id === assignmentId) {
                 laneResult = { status: parsed.status, summary: parsed.summary };
             }
@@ -469,7 +483,6 @@ export function getDispatchStatus(options) {
                 laneResultStale = { assignment_id: parsed.assignment_id, status: parsed.status, summary: parsed.summary };
             }
         }
-        catch { /* no / invalid LANE-RESULT.json */ }
     }
     // pln#554 — worktree git evidence (commits ahead of base + dirty tracked files).
     const evidence = gitEvidence(worktreeForFs, options.base_ref ?? DEFAULT_BASE_REF);
@@ -480,6 +493,15 @@ export function getDispatchStatus(options) {
             exists: ackPath ? fs.existsSync(ackPath) : false,
             path: ackPath,
         },
+        ...(assignmentId && (completionSignals.completed || completionSignals.failed) ? {
+            terminal_signal: {
+                status: completionSignals.completed && completionSignals.failed
+                    ? 'contradictory'
+                    : completionSignals.completed ? 'completed' : 'failed',
+                completed_path: getRuntimeSignalPath(projectRoot, assignmentId, 'completed', runtimeRunId),
+                failed_path: getRuntimeSignalPath(projectRoot, assignmentId, 'failed', runtimeRunId),
+            },
+        } : {}),
         log_files: {
             stdout: stdoutPath ? readLogTail(stdoutPath, tailLines) : undefined,
             stderr: stderrPath ? readLogTail(stderrPath, tailLines) : undefined,

package/dist/core/dispatcher.js

@@ -37,7 +37,7 @@ import { buildClaimEnvPrefix } from './execution-profile.js';
 import { getActiveSequence, listSequences } from './sequence.js';
 import { loadState, persistState } from './state.js';
 import { listClaims, createCoordinatorClaim, attachAssignmentMessageToClaim, linkClaimToAssignment, assessClaimLiveness } from './claims.js';
-import { sanitizeBranchComponent, isBranchMergedByContent, probeLocalBranch, isGitRepo } from './worktree.js';
+import { sanitizeBranchComponent, isBranchMergedByContent, probeLocalBranch, isGitRepo, detectWorkspaceNodeModules } from './worktree.js';
 import { listAgentIdentities, ensureAgentRegisteredForDispatch } from './agent-registry.js';
 import { sendMessage, hasActiveAssignment } from './messaging.js';
 import { memoryDir } from './io.js';
@@ -328,7 +328,7 @@ export function buildWorkingDefaultsSection(opts) {
         '',
     ].join('\n');
 }
-export function laneResultShape(assignmentId, contractRef, fence) {
+export function laneResultShape(assignmentId, contractRef, fence, artifactType) {
     const asgn = assignmentId ?? '<assignment_id>';
     const generation = fence
         ? `,"turn_id":"${fence.turn_id}","run_id":"${fence.run_id}","nonce":"${fence.nonce}","attempt_epoch":${fence.attempt_epoch},"workspace_digest":"${fence.workspace_digest}"`
@@ -336,10 +336,11 @@ export function laneResultShape(assignmentId, contractRef, fence) {
     const contract = contractRef
         ? `,"execution_contract_hash":"${contractRef.hash}","capability_snapshot_hash":"${contractRef.snapshot_hash}"`
         : '';
-    return `{"assignment_id":"${asgn}"${generation}${contract},"status":"completed|blocked|failed","summary":"<one line>","body":"<your full output — the reasoning, not just a label>","files_changed":["..."],"artifacts":["..."]}`;
+    const artifact = artifactType ? `,"artifact_type":"${artifactType}"` : '';
+    return `{"assignment_id":"${asgn}"${generation}${contract},"status":"completed|blocked|failed","summary":"<one line>"${artifact},"body":"<your full output — the reasoning, not just a label>","files_changed":["..."],"artifacts":["<ref>",{"type":"file|commit|artifact","ref":"<path-or-id>","description":"<optional>"}]}`;
 }
 export function buildTransportSection(opts) {
-    const laneResult = `write LANE-RESULT.json at the worktree ROOT: ${laneResultShape(opts.assignmentId, opts.executionContractRef, opts.attemptFence)}`;
+    const laneResult = `write the terminal envelope at the worktree ROOT with the exact filename LANE-RESULT.json: ${laneResultShape(opts.assignmentId, opts.executionContractRef, opts.attemptFence, opts.artifactType)}. The filename is protocol-significant: do not translate it, replace the hyphen, add a suffix, or place it in a subdirectory. The artifacts array accepts either string refs or {type,ref,description} objects; for a loop turn, artifact_type is required exactly as shown`;
     const acceptance = opts.executionContractRef
         ? [
             `Execution contract: ${opts.executionContractRef.hash}`,
@@ -408,8 +409,8 @@ export function buildProtocolSection(options) {
     if (options?.worktreePath) {
         parts.push(`Worktree: ${options.worktreePath}`);
         // pln#523 / trp_37b05a15: tell the worker how dependencies are provisioned so
-        // it does not stall trying to (re)install them. The authoritative record is
-        // the worktree's `.brainclaw-worktree.json` → `deps_mode` (absent ⇒ `link`).
+        // it does not stall trying to (re)install them. The sidecar records intent,
+        // but the brief only claims availability after checking the worktree itself.
         //   - link (default): node_modules (incl. monorepo per-package) is
         //     junction-linked from the main repo — build/typecheck directly; do NOT
         //     `npm install`. An out-of-root symlink, so `next dev`/Turbopack rejects
@@ -417,28 +418,34 @@ export function buildProtocolSection(options) {
         //   - install/copy: node_modules is a REAL in-root directory — everything,
         //     including a dev server, works directly; no reinstall needed.
         //   - none: no deps provisioned — run the project's install first.
-        let depsMode = 'link';
+        let depsMode;
         let depsProvisioned;
+        let recordedPaths = [];
         try {
             const sidecar = JSON.parse(fs.readFileSync(path.join(options.worktreePath, '.brainclaw-worktree.json'), 'utf-8'));
-            if (sidecar.deps_mode)
-                depsMode = sidecar.deps_mode;
+            depsMode = sidecar.deps_mode;
             depsProvisioned = sidecar.deps_provisioned;
+            recordedPaths = Array.isArray(sidecar.deps_paths) ? sidecar.deps_paths : [];
         }
-        catch { /* sidecar absent/unreadable — assume the default `link` */ }
-        if ((depsMode === 'install' || depsMode === 'copy') && depsProvisioned === false) {
-            // Codex review P1: provisioning was ATTEMPTED but FAILED (best-effort, non-fatal).
-            // Do not claim node_modules is usable — tell the worker to install it.
-            parts.push(`Dependencies: in-root provisioning was attempted (deps_mode=${depsMode}) but FAILED — node_modules may be missing or incomplete. Run the project's install (npm/pnpm/yarn/bun) in the worktree before building; see .brainclaw-worktree.json symlink_warnings for the failure.`);
+        catch { /* sidecar absent/unreadable — do not infer provisioning */ }
+        const detectedPaths = detectWorkspaceNodeModules(options.worktreePath)
+            .filter((relativePath) => fs.existsSync(path.join(options.worktreePath, relativePath)));
+        const verifiedPaths = [...new Set([...recordedPaths, ...detectedPaths])]
+            .filter((relativePath) => fs.existsSync(path.join(options.worktreePath, relativePath)));
+        if (verifiedPaths.length > 0 && (depsMode === 'install' || depsMode === 'copy')) {
+            parts.push(`Dependencies: verified in-root node_modules at ${verifiedPaths.join(', ')} (deps_mode=${depsMode}). Use the repository's local scripts/binaries; do NOT reinstall.`);
         }
-        else if (depsMode === 'install' || depsMode === 'copy') {
-            parts.push(`Dependencies: node_modules is a real in-root directory (deps_mode=${depsMode}) — build, typecheck, and dev server all work directly; do NOT reinstall. If anything is missing, see .brainclaw-worktree.json symlink_warnings.`);
+        else if (verifiedPaths.length > 0 && depsMode === 'link') {
+            parts.push(`Dependencies: verified node_modules at ${verifiedPaths.join(', ')} (deps_mode=link). Use the repository's local scripts/binaries; do NOT reinstall. These may be out-of-root links, so next dev/Turbopack can require deps_mode=install.`);
         }
         else if (depsMode === 'none') {
-            parts.push('Dependencies: none were provisioned (deps_mode=none) — run the project\'s install (npm/pnpm/yarn/bun) in the worktree before building.');
+            parts.push('Dependencies: none were provisioned (deps_mode=none). Do not invoke npx or any network-backed install unless the task explicitly authorizes it; report local validation as blocked when required tools are unavailable.');
         }
         else {
-            parts.push('Dependencies: node_modules is linked from the main repo (incl. monorepo per-package). Build/typecheck directly; if deps are missing, do NOT npm install here — see .brainclaw-worktree.json symlink_warnings and validate centrally. (Out-of-root symlink: next dev/Turbopack needs deps_mode=install.)');
+            const attempted = depsProvisioned === false && depsMode
+                ? ` Provisioning was attempted with deps_mode=${depsMode} but did not produce a usable node_modules tree.`
+                : '';
+            parts.push(`Dependencies: no node_modules directory was verified in this worktree.${attempted} Do not invoke npx or any network-backed install unless the task explicitly authorizes it; report local validation as blocked when required tools are unavailable. See .brainclaw-worktree.json symlink_warnings when present.`);
         }
     }
     parts.push('');
@@ -711,8 +718,8 @@ export function buildContextEnvelopeSection(cwd) {
     }
     const newestFirst = (items) => [...items].sort((a, b) => (b.created_at ?? '').localeCompare(a.created_at ?? '') || (a.id ?? '').localeCompare(b.id ?? ''));
     const clip = (text) => text.length > CONTEXT_ENVELOPE_ITEM_MAX_CHARS ? `${text.slice(0, CONTEXT_ENVELOPE_ITEM_MAX_CHARS - 1)}…` : text;
-    const constraints = newestFirst(state.active_constraints ?? []);
-    const traps = newestFirst(state.known_traps ?? []).slice(0, CONTEXT_ENVELOPE_TOP_K);
+    const constraints = newestFirst((state.active_constraints ?? []).filter((item) => item.status === 'active'));
+    const traps = newestFirst((state.known_traps ?? []).filter((item) => item.status === 'active')).slice(0, CONTEXT_ENVELOPE_TOP_K);
     const decisions = newestFirst(state.recent_decisions ?? []).slice(0, CONTEXT_ENVELOPE_TOP_K);
     if (constraints.length === 0 && traps.length === 0 && decisions.length === 0)
         return '';
@@ -777,6 +784,7 @@ export function generateDispatchBrief(options) {
             worktreePath: options.worktreePath,
             assignmentId: options.assignmentId,
             attemptFence: options.attemptFence,
+            artifactType: options.artifactType,
         }));
     }
     // pln#628 Focus 4A — transport addendum keyed to the ACTUAL missing capability

package/dist/core/entity-operations.js

@@ -21,7 +21,7 @@ import { addCrossProjectLink, removeCrossProjectLink, resolveCrossProjectLinks,
 import { findActiveClaimsForPlan, listClaims, loadClaim, logCascadeReleaseResult, markClaimStale, releaseClaimsCascade, releaseClaimWithCascade, saveClaim, } from './claims.js';
 import { listActionRequired } from './actions.js';
 import { listAgentIdentities } from './agent-registry.js';
-import { getCapabilityProfile, getSpawnableAgents } from './agent-capability.js';
+import { getCapabilityProfile, getSpawnableAgents, validateAgentForDispatch } from './agent-capability.js';
 import { buildReputationSnapshot, toPublicReputationSummary } from './reputation.js';
 import { loadAllSessions } from './identity.js';
 import { loadInstructions } from './instructions.js';
@@ -40,7 +40,7 @@ import { createPlan, deletePlan, updatePlan, } from './operations/plan.js';
 import { ENTITY_NAMES, ENTITY_REGISTRY, isValidTransition, } from './entity-registry.js';
 import { generateId } from './ids.js';
 import { mergeHandoffReview } from './handoff-review.js';
-import { CandidateTypeSchema, ConstraintCategorySchema, DecisionOutcomeSchema, HandoffContractSchema, HandoffReviewSchema, MemoryVisibilitySchema, PlanTypeEnumSchema, PrioritySchema, RuntimeNoteTypeSchema, SequenceStatusSchema, SeveritySchema, } from './schema.js';
+import { CandidateTypeSchema, ConstraintCategorySchema, DecisionOutcomeSchema, HandoffContractSchema, HandoffReviewSchema, MemoryVisibilitySchema, PlanTypeEnumSchema, PrioritySchema, RuntimeNoteTypeSchema, SequenceStatusSchema, SeveritySchema, MemoryVerificationSchema, } from './schema.js';
 /**
  * Default provenance stamp applied on create when the caller does not
  * supply one. `user` kind with whatever author is in the payload; the
@@ -272,7 +272,14 @@ export function listEntities(name, cwd, filter = {}) {
         : fieldFiltered.filter((item) => isLegacyProvenance(item)).length;
     const excludedLowConfidenceAutoReflect = fieldFiltered.filter((item) => isLowConfidenceAutoReflect(item, filter)).length;
     const filtered = fieldFiltered.filter((item) => passesProvenanceFilter(item, filter));
-    const paged = applyPaging(filtered, filter);
+    const newestFirst = [...filtered].sort((a, b) => {
+        const left = a;
+        const right = b;
+        const leftDate = String(left.updated_at ?? left.created_at ?? '');
+        const rightDate = String(right.updated_at ?? right.created_at ?? '');
+        return rightDate.localeCompare(leftDate) || String(left.id ?? '').localeCompare(String(right.id ?? ''));
+    });
+    const paged = applyPaging(newestFirst, filter);
     return {
         entity: name,
         total: filtered.length,
@@ -301,6 +308,16 @@ export function boundListResult(result, offset, charBudget = DEFAULT_FIND_CHAR_B
         items = items.slice(0, items.length - drop);
         omittedForSize = result.items.length - items.length;
     }
+    let oversizedItemProjected = false;
+    if (items.length === 1 && JSON.stringify(items).length > charBudget) {
+        const item = items[0];
+        if (item && typeof item === 'object') {
+            const row = item;
+            const compactKeys = ['id', 'short_label', 'status', 'created_at', 'updated_at', 'agent', 'scope', 'plan_id'];
+            items = [Object.fromEntries(compactKeys.filter((key) => row[key] !== undefined).map((key) => [key, row[key]]))];
+            oversizedItemProjected = true;
+        }
+    }
     const returned = items.length;
     const hasMore = offset + returned < result.total;
     const bounded = {
@@ -309,6 +326,7 @@ export function boundListResult(result, offset, charBudget = DEFAULT_FIND_CHAR_B
         returned,
         has_more: hasMore,
         ...(omittedForSize > 0 ? { omitted_for_size: omittedForSize } : {}),
+        ...(oversizedItemProjected ? { oversized_item_projected: true } : {}),
     };
     if (hasMore) {
         bounded.next_offset = offset + returned;
@@ -316,6 +334,9 @@ export function boundListResult(result, offset, charBudget = DEFAULT_FIND_CHAR_B
             ? `Payload size-bounded: returned ${returned} of ${result.total} ${result.entity} item(s). Fetch more with filter.offset=${bounded.next_offset}, or narrow the filter (status/tag/author).`
             : `Returned ${returned} of ${result.total} ${result.entity} item(s). Page with filter.offset=${bounded.next_offset}, or narrow the filter.`;
     }
+    else if (oversizedItemProjected) {
+        bounded.hint = 'The matching item exceeded budget_tokens and was projected to identity/status fields. Use bclaw_get for the full item or request explicit bclaw_find fields.';
+    }
     return bounded;
 }
 /**
@@ -388,6 +409,11 @@ function loadAgentsForRead(cwd, filter) {
         : undefined;
     const project = (doc) => {
         const row = projectAgentForRead(doc);
+        const availability = validateAgentForDispatch(doc.agent_name, { requireSpawnable: true });
+        row.declared_spawnable = getCapabilityProfile(doc.agent_name)?.runtime.canBeSpawnedCli ?? false;
+        row.executable_now = availability.valid;
+        row.availability_code = availability.code;
+        row.availability_reason = availability.reason;
         if (reputationById)
             row.reputation = reputationById.get(String(row.id));
         return row;
@@ -408,7 +434,13 @@ function loadAgentsForRead(cwd, filter) {
             existing.dispatchable = true;
             continue;
         }
-        byName.set(name, projectCatalogAgentForRead(name));
+        const row = projectCatalogAgentForRead(name);
+        const availability = validateAgentForDispatch(name, { requireSpawnable: true });
+        row.declared_spawnable = true;
+        row.executable_now = availability.valid;
+        row.availability_code = availability.code;
+        row.availability_reason = availability.reason;
+        byName.set(name, row);
     }
     return [...byName.values()];
 }
@@ -556,6 +588,7 @@ export function createEntity(name, data, cwd) {
                 planId: data.plan_id,
             }, cwd);
             stampProvenanceOnStateItem('decision', res.id, defaultProvenance(data), cwd);
+            stampMemoryVerification('decision', res.id, data, cwd);
             return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'constraint': {
@@ -567,6 +600,7 @@ export function createEntity(name, data, cwd) {
                 relatedPaths: data.related_paths,
             }, cwd);
             stampProvenanceOnStateItem('constraint', res.id, defaultProvenance(data), cwd);
+            stampMemoryVerification('constraint', res.id, data, cwd);
             return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'trap': {
@@ -578,6 +612,7 @@ export function createEntity(name, data, cwd) {
                 relatedPaths: data.related_paths,
             }, cwd);
             stampProvenanceOnStateItem('trap', res.id, defaultProvenance(data), cwd);
+            stampMemoryVerification('trap', res.id, data, cwd);
             return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'runtime_note': {
@@ -1104,6 +1139,29 @@ function stampProvenanceOnStateItem(name, id, provenance, cwd) {
         item.provenance = provenance;
     }, cwd);
 }
+function stampMemoryVerification(name, id, data, cwd) {
+    const verification = data.verification === undefined
+        ? undefined
+        : MemoryVerificationSchema.parse(data.verification);
+    const verifiedAt = typeof data.verified_at === 'string' ? data.verified_at : verification?.verified_at;
+    const verifyCmd = typeof data.verify_cmd === 'string' ? data.verify_cmd : undefined;
+    if (!verification && !verifiedAt && !verifyCmd)
+        return;
+    mutateState((state) => {
+        const bucket = name === 'decision' ? state.recent_decisions
+            : name === 'constraint' ? state.active_constraints
+                : state.known_traps;
+        const item = bucket.find((entry) => entry.id === id);
+        if (!item)
+            return;
+        if (verification)
+            item.verification = verification;
+        if (verifiedAt)
+            item.verified_at = verifiedAt;
+        if (verifyCmd)
+            item.verify_cmd = verifyCmd;
+    }, cwd);
+}
 function requireString(data, field) {
     const value = data[field];
     if (typeof value !== 'string' || !value) {

package/dist/core/entity-registry.js

@@ -117,7 +117,7 @@ const decision = {
     shortLabelPrefix: 'dec',
     schema: DecisionSchema,
     updatable: [
-        'text', 'tags', 'outcome', 'scope', 'related_paths', 'verified_at', 'verify_cmd',
+        'text', 'tags', 'outcome', 'scope', 'related_paths', 'verified_at', 'verify_cmd', 'verification',
         // pln#544 lifecycle (touched via memory-lifecycle.ts recordMemoryEvent;
         // exposing them here keeps bclaw_update straight-through for tests and
         // operator backfills).
@@ -140,7 +140,7 @@ const constraint = {
     shortLabelPrefix: 'cst',
     schema: ConstraintSchema,
     updatable: [
-        'text', 'tags', 'category', 'scope', 'related_paths', 'expires_at',
+        'text', 'tags', 'category', 'scope', 'related_paths', 'expires_at', 'verified_at', 'verify_cmd', 'verification',
         // pln#544 lifecycle — see decision.updatable.
         'last_confirmed_at', 'last_infirmed_at',
         'confirmation_count', 'infirmation_count',
@@ -164,7 +164,7 @@ const trap = {
     schema: TrapSchema,
     updatable: [
         'text', 'tags', 'severity', 'scope', 'related_paths', 'expires_at', 'platform_scope',
-        'verified_at', 'verify_cmd',
+        'verified_at', 'verify_cmd', 'verification',
         // pln#544 lifecycle — see decision.updatable.
         'last_confirmed_at', 'last_infirmed_at',
         'confirmation_count', 'infirmation_count',

package/dist/core/execution-adapters.js

@@ -365,6 +365,13 @@ export class CliExecutionAdapter {
                 contractBootstrapPath,
                 expectedWorkspacePath: options.worktreePath,
             }, isWin32, options.turnEcho);
+            // Materialize advertised log paths before spawn. A shell/bootstrap error
+            // can otherwise happen before redirection creates either file.
+            for (const stream of ['stdout', 'stderr']) {
+                const logPath = getRuntimeLogPath(signalRoot, options.assignmentId, stream, runtimeRunId);
+                if (!fs.existsSync(logPath))
+                    fs.writeFileSync(logPath, '', { encoding: 'utf8', mode: 0o600 });
+            }
             child = spawn(wrappedCmd, [], {
                 detached: !isWin32,
                 shell: true,
@@ -395,6 +402,9 @@ export class CliExecutionAdapter {
             child.stdin.write(invoke.promptText);
             child.stdin.end();
         }
+        // Preserve fire-and-forget semantics while keeping an exit observer so
+        // libuv reaps the direct wrapper child on long-lived POSIX coordinators.
+        child.once('exit', () => { });
         child.unref();
         const pid = child.pid;
         if (!pid) {

package/dist/core/facade-schema.js

@@ -36,6 +36,16 @@ export const CoordinateRequestSchema = z.object({
     task: z.string(),
     scope: z.string().optional(),
     targetAgents: z.array(z.string()).optional(),
+    /**
+     * Ideation critic scheduling. The default is deliberately sequential: the
+     * loop still requires every critic artifact, but only the first open critic
+     * is dispatched initially and the driver takes the next real turn after
+     * harvest. Parallel fan-out remains available as an explicit throughput
+     * trade-off.
+     */
+    ideation_schedule: z.enum(['sequential', 'parallel']).optional().default('sequential'),
+    /** Optional per-slot lenses, positionally aligned with targetAgents. */
+    criticPerspectives: z.array(z.string().min(1).max(1000)).optional(),
     constraints: z.record(z.string(), z.unknown()).optional(),
     threadId: z.string().optional(),
     /** Optional pipeline provenance persisted when open_loop creates a loop. */

package/dist/core/ideation-loop-close.js

@@ -107,7 +107,9 @@ export function closeIdeationLoopFromLaneResult(assignment, lane, actor, cwd) {
                 // Prefer the typed envelope, but honor the legacy artifacts labels too:
                 // coverage_gap used to be silently invisible to a critique gate.
                 const reportedArtifactType = lane.artifact_type?.trim()
-                    ?? lane.artifacts?.find((label) => /^[a-z][a-z0-9_]*$/.test(label) && label !== expectedArtifactType);
+                    ?? lane.artifacts
+                        ?.map((item) => typeof item === 'string' ? item : item.type)
+                        .find((label) => /^[a-z][a-z0-9_]*$/.test(label) && label !== expectedArtifactType);
                 const body = lane.body?.trim();
                 const critique = body || [lane.summary, lane.notes]
                     .map((s) => (s ?? '').trim())