brainclaw 1.28.2 → 1.28.4

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

@@ -15,12 +15,13 @@
  */
 import path from 'node:path';
 import { loadState, mutateState } from './state.js';
+import { detectDuplicates } from './duplicates.js';
 import { archiveCandidate, listCandidates, loadCandidate, saveCandidate, } from './candidates.js';
 import { addCrossProjectLink, removeCrossProjectLink, resolveCrossProjectLinks, } from './cross-project.js';
 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';
@@ -39,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
@@ -271,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,
@@ -300,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 = {
@@ -308,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;
@@ -315,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;
 }
 /**
@@ -387,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;
@@ -407,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()];
 }
@@ -511,6 +544,19 @@ export function getEntity(name, idOrShortLabel, cwd) {
 // ─── CREATE ────────────────────────────────────────────────────────────
 export function createEntity(name, data, cwd) {
     assertKnownEntity(name, 'create');
+    const proximityKinds = new Set(['decision', 'constraint', 'trap']);
+    const nearby = proximityKinds.has(name) && typeof data.text === 'string'
+        ? detectDuplicates(data.text, name, loadState(cwd), listCandidates(undefined, cwd).filter((candidate) => candidate.status === 'pending')).slice(0, 3).map((match) => ({
+            id: match.id,
+            source: match.source,
+            reason: match.reason,
+            preview: match.text.length > 160 ? `${match.text.slice(0, 157)}…` : match.text,
+        }))
+        : [];
+    const result = (base) => ({
+        ...base,
+        ...(nearby.length ? { nearby_items: nearby } : {}),
+    });
     switch (name) {
         case 'plan': {
             // Explicit field whitelist + required-author check brings plan create in line
@@ -530,7 +576,7 @@ export function createEntity(name, data, cwd) {
                 estimatedEffort: data.estimated_effort,
             }, cwd);
             stampProvenanceOnStateItem('plan', res.id, defaultProvenance(data), cwd);
-            return { entity: name, id: res.id, short_label: res.shortLabel };
+            return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'decision': {
             const res = createDecision({
@@ -542,7 +588,8 @@ export function createEntity(name, data, cwd) {
                 planId: data.plan_id,
             }, cwd);
             stampProvenanceOnStateItem('decision', res.id, defaultProvenance(data), cwd);
-            return { entity: name, id: res.id, short_label: res.shortLabel };
+            stampMemoryVerification('decision', res.id, data, cwd);
+            return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'constraint': {
             const res = createConstraint({
@@ -553,7 +600,8 @@ export function createEntity(name, data, cwd) {
                 relatedPaths: data.related_paths,
             }, cwd);
             stampProvenanceOnStateItem('constraint', res.id, defaultProvenance(data), cwd);
-            return { entity: name, id: res.id, short_label: res.shortLabel };
+            stampMemoryVerification('constraint', res.id, data, cwd);
+            return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'trap': {
             const res = createTrap({
@@ -564,7 +612,8 @@ export function createEntity(name, data, cwd) {
                 relatedPaths: data.related_paths,
             }, cwd);
             stampProvenanceOnStateItem('trap', res.id, defaultProvenance(data), cwd);
-            return { entity: name, id: res.id, short_label: res.shortLabel };
+            stampMemoryVerification('trap', res.id, data, cwd);
+            return result({ entity: name, id: res.id, short_label: res.shortLabel });
         }
         case 'runtime_note': {
             const id = generateId('runtime_note');
@@ -1090,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

@@ -213,6 +213,12 @@ export function withCodexWorkspaceRoot(invoke, agent, worktreePath, isWin32 = pr
     }
     return { ...invoke, args, bashCommand };
 }
+/** Refuse a stdin-delivery invoke that would otherwise inherit `/dev/null`. */
+export function assertPromptDelivery(invoke) {
+    if (invoke.promptDelivery === 'stdin_pipe' && !invoke.promptText?.trim()) {
+        throw new Error('Invalid stdin_pipe invocation: promptText is empty; refusing to spawn an agent with ignored stdin.');
+    }
+}
 export class CliExecutionAdapter {
     id = 'cli';
     canSpawn(agentName) {
@@ -281,6 +287,7 @@ export class CliExecutionAdapter {
         };
     }
     start(invoke, options) {
+        assertPromptDelivery(invoke);
         const isWin32 = process.platform === 'win32';
         invoke = withCodexWorkspaceRoot(invoke, options.agent, options.worktreePath, isWin32);
         // F7 (trp_0e5150d3): route worker env through buildWorkerIdentityEnv so the
@@ -317,7 +324,7 @@ export class CliExecutionAdapter {
         }
         const spawnExecutable = resolvedExecutable ?? invoke.executable;
         const useShell = isWin32 && /\.(cmd|bat)$/i.test(spawnExecutable);
-        const needsStdin = invoke.promptDelivery === 'stdin_pipe' && invoke.promptText;
+        const needsStdin = invoke.promptDelivery === 'stdin_pipe';
         // pln#520 step 4: when we ack-wrap, the SHELL redirects stdout/stderr to the
         // per-assignment log files (fds passed via stdio are NOT inherited through
         // the cmd.exe → .cmd → node shim — the empty-logs bug of can_f792cacd), and
@@ -358,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,
@@ -388,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())

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)