nexus-prime 7.9.6 → 7.9.8

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

@@ -293,6 +293,9 @@ export function decideWorkers(requestedWorkers, plannedWorkers, phaseCount, inte
     if (typeof requestedWorkers === 'number' && requestedWorkers > 0) {
         return Math.max(1, Math.min(7, requestedWorkers));
     }
+    if (intent.taskType === 'release') {
+        return 1;
+    }
     if (intent.riskClass !== 'high'
         && intent.complexity <= 3
         && phaseCount <= 2

package/dist/engines/orchestrator.js

@@ -2316,6 +2316,23 @@ export class OrchestratorEngine {
             limit: 4,
             selector: 'name',
         });
+        const selectedWorkflowValues = intent.taskType === 'release'
+            ? dedupeStrings(['release-pipeline', ...workflowSelection.selectedValues])
+            : workflowSelection.selectedValues;
+        const workflowSelectedEntries = [
+            ...workflowSelection.selectedEntries,
+            ...selectedWorkflowValues
+                .filter((value) => !workflowSelection.selectedEntries.some((entry) => entry.name === value || entry.id === value))
+                .map((value) => this.toArtifactAuditEntry('workflow', value, workflowItems, {
+                score: 1,
+                source: 'planner',
+                confidence: 'high',
+                reason: 'Release intent requires the release-pipeline workflow so package, audit, and smoke evidence is collected.',
+                selector: 'name',
+                selectionPolicy: 'global-first',
+                authorityTier: this.getAuthorityTier('workflow'),
+            })),
+        ];
         const hookSelection = this.resolveCatalogVotes('hook', task, intent, hookItems, {
             explicit: options.hookSelectors,
             planner: [],
@@ -2356,7 +2373,7 @@ export class OrchestratorEngine {
             selectionSummary: {
                 specialists: specialistSelection.selectedValues.length,
                 skills: skillSelection.selectedValues.length,
-                workflows: workflowSelection.selectedValues.length,
+                workflows: selectedWorkflowValues.length,
                 hooks: hookSelection.selectedValues.length,
                 automations: automationSelection.selectedValues.length,
                 crews: crewSelection.selectedValues.length,
@@ -2367,7 +2384,7 @@ export class OrchestratorEngine {
             ...crewSelection.selectedEntries,
             ...specialistSelection.selectedEntries,
             ...skillSelection.selectedEntries,
-            ...workflowSelection.selectedEntries,
+            ...workflowSelectedEntries,
             ...hookSelection.selectedEntries,
             ...automationSelection.selectedEntries,
         ];
@@ -2388,7 +2405,7 @@ export class OrchestratorEngine {
             selectionSummary: {
                 specialists: specialistSelection.selectedValues.length,
                 skills: skillSelection.selectedValues.length,
-                workflows: workflowSelection.selectedValues.length,
+                workflows: selectedWorkflowValues.length,
                 hooks: hookSelection.selectedValues.length,
                 automations: automationSelection.selectedValues.length,
                 crews: crewSelection.selectedValues.length,
@@ -2400,7 +2417,7 @@ export class OrchestratorEngine {
             crew: crewSelection.selectedValues[0],
             specialists: specialistSelection.selectedValues,
             skills: skillSelection.selectedValues,
-            workflows: workflowSelection.selectedValues,
+            workflows: selectedWorkflowValues,
             hooks: hookSelection.selectedValues,
             automations: automationSelection.selectedValues,
             audit: {
@@ -2618,6 +2635,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 +2676,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,39 @@ 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',
+                bindings: [
+                    { type: 'run_command', command: 'npm run qa:release' },
+                ],
             },
             {
-                title: `Review ${seed.domain} outputs and attach evidence`,
+                title: 'Record publish readiness and remaining blockers',
                 checkpoint: 'before-verify',
                 role: 'verifier',
             },
@@ -599,35 +608,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.d.ts

@@ -8,6 +8,10 @@ import { type WorktreeHealthSnapshot } from '../../engines/worktree-health.js';
 import type { MergeDecision } from '../index.js';
 import type { RuntimeWorkerResult, WorkerRole } from '../runtime.js';
 import { type CommandRecord } from './worker.js';
+export interface BindingApplicationResult {
+    modifiedFiles: string[];
+    commandRecords: CommandRecord[];
+}
 /**
  * Lightweight per-run artifact writer. Maintains a flat index of paths
  * written so callers can recover the full run artifact layout.
@@ -36,11 +40,12 @@ export declare class WorktreeSession {
     constructor(repoRoot: string, workerId: string, role: WorkerRole, recorder: ArtifactRecorder, reportHealth?: (snapshot: WorktreeHealthSnapshot) => void);
     create(): Promise<void>;
     run(command: string, allowFailure?: boolean, timeoutMs?: number): Promise<CommandRecord>;
-    applyBindings(bindings: SkillBinding[], timeoutMs?: number): Promise<string[]>;
+    applyBindings(bindings: SkillBinding[], timeoutMs?: number): Promise<BindingApplicationResult>;
     captureDiff(): Promise<string>;
     applyPatchContent(diff: string): Promise<void>;
     cleanup(): Promise<void>;
     private resolve;
+    private linkWorkspaceDependencies;
 }
 /** Thin adapter that wraps a MemoryBackend for use inside MergeOracle. */
 export declare class MergeMemoryAdapter {

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;
     }
@@ -75,6 +75,7 @@ export class WorktreeSession {
                 cwd: this.repoRoot,
                 maxBuffer: 1024 * 1024 * 20,
             });
+            await this.linkWorkspaceDependencies();
         }
         catch (error) {
             const retryHealth = await doctorGitWorktrees(this.repoRoot);
@@ -87,6 +88,7 @@ export class WorktreeSession {
     }
     async applyBindings(bindings, timeoutMs) {
         const modified = new Set();
+        const commandRecords = [];
         for (const binding of bindings) {
             switch (binding.type) {
                 case 'write_file': {
@@ -114,12 +116,13 @@ export class WorktreeSession {
                 }
                 case 'run_command': {
                     const record = await this.run(binding.command || '', false, timeoutMs);
+                    commandRecords.push(record);
                     this.recorder.writeJson(path.join('workers', this.workerId, `${sanitizeFileName(record.command)}.json`), record);
                     break;
                 }
             }
         }
-        return [...modified];
+        return { modifiedFiles: [...modified], commandRecords };
     }
     async captureDiff() {
         try {
@@ -130,6 +133,12 @@ export class WorktreeSession {
             catch {
                 // Runtime skill overlays stay outside repo patches.
             }
+            try {
+                await exec('git reset HEAD -- node_modules', { cwd: this.worktreeDir, maxBuffer: 1024 * 1024 * 20 });
+            }
+            catch {
+                // Shared dependency symlink stays outside repo patches.
+            }
             const { stdout } = await exec('git diff --binary --cached HEAD', {
                 cwd: this.worktreeDir,
                 maxBuffer: 1024 * 1024 * 20,
@@ -167,6 +176,23 @@ export class WorktreeSession {
             return target;
         return path.join(this.worktreeDir, target);
     }
+    async linkWorkspaceDependencies() {
+        const source = path.join(this.repoRoot, 'node_modules');
+        const target = path.join(this.worktreeDir, 'node_modules');
+        try {
+            const stat = await fs.promises.lstat(source);
+            if (!stat.isDirectory() && !stat.isSymbolicLink())
+                return;
+            await fs.promises.lstat(target).then(() => undefined).catch(async (error) => {
+                if (error?.code !== 'ENOENT')
+                    throw error;
+                await fs.promises.symlink(source, target, 'dir');
+            });
+        }
+        catch {
+            // Worktrees remain valid for repos that do not use node_modules or have not installed deps.
+        }
+    }
 }
 // ─── MergeMemoryAdapter ───────────────────────────────────────────────────────
 /** Thin adapter that wraps a MemoryBackend for use inside MergeOracle. */

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;
@@ -197,6 +199,7 @@ export interface RuntimeWorkerResult extends WorkerResult {
     verification?: WorkerVerification;
     artifactsPath: string;
     modifiedFiles: string[];
+    commandRecords?: CommandRecord[];
 }
 export interface PlannerResult {
     summary: string;
@@ -531,6 +534,7 @@ export declare class SubAgentRuntime {
     private applyDecision;
     private evaluatePromotions;
     private resolveCandidateDiff;
+    private isCommandOnlyOperationalSuccess;
     private resolveFileRefs;
     private discoverTargetFiles;
     private collectLibraryCounts;

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();
@@ -685,14 +688,15 @@ export class SubAgentRuntime {
             : enforcedBlockingGate
                 ? { applied: false, rolledBack: false, summary: `Review gate ${enforcedBlockingGate.gate} remains ${enforcedBlockingGate.status}.` }
                 : await this.applyDecision(recorder, { ...task, verifyCommands: beforeVerifyResolved.verifyCommands }, decision, consensusPolicy);
-        // Read-only intents (inspect/plan) don't produce a diff to apply, so applied=false
-        // is the expected outcome — not a failure. Only mark 'failed' when a shield blocked,
-        // a review gate enforced, or a mutate run produced no applicable diff.
+        const commandOnlyOperationalSuccess = this.isCommandOnlyOperationalSuccess(task, decision);
+        // Read-only and command-only operational runs don't produce a diff to apply.
+        // Only mark 'failed' when a shield blocked, a review gate enforced, or a
+        // mutate run produced neither a patch nor successful command evidence.
         const readOnlyIntent = task.intent === 'inspect' || task.intent === 'plan';
         const failureExpected = preApplyShield.blocked || Boolean(enforcedBlockingGate);
         run.state = applied.applied
             ? (applied.rolledBack ? 'rolled_back' : 'merged')
-            : (readOnlyIntent && !failureExpected ? 'inspected' : 'failed');
+            : ((readOnlyIntent || commandOnlyOperationalSuccess) && !failureExpected ? 'inspected' : 'failed');
         // Surface completion on the SSE feed so the dashboard can move the
         // run from "Running" to "Done" without a poll round-trip.
         try {
@@ -2045,13 +2049,20 @@ export class SubAgentRuntime {
                     verified: false,
                     artifactsPath: workerDir,
                     modifiedFiles: [],
+                    commandRecords: [],
                 };
             }
-            const modifiedFiles = await session.applyBindings(allowedActions, timeoutMs);
+            const bindingResult = await session.applyBindings(allowedActions, timeoutMs);
+            const modifiedFiles = bindingResult.modifiedFiles;
+            const commandRecords = bindingResult.commandRecords;
             modifiedFiles.forEach(file => {
                 this.sessionDNA?.recordFileModified(file);
                 learnings.push(`Modified ${file}`);
             });
+            if (commandRecords.length > 0) {
+                const passedCommands = commandRecords.filter((record) => record.exitCode === 0).length;
+                learnings.push(`Ran ${commandRecords.length} command binding(s), ${passedCommands} passed.`);
+            }
             const diff = await session.captureDiff();
             recorder.writeText(path.join('workers', manifest.workerId, 'diff.patch'), diff);
             podNetwork.publish(manifest.workerId, `Produced ${modifiedFiles.length} modified files`, 0.8, ['#runtime-worker']);
@@ -2060,23 +2071,30 @@ export class SubAgentRuntime {
             if (budgetExceeded) {
                 learnings.push(`Token budget exceeded: used ${estimatedTokens}, budget ${manifest.tokenBudget}`);
             }
-            nexusEventBus.emit('phantom.worker.complete', { workerId: manifest.workerId, confidence: budgetExceeded ? 0.1 : (diff.trim() ? 0.7 : 0.2) });
+            const commandOnlySuccess = !diff.trim()
+                && commandRecords.length > 0
+                && commandRecords.every((record) => record.exitCode === 0);
+            nexusEventBus.emit('phantom.worker.complete', {
+                workerId: manifest.workerId,
+                confidence: budgetExceeded ? 0.1 : (diff.trim() ? 0.7 : (commandOnlySuccess ? 0.75 : 0.2)),
+            });
             return {
                 workerId: manifest.workerId,
                 role: manifest.role,
                 taskId: runId,
                 approach: manifest.strategy,
                 diff,
-                outcome: budgetExceeded ? 'budgetExceeded' : (diff.trim() ? 'partial' : 'failed'),
-                confidence: budgetExceeded ? 0.1 : (diff.trim() ? 0.68 : 0.18),
+                outcome: budgetExceeded ? 'budgetExceeded' : (diff.trim() ? 'partial' : (commandOnlySuccess ? 'success' : 'failed')),
+                confidence: budgetExceeded ? 0.1 : (diff.trim() ? 0.68 : (commandOnlySuccess ? 0.82 : 0.18)),
                 tokensUsed: estimatedTokens,
                 tokenEstimateSource: 'runtime-estimate',
                 budgetExceeded,
                 learnings,
-                testsPassing: 0,
+                testsPassing: commandRecords.filter((record) => record.exitCode === 0).length,
                 verified: false,
                 artifactsPath: workerDir,
                 modifiedFiles,
+                commandRecords,
             };
         }
         catch (error) {
@@ -2099,6 +2117,7 @@ export class SubAgentRuntime {
                 verified: false,
                 artifactsPath: workerDir,
                 modifiedFiles: [],
+                commandRecords: [],
             };
         }
         finally {
@@ -2130,15 +2149,31 @@ export class SubAgentRuntime {
         const verifier = new WorktreeSession(this.repoRoot, `${runId}-${manifest.workerId}`, 'verifier', recorder, (snapshot) => this.recordWorktreeHealth(snapshot));
         const records = [];
         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.
+        const commandRecords = target?.commandRecords ?? [];
+        const commandOnlySuccess = !target?.diff?.trim()
+            && commandRecords.length > 0
+            && commandRecords.every((record) => record.exitCode === 0);
+        // Skip worktree creation if there is no diff. Command-only operational
+        // workers are verified from their command records; pure no-op workers
+        // remain skipped rather than counted as implementation evidence.
         if (!target?.diff?.trim()) {
+            if (commandOnlySuccess) {
+                return {
+                    workerId: manifest.targetWorkerId ?? 'unknown',
+                    verifierId: manifest.workerId,
+                    passed: true,
+                    status: 'passed',
+                    commands: commandRecords,
+                    summary: `Verifier accepted command-only evidence (${commandRecords.length} command binding(s) passed).`,
+                    artifactsPath,
+                };
+            }
             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 +2210,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 +2226,7 @@ export class SubAgentRuntime {
                 workerId: manifest.targetWorkerId ?? 'unknown',
                 verifierId: manifest.workerId,
                 passed: false,
+                status: 'failed',
                 commands: [],
                 summary,
                 artifactsPath,
@@ -2202,6 +2239,14 @@ export class SubAgentRuntime {
     async applyDecision(recorder, task, decision, consensusPolicy) {
         const candidateDiff = this.resolveCandidateDiff(decision);
         if (!candidateDiff.trim()) {
+            if (this.isCommandOnlyOperationalSuccess(task, decision)) {
+                const records = decision.winner?.commandRecords ?? [];
+                return {
+                    applied: false,
+                    rolledBack: false,
+                    summary: `Operational workflow completed with command evidence only (${records.length} command binding(s) passed); no repository patch was required.`,
+                };
+            }
             return {
                 applied: false,
                 rolledBack: false,
@@ -2402,6 +2447,20 @@ export class SubAgentRuntime {
         }
         return decision.winner?.diff ?? '';
     }
+    isCommandOnlyOperationalSuccess(task, decision) {
+        if (decision.action === 'reject')
+            return false;
+        if (this.resolveCandidateDiff(decision).trim())
+            return false;
+        const winner = decision.winner;
+        const records = winner?.commandRecords ?? [];
+        if (records.length === 0 || !records.every((record) => record.exitCode === 0)) {
+            return false;
+        }
+        return task.releasePolicy.mode === 'ship-ready'
+            || task.workflowSelectors.some((selector) => /release|deploy|publish|ci|smoke|audit/i.test(selector))
+            || /release|publish|deploy|npm|github action|ci\/cd|smoke|audit/i.test(task.goal);
+    }
     async resolveFileRefs(files) {
         return Promise.all(files.map(async (file) => {
             const resolved = path.isAbsolute(file) ? file : path.join(this.repoRoot, file);
@@ -2945,8 +3004,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.6",
+  "version": "7.9.8",
   "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",