nexus-prime 7.9.5 → 7.9.7

package/dist/agents/adapters/mcp/async-gate.d.ts

@@ -41,6 +41,8 @@ export interface AsyncGateOpts {
     maxSyncMs?: number;
     /** Human-readable hint for estimated duration */
     etaMs?: number;
+    /** Return the async receipt before starting work. Use for cold paths that may block synchronously. */
+    alwaysQueue?: boolean;
 }
 type HandlerFn = () => Promise<{
     content: Array<{

package/dist/agents/adapters/mcp/async-gate.js

@@ -33,10 +33,7 @@ class AsyncGate {
             etaMs: opts.etaMs,
         };
         this.enqueueJob(job);
-        // Race: handler vs deadline
-        let syncResolved = false;
-        const deadline = new Promise((resolve) => setTimeout(() => resolve(null), maxSyncMs));
-        const work = (async () => {
+        const startWork = () => (async () => {
             job.status = 'running';
             job.stage = 'executing';
             job.startedAt = Date.now();
@@ -64,6 +61,18 @@ class AsyncGate {
                 };
             }
         })();
+        if (opts.alwaysQueue) {
+            setImmediate(() => {
+                startWork().catch(() => { });
+            });
+            return { queued: true, runId, etaMs: opts.etaMs };
+        }
+        // Race: handler vs deadline. Note: this only protects paths that yield
+        // quickly. Cold synchronous work should set alwaysQueue so the receipt is
+        // returned before the heavy section starts.
+        let syncResolved = false;
+        const deadline = new Promise((resolve) => setTimeout(() => resolve(null), maxSyncMs));
+        const work = startWork();
         // Suppress unhandled rejection: deadline may win while work is still in flight.
         work.catch(() => { });
         const winner = await Promise.race([

package/dist/agents/adapters/mcp/dispatch.js

@@ -124,7 +124,13 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
             const gated = await withAsyncGate(async () => {
                 const r = await runHandlers();
                 return r ?? { content: [{ type: 'text', text: `Tool ${toolName} returned no result` }] };
-            }, { tool: toolName, args, maxSyncMs: 2000, etaMs: TOOL_ETA_MS[toolName] });
+            }, {
+                tool: toolName,
+                args,
+                maxSyncMs: 2000,
+                etaMs: TOOL_ETA_MS[toolName],
+                alwaysQueue: toolName === 'nexus_orchestrate',
+            });
             if ('queued' in gated && gated.queued) {
                 // Persist orchestration run record for durable stage tracking
                 if (toolName === 'nexus_orchestrate') {

package/dist/agents/adapters/mcp/types.d.ts

@@ -35,6 +35,8 @@ export declare class SessionTelemetry {
     private fileIntentPaths;
     private tokenAutoApplied;
     private stickyTokenOptimization;
+    private tokenOptimizationPending;
+    private orchestrationPending;
     bootstrapped: boolean;
     bootstrapCallCount: number;
     recordCall(): void;
@@ -54,12 +56,16 @@ export declare class SessionTelemetry {
         fileReadIntentCount: number;
         callsSinceOrchestrate: number;
         tokenAutoApplied: boolean;
+        tokenOptimizationPending: boolean;
+        orchestrationPending: boolean;
     };
     elapsedMs(): number;
     advancePhase(nextPhase: LifecyclePhase): void;
     observeSuccessfulToolCall(toolName: string, args: Record<string, unknown>): void;
+    observeQueuedToolCall(toolName: string, args: Record<string, unknown>): void;
     needsOptimizeTokens(currentToolName?: string): boolean;
     markTokenAutoApplied(): void;
+    needsOrchestration(currentToolName?: string): boolean;
     needsStoreMemory(currentToolName?: string): boolean;
     needsSessionDna(currentToolName?: string): boolean;
     notifyStore(priority: number, tags: string[], memStats: {

package/dist/agents/adapters/mcp/types.js

@@ -24,6 +24,8 @@ export class SessionTelemetry {
     fileIntentPaths = new Set();
     tokenAutoApplied = false;
     stickyTokenOptimization = false;
+    tokenOptimizationPending = false;
+    orchestrationPending = false;
     bootstrapped = false;
     bootstrapCallCount = 0;
     recordCall() {
@@ -49,6 +51,8 @@ export class SessionTelemetry {
             fileReadIntentCount: this.fileReadIntentCount,
             callsSinceOrchestrate: this.callsSinceOrchestrate,
             tokenAutoApplied: this.tokenAutoApplied,
+            tokenOptimizationPending: this.tokenOptimizationPending,
+            orchestrationPending: this.orchestrationPending,
         };
     }
     elapsedMs() {
@@ -69,8 +73,10 @@ export class SessionTelemetry {
                 this.optimizeTokensCalled = false;
                 this.tokenAutoApplied = false;
             }
+            this.tokenOptimizationPending = false;
         }
         if (nextPhase === 'orchestrated') {
+            this.orchestrationPending = false;
             this.mindkitCheckCalled = false;
             this.storeMemoryCalledPostOrchestrate = false;
             this.sessionDnaCalled = false;
@@ -85,12 +91,17 @@ export class SessionTelemetry {
             return;
         }
         if (toolName === 'nexus_orchestrate') {
+            this.stickyTokenOptimization = true;
             this.advancePhase('orchestrated');
+            this.optimizeTokensCalled = true;
+            this.tokenAutoApplied = true;
+            this.tokenOptimizationPending = false;
             this.noteFileIntent(args.files);
             return;
         }
         if (toolName === 'nexus_optimize_tokens') {
             this.optimizeTokensCalled = true;
+            this.tokenOptimizationPending = false;
             if (this.lifecyclePhase === 'orchestrated')
                 this.advancePhase('working');
             this.noteFileIntent(args.files);
@@ -126,6 +137,20 @@ export class SessionTelemetry {
             this.advancePhase('working');
         }
     }
+    observeQueuedToolCall(toolName, args) {
+        if (toolName === 'nexus_orchestrate') {
+            this.orchestrationPending = true;
+            this.tokenOptimizationPending = true;
+            this.optimizeTokensCalled = true;
+            this.noteFileIntent(args.files);
+            return;
+        }
+        if (toolName === 'nexus_optimize_tokens') {
+            this.tokenOptimizationPending = true;
+            this.optimizeTokensCalled = true;
+            this.noteFileIntent(args.files);
+        }
+    }
     needsOptimizeTokens(currentToolName) {
         if (currentToolName === 'nexus_optimize_tokens')
             return false;
@@ -133,12 +158,26 @@ export class SessionTelemetry {
             return false;
         if (this.tokenAutoApplied)
             return false;
+        if (this.tokenOptimizationPending)
+            return false;
         return this.fileReadIntentCount >= 1 && !this.optimizeTokensCalled;
     }
     markTokenAutoApplied() {
         this.tokenAutoApplied = true;
         this.optimizeTokensCalled = true;
         this.stickyTokenOptimization = true;
+        this.tokenOptimizationPending = false;
+    }
+    needsOrchestration(currentToolName) {
+        if (currentToolName === 'nexus_orchestrate')
+            return false;
+        if (this.lifecyclePhase === 'pre-bootstrap')
+            return false;
+        if (this.lifecyclePhase === 'orchestrated' || this.lifecyclePhase === 'working' || this.lifecyclePhase === 'closing')
+            return false;
+        if (this.orchestrationPending)
+            return false;
+        return this.bootstrapped && this.lifecyclePhase === 'bootstrapped';
     }
     needsStoreMemory(currentToolName) {
         if (currentToolName === 'nexus_store_memory')
@@ -184,9 +223,8 @@ export class SessionTelemetry {
                 }
                 break;
             case 'store':
-                if ((context.priority ?? 0) > 0.8) {
-                    nudges.push('High-priority insight stored. Next: call nexus_store_memory to persist related findings.');
-                }
+                // Storing memory completes the lifecycle step; do not create a
+                // self-referential "store again" loop.
                 break;
             case 'mindkit_fail':
                 nudges.push('Guardrail FAILED. Do NOT proceed. Re-scope the task or call nexus_ghost_pass for a safer approach.');

package/dist/agents/adapters/mcp.d.ts

@@ -41,6 +41,7 @@ export declare class MCPAdapter implements Adapter {
     private formatRemainingProtocolSteps;
     private prependTextToResponse;
     private decorateLifecycleResponse;
+    private buildPreOrchestrationBlock;
     private extractGoalLikeText;
     private isMemoryTool;
     private injectMemoryContext;

package/dist/agents/adapters/mcp.js

@@ -124,6 +124,23 @@ const PRE_BOOTSTRAP_ALLOWED_TOOLS = new Set([
     'nexus_list_specialists',
     'nexus_list_crews',
 ]);
+const PRE_ORCHESTRATE_ALLOWED_TOOLS = new Set([
+    ...PRE_BOOTSTRAP_ALLOWED_TOOLS,
+    'nexus_orchestrate',
+    'nexus_plan_execution',
+    'nexus_recall_memory',
+    'nexus_temporal_query',
+    'nexus_store_memory',
+    'nexus_search',
+    'nexus_optimize_tokens',
+    'nexus_mindkit_check',
+    'nexus_ghost_pass',
+    'nexus_token_report',
+    'nexus_session_dna',
+    'nexus_run_status',
+    'nexus_selection_ledger',
+    'nexus_license_usage',
+]);
 export class MCPAdapter {
     name;
     type = 'mcp';
@@ -513,6 +530,24 @@ export class MCPAdapter {
             ],
         };
     }
+    buildPreOrchestrationBlock(toolName) {
+        if (!this.telemetry.needsOrchestration(toolName))
+            return null;
+        if (PRE_ORCHESTRATE_ALLOWED_TOOLS.has(toolName) || isReadOnlyMcpTool(toolName))
+            return null;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'blocked',
+                        code: 'orchestration-required',
+                        reason: 'nexus_orchestrate has not been called for this session',
+                        action: 'Call nexus_orchestrate(prompt="<your task>") before invoking mutation, worker, kernel, hook, automation, or low-level execution tools.',
+                        hint: 'Nexus Prime must own planning, token budgeting, memory recall, hooks, and review gates before work starts.',
+                    }, null, 2),
+                }],
+        };
+    }
     extractGoalLikeText(args) {
         const candidates = [args.goal, args.task, args.prompt, args.query, args.action, args.content]
             .map((value) => String(value ?? '').trim())
@@ -790,6 +825,9 @@ export class MCPAdapter {
                     }],
             };
         }
+        const preOrchestrationBlock = this.buildPreOrchestrationBlock(toolName);
+        if (preOrchestrationBlock)
+            return preOrchestrationBlock;
         const callId = `mcp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTimeMs = Date.now();
         nexusEventBus.emit('mcp.call.start', {
@@ -831,8 +869,13 @@ export class MCPAdapter {
                 ? { result: resultPreview }
                 : { error: envelope.error.message }),
         });
-        if (envelope.ok && !asyncReceipt?.queued) {
-            this.telemetry.observeSuccessfulToolCall(toolName, args);
+        if (envelope.ok) {
+            if (asyncReceipt?.queued) {
+                this.telemetry.observeQueuedToolCall(toolName, args);
+            }
+            else {
+                this.telemetry.observeSuccessfulToolCall(toolName, args);
+            }
         }
         // Surface meaningful tool calls on the SSE feed; persist only high-signal outcomes.
         if (this.nexusRef) {
@@ -1028,8 +1071,10 @@ export class MCPAdapter {
                 return;
             // Skip if an explicit optimize/orchestrate already ran this session.
             const usage = this.nexusRef?.getRuntime?.()?.getUsageSnapshot?.();
-            if (usage?.tokenOptimizationApplied)
+            if (usage?.tokenOptimizationApplied) {
+                this.telemetry.markTokenAutoApplied?.();
                 return;
+            }
             const fileRefs = this.extractFileRefsFromArgs(args);
             if (fileRefs.length < 5)
                 return;
@@ -1043,6 +1088,7 @@ export class MCPAdapter {
             const compressionRatio = grossInput > 0 ? totalEstimated / grossInput : 0;
             const pct = grossInput > 0 ? Math.round((savings / grossInput) * 100) : 0;
             // Mark applied so we don't repeat this for every subsequent tool call.
+            this.telemetry.markTokenAutoApplied?.();
             try {
                 this.nexusRef?.getRuntime?.()?.recordClientToolCall?.(toolName, {
                     tokenOptimizationApplied: true,

package/dist/cli.js

@@ -1329,12 +1329,14 @@ program
     .alias('claude')
     .description('Integrate with Claude Code')
     .option('--dry-run', 'Preview changes')
-    .option('--hooks', 'Also install Claude Code hooks into ~/.claude/settings.json for auto-bootstrap, auto-memory, and governance')
+    .option('--hooks', 'Install Claude Code hooks into ~/.claude/settings.json for auto-bootstrap, auto-memory, and governance (default)')
+    .option('--no-hooks', 'Skip Claude Code hooks')
     .action((options) => {
     const definition = getSetupDefinition('claude-code');
+    const shouldInstallHooks = options.hooks !== false;
     if (options.dryRun) {
         printSetupPreview(definition);
-        if (options.hooks) {
+        if (shouldInstallHooks) {
             const settingsPath = join(homedir(), '.claude', 'settings.json');
             writeClaudeCodeHooks(settingsPath, true);
         }
@@ -1344,7 +1346,7 @@ program
     console.log(`✅ Nexus Prime installed for Claude Code`);
     console.log(`   MCP: ${definition.configPath}`);
     definition.instructionFiles.forEach((file) => console.log(`   Instruction: ${file.path}`));
-    if (options.hooks) {
+    if (shouldInstallHooks) {
         const settingsPath = join(homedir(), '.claude', 'settings.json');
         writeClaudeCodeHooks(settingsPath, false);
         console.log(`✅ Claude Code hooks installed (auto-bootstrap, auto-memory, governance)`);
@@ -1428,9 +1430,11 @@ program
         .map((clientId) => getSetupDefinition(clientId));
     if (options.dryRun) {
         definitions.forEach((definition) => printSetupPreview(definition));
+        writeClaudeCodeHooks(join(homedir(), '.claude', 'settings.json'), true);
         return;
     }
     definitions.forEach((definition) => installSetup(definition));
+    writeClaudeCodeHooks(join(homedir(), '.claude', 'settings.json'), false);
     console.log('✅ Nexus Prime installed for all supported clients');
     definitions.forEach((definition) => {
         console.log(`   ${definition.label}`);

package/dist/engines/orchestrator.js

@@ -2618,6 +2618,8 @@ export class OrchestratorEngine {
     isCatalogVoteSelected(entry) {
         if (entry.eligible === false)
             return false;
+        if (!entry.item && entry.source !== 'explicit')
+            return false;
         if (entry.source === 'explicit' || entry.source === 'planner')
             return true;
         if (entry.source === 'runtime-resolver')
@@ -2657,6 +2659,12 @@ export class OrchestratorEngine {
         if (entry.source === 'explicit') {
             return { eligible: true };
         }
+        if (!entry.item) {
+            return {
+                eligible: false,
+                blockedReason: 'Recommended artifact is not present in the runtime catalog.',
+            };
+        }
         if (entry.source === 'scorer' && entry.confidence === 'low') {
             return {
                 eligible: false,

package/dist/engines/runtime-assets.js

@@ -568,30 +568,36 @@ export const BUILTIN_SKILL_PACKS = BASE_DOMAIN_SKILLS.flatMap((seed) => ([
         promotionThresholds: { minSuccesses: 2, maxFailures: 1 },
     },
 ]));
-export const BUILTIN_WORKFLOW_PACKS = BASE_DOMAIN_SKILLS.flatMap((seed) => ([
+const SPECIALIZED_WORKFLOW_PACKS = [
     {
-        key: `${seed.domain}-execution-loop`,
-        name: `${seed.domain}-execution-loop`,
-        domain: seed.domain,
-        description: `Bundled ${seed.domain} workflow with planning, execution, and verification checkpoints.`,
-        triggerConditions: [`goal mentions ${seed.domain}`, `${seed.domain} pack selected`],
-        expectedOutputs: seed.outputs,
-        guardrails: seed.guardrails,
-        verifierHooks: ['Collect verifier evidence before workflow promotion.', ...seed.verifierHooks],
-        roleAffinity: ['planner', 'coder', 'verifier', 'skill-maker'],
+        key: 'release-pipeline',
+        name: 'release-pipeline',
+        domain: 'pdlc',
+        description: 'Release workflow with packaging, audit, smoke, and publish-readiness checkpoints.',
+        triggerConditions: ['release requested', 'publish or deploy task detected', 'version or tag work selected'],
+        expectedOutputs: ['release checklist', 'verification evidence', 'publish decision'],
+        guardrails: [
+            'Do not treat a draft release as published.',
+            'Do not publish without explicit release-gate evidence.',
+        ],
+        verifierHooks: [
+            'Attach package, audit, and smoke evidence before promotion.',
+            'Record publish-readiness outcome in the run ledger.',
+        ],
+        roleAffinity: ['planner', 'verifier', 'devops'],
         steps: [
             {
-                title: `Plan ${seed.domain} outcome and artifacts`,
+                title: 'Frame release criteria and affected package surface',
                 checkpoint: 'before-read',
                 role: 'planner',
             },
             {
-                title: `Execute ${seed.domain} changes with bounded scope`,
-                checkpoint: 'before-mutate',
-                role: 'coder',
+                title: 'Collect package, audit, and smoke evidence',
+                checkpoint: 'before-verify',
+                role: 'verifier',
             },
             {
-                title: `Review ${seed.domain} outputs and attach evidence`,
+                title: 'Record publish readiness and remaining blockers',
                 checkpoint: 'before-verify',
                 role: 'verifier',
             },
@@ -599,35 +605,104 @@ export const BUILTIN_WORKFLOW_PACKS = BASE_DOMAIN_SKILLS.flatMap((seed) => ([
         promotionThresholds: { minSuccesses: 2, maxFailures: 1 },
     },
     {
-        key: `${seed.domain}-approval-loop`,
-        name: `${seed.domain}-approval-loop`,
-        domain: seed.domain,
-        description: `Bundled ${seed.domain} approval loop with review, verification, and promotion control.`,
-        triggerConditions: [`${seed.domain} approval requested`, `${seed.domain} promotion under review`],
-        expectedOutputs: ['approval note', 'review evidence', 'promotion decision'],
-        guardrails: ['Do not approve unverified work.', ...seed.guardrails],
-        verifierHooks: ['Require approval evidence before promotion.', ...seed.verifierHooks],
-        roleAffinity: ['planner', 'verifier', 'research-shadow'],
+        key: 'research-and-implement',
+        name: 'research-and-implement',
+        domain: 'deep-tech',
+        description: 'Research-backed implementation workflow tying retrieved context to bounded code changes and verification.',
+        triggerConditions: ['rag context attached', 'research-backed implementation requested', 'unknown code path requires grounding'],
+        expectedOutputs: ['source-grounded plan', 'bounded implementation notes', 'verification evidence'],
+        guardrails: [
+            'Do not promote research claims without source-grounded evidence.',
+            'Keep implementation scope tied to retrieved context.',
+        ],
+        verifierHooks: [
+            'Attach source-grounding notes before verification.',
+            'Record how research context changed the implementation decision.',
+        ],
+        roleAffinity: ['planner', 'coder', 'verifier', 'research-shadow'],
         steps: [
             {
-                title: `Frame ${seed.domain} approval criteria`,
+                title: 'Extract source-grounded implementation constraints',
                 checkpoint: 'before-read',
                 role: 'planner',
             },
             {
-                title: `Review ${seed.domain} evidence and risks`,
-                checkpoint: 'before-verify',
-                role: 'verifier',
+                title: 'Apply the smallest implementation compatible with the research context',
+                checkpoint: 'before-mutate',
+                role: 'coder',
             },
             {
-                title: `Publish ${seed.domain} approval outcome`,
-                checkpoint: 'retry',
-                role: 'research-shadow',
+                title: 'Verify behavior and cite grounding evidence',
+                checkpoint: 'before-verify',
+                role: 'verifier',
             },
         ],
         promotionThresholds: { minSuccesses: 2, maxFailures: 1 },
     },
-]));
+];
+export const BUILTIN_WORKFLOW_PACKS = [
+    ...BASE_DOMAIN_SKILLS.flatMap((seed) => ([
+        {
+            key: `${seed.domain}-execution-loop`,
+            name: `${seed.domain}-execution-loop`,
+            domain: seed.domain,
+            description: `Bundled ${seed.domain} workflow with planning, execution, and verification checkpoints.`,
+            triggerConditions: [`goal mentions ${seed.domain}`, `${seed.domain} pack selected`],
+            expectedOutputs: seed.outputs,
+            guardrails: seed.guardrails,
+            verifierHooks: ['Collect verifier evidence before workflow promotion.', ...seed.verifierHooks],
+            roleAffinity: ['planner', 'coder', 'verifier', 'skill-maker'],
+            steps: [
+                {
+                    title: `Plan ${seed.domain} outcome and artifacts`,
+                    checkpoint: 'before-read',
+                    role: 'planner',
+                },
+                {
+                    title: `Execute ${seed.domain} changes with bounded scope`,
+                    checkpoint: 'before-mutate',
+                    role: 'coder',
+                },
+                {
+                    title: `Review ${seed.domain} outputs and attach evidence`,
+                    checkpoint: 'before-verify',
+                    role: 'verifier',
+                },
+            ],
+            promotionThresholds: { minSuccesses: 2, maxFailures: 1 },
+        },
+        {
+            key: `${seed.domain}-approval-loop`,
+            name: `${seed.domain}-approval-loop`,
+            domain: seed.domain,
+            description: `Bundled ${seed.domain} approval loop with review, verification, and promotion control.`,
+            triggerConditions: [`${seed.domain} approval requested`, `${seed.domain} promotion under review`],
+            expectedOutputs: ['approval note', 'review evidence', 'promotion decision'],
+            guardrails: ['Do not approve unverified work.', ...seed.guardrails],
+            verifierHooks: ['Require approval evidence before promotion.', ...seed.verifierHooks],
+            roleAffinity: ['planner', 'verifier', 'research-shadow'],
+            steps: [
+                {
+                    title: `Frame ${seed.domain} approval criteria`,
+                    checkpoint: 'before-read',
+                    role: 'planner',
+                },
+                {
+                    title: `Review ${seed.domain} evidence and risks`,
+                    checkpoint: 'before-verify',
+                    role: 'verifier',
+                },
+                {
+                    title: `Publish ${seed.domain} approval outcome`,
+                    checkpoint: 'retry',
+                    role: 'research-shadow',
+                },
+            ],
+            promotionThresholds: { minSuccesses: 2, maxFailures: 1 },
+        },
+    ])),
+    ...SPECIALIZED_WORKFLOW_PACKS,
+];
 export function slugify(value) {
     return value
         .toLowerCase()

package/dist/engines/token-supremacy.d.ts

@@ -40,7 +40,7 @@ export interface SessionSummary {
     sessionId: string;
     timestamp: number;
     files: string[];
-    fileSHAs: Record<string, string>;
+    fileSHAs?: Record<string, string>;
     summary: string;
     keyDecisions: string[];
 }

package/dist/engines/token-supremacy.js

@@ -204,6 +204,10 @@ export class TokenSupremacyEngine {
     // Saves ~60-70% tokens on follow-up sessions
     // ───────────────────────────────────────────────────────────────────────────
     differential(prev, curr) {
+        const previousFileSHAs = prev.fileSHAs && typeof prev.fileSHAs === 'object'
+            ? prev.fileSHAs
+            : {};
+        const hasComparableFingerprints = Object.keys(previousFileSHAs).length > 0;
         const delta = {
             added: [],
             changed: [],
@@ -214,10 +218,15 @@ export class TokenSupremacyEngine {
                 : undefined,
         };
         for (const file of curr) {
-            const prevSHA = prev.fileSHAs[file.path];
+            const prevSHA = previousFileSHAs[file.path];
             const currSHA = this.fingerprintFile(file);
             if (!prevSHA) {
-                delta.added.push(file);
+                if (hasComparableFingerprints) {
+                    delta.added.push(file);
+                }
+                else {
+                    delta.changed.push(file);
+                }
             }
             else if (prevSHA !== currSHA) {
                 delta.changed.push(file);

package/dist/phantom/runtime/worktree.js

@@ -33,14 +33,14 @@ export class ArtifactRecorder {
     writeJson(relativePath, value) {
         const target = path.join(this.runDir, relativePath);
         fs.mkdirSync(path.dirname(target), { recursive: true });
-        void fs.promises.writeFile(target, JSON.stringify(value, null, 2), 'utf-8');
+        fs.writeFileSync(target, JSON.stringify(value, null, 2), 'utf-8');
         this.index[relativePath] = target;
         return target;
     }
     writeText(relativePath, value) {
         const target = path.join(this.runDir, relativePath);
         fs.mkdirSync(path.dirname(target), { recursive: true });
-        void fs.promises.writeFile(target, value, 'utf-8');
+        fs.writeFileSync(target, value, 'utf-8');
         this.index[relativePath] = target;
         return target;
     }

package/dist/phantom/runtime.d.ts

@@ -187,6 +187,8 @@ export interface WorkerVerification {
     workerId: string;
     verifierId: string;
     passed: boolean;
+    status: 'passed' | 'failed' | 'skipped';
+    skippedReason?: string;
     commands: CommandRecord[];
     summary: string;
     artifactsPath: string;

package/dist/phantom/runtime.js

@@ -619,6 +619,7 @@ export class SubAgentRuntime {
                     workerId: manifest.targetWorkerId ?? manifest.workerId,
                     verifierId: manifest.workerId,
                     passed: false,
+                    status: 'failed',
                     commands: [],
                     summary: target?.budgetExceeded
                         ? 'Skipped verification for over-budget worker.'
@@ -637,12 +638,14 @@ export class SubAgentRuntime {
             }
             const verification = verificationResults.find((entry) => entry.workerId === result.workerId);
             if (verification) {
+                const verificationPassed = verification.status === 'passed' || (verification.passed && verification.status !== 'skipped');
                 result.verification = verification;
-                result.verified = verification.passed;
+                result.verified = verificationPassed;
                 result.testsPassing = verification.commands.filter((command) => command.exitCode === 0).length;
-                result.outcome = verification.passed ? 'success' : (result.diff.trim() ? 'partial' : 'failed');
+                result.outcome = verificationPassed ? 'success' : (result.diff.trim() ? 'partial' : 'failed');
             }
         }
+        recorder.writeJson('worker-results.json', run.workerResults);
         const decision = await consensusPolicy.merge(mergeableCoderResults);
         run.finalDecision = decision;
         run.backendEvidence.consensus = consensusPolicy.shadowStats();
@@ -2132,13 +2135,15 @@ export class SubAgentRuntime {
         const artifactsPath = recorder.workerDir(manifest.workerId);
         // Skip worktree creation if there is nothing to verify. An empty diff
         // is not a verification failure — it means the worker produced no
-        // mutation (typical for inspect/plan intents). Mark passed=true so
-        // the run state is not flagged as failed for read-only orchestrations.
+        // mutation (typical for inspect/plan intents). This is a skipped
+        // verification, not evidence that implementation passed.
         if (!target?.diff?.trim()) {
             return {
                 workerId: manifest.targetWorkerId ?? 'unknown',
                 verifierId: manifest.workerId,
-                passed: true,
+                passed: false,
+                status: 'skipped',
+                skippedReason: 'no_candidate_diff',
                 commands: [],
                 summary: 'Verifier skipped — no candidate diff to verify (read-only or no-op run).',
                 artifactsPath,
@@ -2175,6 +2180,7 @@ export class SubAgentRuntime {
                 workerId: manifest.targetWorkerId ?? 'unknown',
                 verifierId: manifest.workerId,
                 passed,
+                status: passed ? 'passed' : 'failed',
                 commands: records,
                 summary: passed
                     ? `Verifier passed ${records.length} command(s).`
@@ -2190,6 +2196,7 @@ export class SubAgentRuntime {
                 workerId: manifest.targetWorkerId ?? 'unknown',
                 verifierId: manifest.workerId,
                 passed: false,
+                status: 'failed',
                 commands: [],
                 summary,
                 artifactsPath,
@@ -2945,8 +2952,8 @@ export class SubAgentRuntime {
         };
     }
     evaluateReviewGates(run) {
-        const verificationPassed = run.verificationResults.filter((result) => result.passed).length;
-        const verificationFailed = run.verificationResults.filter((result) => !result.passed).length;
+        const verificationPassed = run.verificationResults.filter((result) => result.status === 'passed' || (result.passed && result.status !== 'skipped')).length;
+        const verificationFailed = run.verificationResults.filter((result) => result.status === 'failed' || (!result.passed && result.status !== 'skipped')).length;
         const hasPlannerEvidence = Boolean(run.plannerState?.ledger?.length || run.plannerResult?.summary || run.executionLedger?.steps?.some((step) => step.id === 'planner-selection' && step.status === 'completed'));
         const hasImplementation = run.workerResults.some((result) => result.role === 'coder');
         const hasVerifiedImplementation = run.workerResults.some((result) => result.role === 'coder' && result.verified);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.5",
+  "version": "7.9.7",
   "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms",
   "type": "module",
   "main": "dist/index.js",