nexus-prime 7.9.21 → 7.9.23

package/dist/engines/memory.js

@@ -27,6 +27,7 @@ import { createMemoryContentFingerprint } from './memory-fingerprint.js';
 import { resolveCurrentRepoId, warmRepoId, resolveCurrentProjectId, resolvePreferredStateRoot, openMemoryDatabase, } from './memory/schema.js';
 import { safeParseTags, safeParseObject, dedupeStrings, isOperatorVisibleTag, seedDemoMemoriesOnFirstBoot } from './memory/store.js';
 import { dedupeReferences, dedupeLinks, sanitizeFileName } from './memory/recall.js';
+import { QMD_WEIGHTS } from './memory/entropy-decay.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // Types — extracted to memory/types.ts (Phase 1 of v7.x memory split)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1788,19 +1789,32 @@ export class MemoryEngine {
         let scope = existing.scope;
         let state = existing.state;
         let tags = [...existing.tags];
+        const qmd = this.qmdComponents(existing);
+        let entropy = existing.entropy;
+        let qmdRecency = qmd.recency;
+        let qmdFrequency = qmd.frequency;
+        let qmdRelevance = qmd.relevance;
         if (reaction === 'positive') {
             priority = Math.min(1, priority + 0.06 * Math.max(rating, 0));
             trust = Math.min(1, trust + 0.12 * Math.max(rating, 0));
+            entropy = Math.max(0, entropy - 0.08 * Math.max(rating, 0));
+            qmdFrequency = Math.min(1, qmdFrequency + 0.08);
+            qmdRelevance = Math.min(1, qmdRelevance + 0.1 * Math.max(rating, 0));
         }
         else if (reaction === 'negative') {
             priority = Math.max(0.05, priority + 0.08 * Math.min(rating, 0));
             trust = Math.max(0.05, trust + 0.18 * Math.min(rating, 0));
+            entropy = Math.min(1, entropy + 0.12 * Math.abs(Math.min(rating, 0)));
+            qmdRelevance = Math.max(0, qmdRelevance - 0.12 * Math.abs(Math.min(rating, 0)));
         }
         else if (reaction === 'promote') {
             priority = Math.min(1, Math.max(priority, 0.9));
             trust = Math.min(1, Math.max(trust, 0.82));
             scope = 'promoted';
             tags = dedupeStrings([...tags.filter((tag) => tag !== '#quarantine'), '#promoted']);
+            entropy = Math.max(0, entropy - 0.18);
+            qmdFrequency = Math.min(1, qmdFrequency + 0.18);
+            qmdRelevance = Math.min(1, Math.max(qmdRelevance, 0.82));
         }
         else if (reaction === 'demote') {
             priority = Math.max(0.1, priority - 0.08);
@@ -1808,11 +1822,17 @@ export class MemoryEngine {
             if (scope === 'promoted')
                 scope = 'project';
             tags = tags.filter((tag) => tag !== '#promoted');
+            entropy = Math.min(1, entropy + 0.1);
+            qmdFrequency = Math.max(0, qmdFrequency - 0.08);
+            qmdRelevance = Math.max(0, qmdRelevance - 0.12);
         }
         else if (reaction === 'quarantine') {
             state = 'quarantined';
             tags = dedupeStrings([...tags, '#quarantine']);
+            entropy = Math.min(1, entropy + 0.18);
+            qmdRelevance = Math.max(0, qmdRelevance - 0.2);
         }
+        qmdRecency = Math.min(1, qmdRecency + 0.05);
         const nextExpiresAt = state === 'active'
             ? existing.expiresAt
             : state === 'quarantined'
@@ -1834,9 +1854,9 @@ export class MemoryEngine {
         this.withSqliteRetry('submitMemoryFeedback', () => {
             this.db.prepare(`
         UPDATE memories
-        SET priority = ?, trust = ?, scope = ?, state = ?, tags = ?, provenance_json = ?, expires_at = ?, purge_at = ?
+        SET priority = ?, trust = ?, scope = ?, state = ?, tags = ?, entropy = ?, qmd_recency = ?, qmd_frequency = ?, qmd_relevance = ?, provenance_json = ?, expires_at = ?, purge_at = ?
         WHERE id = ?
-      `).run(priority, trust, scope, state, JSON.stringify(dedupeStrings(tags)), JSON.stringify(provenance), nextExpiresAt ?? null, nextPurgeAt ?? null, id);
+      `).run(priority, trust, scope, state, JSON.stringify(dedupeStrings(tags)), entropy, qmdRecency, qmdFrequency, qmdRelevance, JSON.stringify(provenance), nextExpiresAt ?? null, nextPurgeAt ?? null, id);
         });
         const historyEntry = this.appendHistory(id, 'feedback', `Memory feedback recorded: ${reaction}.`, {
             reaction,
@@ -1844,17 +1864,24 @@ export class MemoryEngine {
             note: input.note ?? null,
             priority,
             trust,
+            entropy,
+            qmdRecency,
+            qmdFrequency,
+            qmdRelevance,
             scope,
             state,
         }, input.provenance ?? provenance);
         this.markVaultDirty(id);
         this.syncVault(true);
+        const item = this.getSnapshot(id);
         return {
             accepted: true,
             historyEntry,
-            item: this.getSnapshot(id),
+            item,
             trust,
             priority,
+            decay: item?.decay,
+            reinforcement: item?.reinforcement,
         };
     }
     // ─────────────────────────────────────────────────────────────────────────
@@ -2024,15 +2051,20 @@ export class MemoryEngine {
             this.db.prepare(`
         UPDATE memories
         SET entropy = MAX(0.0, MIN(1.0, entropy + ?)),
-            priority = priority * ?
+            priority = priority * ?,
+            qmd_recency = MAX(0.0, MIN(1.0, COALESCE(qmd_recency, 1.0) - (? * 0.5))),
+            qmd_frequency = MAX(0.0, MIN(1.0, COALESCE(qmd_frequency, MIN(1.0, CAST(access_count AS REAL) / 20.0)) * (1.0 - ?))),
+            qmd_relevance = MAX(0.0, MIN(1.0, COALESCE(qmd_relevance, 1.0 - entropy) - (? * 0.35)))
         WHERE tier = ?
-      `).run(rate, tier === 'cortex' ? 1.0 : priorityRetention, tier);
+      `).run(rate, tier === 'cortex' ? 1.0 : priorityRetention, rate, rate, rate, tier);
             // Apply access-frequency retention: frequently accessed memories decay slower
             this.db.prepare(`
         UPDATE memories
-        SET entropy = MAX(0.0, MIN(1.0, entropy - (? / (1.0 + CAST(access_count AS REAL) * 0.1))))
+        SET entropy = MAX(0.0, MIN(1.0, entropy - (? / (1.0 + CAST(access_count AS REAL) * 0.1)))),
+            qmd_frequency = MAX(0.0, MIN(1.0, COALESCE(qmd_frequency, 0.0) + (? / 2.0))),
+            qmd_relevance = MAX(0.0, MIN(1.0, COALESCE(qmd_relevance, 1.0 - entropy) + (? / 3.0)))
         WHERE tier = ? AND access_count > 0
-      `).run(rate, tier);
+      `).run(rate, rate, rate, tier);
         }
         // Force flush high entropy items (this will promote/demote based on priority)
         this.consolidate();
@@ -2495,6 +2527,9 @@ export class MemoryEngine {
             `freshnessScore: ${snapshot.freshnessScore}`,
             `trustScore: ${snapshot.trustScore}`,
             `entropyScore: ${snapshot.entropyScore}`,
+            `decayState: ${snapshot.decay.state}`,
+            `decayScore: ${snapshot.decay.score}`,
+            `reinforcementScore: ${snapshot.reinforcement.score}`,
             `timestamp: ${new Date(item.timestamp).toISOString()}`,
             item.expiresAt ? `expiresAt: ${new Date(item.expiresAt).toISOString()}` : 'expiresAt:',
             item.supersedes ? `supersedes: ${item.supersedes}` : 'supersedes:',
@@ -2509,6 +2544,11 @@ export class MemoryEngine {
             `- source: ${item.provenance.source}`,
             ...(item.provenance.references.length > 0 ? item.provenance.references.map((reference) => `- ref: ${reference}`) : ['- ref: none']),
             '',
+            '## Lifecycle',
+            `- decay: ${snapshot.decay.state} (${snapshot.decay.score.toFixed(3)})`,
+            `- next action: ${snapshot.decay.nextAction}`,
+            `- reinforcement: ${snapshot.reinforcement.score.toFixed(3)} from ${snapshot.reinforcement.feedbackCount} feedback events and ${snapshot.reinforcement.accessCount} recalls`,
+            '',
             '## Related Runtime Objects',
             related || '- none',
             '',
@@ -2843,13 +2883,103 @@ export class MemoryEngine {
     `).all(entropyLimit, limit);
         return rows.map((row) => this.rowToItem(row));
     }
-    computeQmdScore(item) {
+    clamp01(value) {
+        if (!Number.isFinite(value))
+            return 0;
+        return Math.max(0, Math.min(1, value));
+    }
+    qmdComponents(item) {
         const now = Date.now();
         const ageDays = (now - item.timestamp) / 86_400_000;
-        const recency = item.qmdRecency ?? Math.max(0, 1 - ageDays / 30);
-        const frequency = item.qmdFrequency ?? Math.min(1, item.accessCount / 20);
-        const relevance = item.qmdRelevance ?? (1 - item.entropy);
-        return 0.3 * recency + 0.3 * frequency + 0.2 * relevance + 0.2 * item.trust;
+        return {
+            recency: this.clamp01(item.qmdRecency ?? Math.max(0, 1 - ageDays / 30)),
+            frequency: this.clamp01(item.qmdFrequency ?? Math.min(1, item.accessCount / 20)),
+            relevance: this.clamp01(item.qmdRelevance ?? (1 - item.entropy)),
+        };
+    }
+    computeQmdScore(item) {
+        const qmd = this.qmdComponents(item);
+        const qmdWeightTotal = QMD_WEIGHTS.recency + QMD_WEIGHTS.frequency + QMD_WEIGHTS.relevance;
+        const trustWeight = Math.max(0, 1 - qmdWeightTotal);
+        return this.clamp01((QMD_WEIGHTS.recency * qmd.recency)
+            + (QMD_WEIGHTS.frequency * qmd.frequency)
+            + (QMD_WEIGHTS.relevance * qmd.relevance)
+            + (trustWeight * item.trust));
+    }
+    getFeedbackStats(memoryId) {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) as count, MAX(timestamp) as lastAt
+      FROM memory_history
+      WHERE memory_id = ? AND event_type = 'feedback'
+    `).get(memoryId);
+        return {
+            count: Number(row?.count ?? 0),
+            lastAt: typeof row?.lastAt === 'number' ? row.lastAt : undefined,
+        };
+    }
+    buildDecayProfile(item) {
+        const ageDays = Math.max(0, (Date.now() - item.timestamp) / 86_400_000);
+        const retentionHint = item.provenance.retentionHint ?? 'default';
+        const halfLifeDays = retentionHint === 'forever'
+            ? 365
+            : retentionHint === 'long'
+                ? 180
+                : retentionHint === 'short'
+                    ? 30
+                    : retentionHint === 'session'
+                        ? 3
+                        : 90;
+        const qmd = this.qmdComponents(item);
+        const ageDecay = this.clamp01(1 - Math.pow(0.5, ageDays / Math.max(halfLifeDays, 1)));
+        const accessRetention = Math.min(0.2, qmd.frequency * 0.2);
+        const score = this.clamp01((item.entropy * 0.55) + (ageDecay * 0.3) + ((1 - qmd.relevance) * 0.15) - accessRetention);
+        const state = score >= 0.75 ? 'retiring' : score >= 0.5 ? 'stale' : score >= 0.25 ? 'fading' : 'fresh';
+        const nextAction = state === 'fresh'
+            ? 'keep'
+            : state === 'fading'
+                ? 'reinforce'
+                : state === 'stale'
+                    ? 'review'
+                    : 'archive';
+        const reasons = [
+            item.entropy >= 0.8 ? `entropy ${item.entropy.toFixed(2)} is high` : `entropy ${item.entropy.toFixed(2)}`,
+            ageDays >= halfLifeDays ? `age ${Math.round(ageDays)}d passed half-life ${halfLifeDays}d` : `age ${Math.round(ageDays)}d within half-life ${halfLifeDays}d`,
+            item.accessCount > 0 ? `${item.accessCount} recalls slow decay` : 'no recall reinforcement yet',
+            `retention ${retentionHint}`,
+        ];
+        return {
+            score,
+            state,
+            ageDays,
+            halfLifeDays,
+            retentionHint,
+            nextAction,
+            reasons,
+        };
+    }
+    buildReinforcementProfile(item) {
+        const qmd = this.qmdComponents(item);
+        const feedback = this.getFeedbackStats(item.id);
+        const feedbackScore = this.clamp01(feedback.count / 5);
+        const score = this.clamp01((qmd.frequency * 0.3)
+            + (qmd.relevance * 0.25)
+            + (item.trust * 0.25)
+            + (feedbackScore * 0.2));
+        const reasons = [
+            item.accessCount > 0 ? `${item.accessCount} recalls` : 'not recalled yet',
+            feedback.count > 0 ? `${feedback.count} feedback events` : 'no feedback yet',
+            item.trust >= 0.8 ? 'high trust' : `trust ${item.trust.toFixed(2)}`,
+            qmd.relevance >= 0.7 ? 'high QMD relevance' : `QMD relevance ${qmd.relevance.toFixed(2)}`,
+        ];
+        return {
+            score,
+            accessCount: item.accessCount,
+            trust: item.trust,
+            feedbackCount: feedback.count,
+            lastFeedbackAt: feedback.lastAt,
+            qmd,
+            reasons,
+        };
     }
     applyRecallRerankerHint(score, item, hint) {
         if (!hint || hint === 'balanced') {
@@ -2912,6 +3042,8 @@ export class MemoryEngine {
             freshnessScore: this.freshnessScore(item),
             trustScore: item.trust,
             entropyScore: item.entropy,
+            decay: this.buildDecayProfile(item),
+            reinforcement: this.buildReinforcementProfile(item),
             provenance: item.provenance,
             expiresAt: item.expiresAt,
             purgeAt: item.purgeAt,

package/dist/engines/orchestrator/decision-spine.d.ts

@@ -76,7 +76,17 @@ export interface SourceBudgets {
     graph: number;
     runtime: number;
     skills: number;
+    reasoning: number;
+    codeBlocks: number;
+    verification: number;
     reserve: number;
+    codeBlockPolicy: {
+        detectedBlocks: number;
+        templateBlocks: number;
+        reservedTokens: number;
+        languages: string[];
+        templates: string[];
+    };
 }
 export interface RiskGate {
     gate: string;
@@ -98,6 +108,22 @@ export interface ExecutionPolicy {
     reviewMode: 'none' | 'self-check' | 'reviewer' | 'escalated-review';
     escalationPolicy: string[];
     reasons: string[];
+    agentFlow: {
+        enabled: true;
+        boardSource: 'nexus-runtime';
+        maxTaskCostUsd: number;
+        hardStopUsd: number;
+        crashRecovery: string;
+        dispatchPolicy: string;
+        deterministicGates: string[];
+        stages: Array<{
+            stage: 'research' | 'build' | 'review' | 'test' | 'integrate' | 'done';
+            ownerRole: 'planner' | 'coder' | 'researcher' | 'reviewer' | 'verifier' | 'integrator';
+            gate: string;
+            modelTier: ModelTier;
+            budgetShare: number;
+        }>;
+    };
 }
 export interface SelectionProvenance {
     targetType: 'file' | 'memory' | 'skill' | 'workflow' | 'crew' | 'specialist' | 'model' | 'hook' | 'automation';

package/dist/engines/orchestrator/decision-spine.js

@@ -42,12 +42,22 @@ function inferRisk(task) {
         ...(task.manualOverrides ?? []),
         ...(task.actions ?? []).map(actionName),
     ].join(' ').toLowerCase();
+    const intent = normalizeIntent(task.intent);
+    const readOnlyIntent = intent === 'inspect' || intent === 'plan';
+    const controlPlaneCore = /(orchestrat|synapse|runtime|scheduler|workflow|mcp|model routing|hiring|selection|control plane|worker|dispatch|queue|queued|scheduled)/i.test(text);
+    const mutationIntent = /\b(fix|patch|change|modify|implement|build|create|harden|refactor|rewrite|repair|improve)\b/i.test(text);
     if (/(delete|destroy|drop table|rm\s+-rf|force-push|production|credential|secret|billing|payment)/i.test(text)) {
         return 'critical';
     }
+    if (!readOnlyIntent && controlPlaneCore && mutationIntent) {
+        return 'high';
+    }
     if ((task.files ?? []).length > 8 || Number(task.workers ?? 1) > 3 || /(release|migration|auth|security)/i.test(text)) {
         return 'high';
     }
+    if (!readOnlyIntent && (mutationIntent || /(bug|broken|not working|doesn.t work|scheduled|queued)/i.test(text))) {
+        return 'medium';
+    }
     if ((task.files ?? []).length > 0 || (task.actions ?? []).length > 0)
         return 'medium';
     return 'low';
@@ -100,6 +110,86 @@ export function inferModelRoute(input) {
 function normalizeTools(values) {
     return unique(values.flatMap((value) => Array.isArray(value) ? value : [value]), 30);
 }
+function resolveCostGuardrailUsd(task, run, risk) {
+    const explicit = Number(task.budgetCapUsd ?? task.maxCostUsd ?? run.budgetCapUsd ?? run.maxCostUsd);
+    if (Number.isFinite(explicit) && explicit > 0)
+        return Math.min(50, Math.max(0.25, explicit));
+    if (risk === 'critical')
+        return 20;
+    if (risk === 'high')
+        return 10;
+    if (risk === 'medium')
+        return 3;
+    return 1;
+}
+function buildAgentFlowPolicy(input) {
+    const budget = resolveCostGuardrailUsd(input.task, input.run, input.risk);
+    const reviewerTier = input.modelRoute.reviewerTier ?? input.modelRoute.workerTier;
+    const stages = [
+        {
+            stage: 'research',
+            ownerRole: 'planner',
+            gate: 'request brief, memory recall, and candidate context selected',
+            modelTier: reviewerTier,
+            budgetShare: 0.12,
+        },
+        {
+            stage: 'build',
+            ownerRole: 'coder',
+            gate: 'owned files only, small diff, no unrelated churn',
+            modelTier: input.modelRoute.workerTier,
+            budgetShare: input.workerCount > 1 ? 0.44 : 0.5,
+        },
+        {
+            stage: 'review',
+            ownerRole: input.reviewMode === 'none' ? 'verifier' : 'reviewer',
+            gate: input.reviewMode === 'none'
+                ? 'self-check only for low-risk advisory work'
+                : 'adversarial review must identify risks before pass',
+            modelTier: reviewerTier,
+            budgetShare: input.reviewMode === 'none' ? 0.08 : 0.16,
+        },
+        {
+            stage: 'test',
+            ownerRole: 'verifier',
+            gate: input.verificationRequired ? 'targeted tests/build/lint required' : 'verification optional unless files changed',
+            modelTier: reviewerTier,
+            budgetShare: 0.14,
+        },
+        {
+            stage: 'integrate',
+            ownerRole: 'integrator',
+            gate: input.workerCount > 1 ? 'merge independent packets and check conflicts' : 'summarize single-lane result',
+            modelTier: reviewerTier,
+            budgetShare: 0.1,
+        },
+        {
+            stage: 'done',
+            ownerRole: 'verifier',
+            gate: 'record verification, memory write-back, and residual risk',
+            modelTier: reviewerTier,
+            budgetShare: 0.08,
+        },
+    ];
+    return {
+        enabled: true,
+        boardSource: 'nexus-runtime',
+        maxTaskCostUsd: budget,
+        hardStopUsd: Math.max(budget, Math.min(50, budget * 2)),
+        crashRecovery: 'Persist run state, decision-spine artifacts, and worker lanes so the next sweep can resume.',
+        dispatchPolicy: input.workerCount > 1
+            ? 'bounded parallel lanes with one owner per file and deterministic gates before AI review'
+            : 'single worker lane with planner and verifier checkpoints',
+        deterministicGates: unique([
+            'build',
+            'lint',
+            'test',
+            input.reviewMode !== 'none' ? 'adversarial-review' : '',
+            input.workerCount > 1 ? 'integration-conflict-check' : '',
+        ], 8),
+        stages,
+    };
+}
 export function buildExecutionPolicy(input) {
     const task = input.task ?? {};
     const run = input.run ?? {};
@@ -123,6 +213,7 @@ export function buildExecutionPolicy(input) {
     const topology = String(task.topology ?? planner.swarmDecision?.mode ?? 'auto');
     const coderTier = modelRoute.workerTier;
     const reviewerTier = modelRoute.reviewerTier ?? modelRoute.workerTier;
+    const verificationRequired = reviewMode !== 'none' || (task.verifyCommands ?? []).length > 0;
     return {
         topology,
         workerCount,
@@ -135,7 +226,7 @@ export function buildExecutionPolicy(input) {
             { role: 'coder', modelTier: coderTier, authority: tools.some((tool) => /write|append|replace|run_command/.test(tool)) ? 'write' : 'read', reviewRequired: reviewMode !== 'none' },
             { role: 'verifier', modelTier: reviewerTier, authority: 'verify', reviewRequired: false },
         ],
-        verificationRequired: reviewMode !== 'none' || (task.verifyCommands ?? []).length > 0,
+        verificationRequired,
         reviewMode,
         escalationPolicy: modelRoute.escalationPolicy,
         reasons: unique([
@@ -145,6 +236,15 @@ export function buildExecutionPolicy(input) {
             workerCount > 1 ? 'Multiple workers require bounded parallelism and verifier coverage.' : '',
             (task.verifyCommands ?? []).length > 0 ? 'Explicit verification commands were provided.' : '',
         ], 8),
+        agentFlow: buildAgentFlowPolicy({
+            task,
+            run,
+            risk,
+            workerCount,
+            modelRoute,
+            reviewMode,
+            verificationRequired,
+        }),
     };
 }
 export function buildRequestBrief(input) {
@@ -180,17 +280,56 @@ export function buildRequestBrief(input) {
     };
 }
 function buildBudgets(run, task, readingPlan) {
-    const totalTokens = Number(readingPlan?.totalEstimatedTokens ?? run.tokenTelemetry?.forwardedTokens ?? 0);
+    const repoTokens = Number(readingPlan?.totalEstimatedTokens ?? run.tokenTelemetry?.forwardedTokens ?? 0);
+    const promptText = String(task.goal ?? '');
+    const detectedBlocks = Math.floor((promptText.match(/```/g) ?? []).length / 2);
+    const languages = unique([...promptText.matchAll(/```([a-z0-9_-]+)/gi)].map((match) => match[1]), 8);
+    const wantsCodeBlocks = detectedBlocks > 0 || /(code blocks?|template|patch|diff|snippet|implementation|coding quality|work quality)/i.test(promptText);
+    const templateBlocks = wantsCodeBlocks ? 4 : 2;
+    const codeBlockTokens = Math.min(2400, Math.max(360, detectedBlocks * 320 + templateBlocks * 220));
     const skillTokens = Math.min(1600, Math.max(400, (run.activeSkills?.length ?? 0) * 220 + (run.activeWorkflows?.length ?? 0) * 180));
+    const promptTokens = Math.min(1600, Math.max(200, Math.ceil(promptText.length / 4)));
+    const memoryTokens = Math.min(2400, Math.max(300, (run.backendEvidence?.memory?.recalled?.length ?? 0) * 300));
+    const graphTokens = run.knowledgeFabric ? 800 : 0;
+    const runtimeTokens = run.executionLedger ? 600 : 0;
+    const risk = run.requestBrief?.risk ?? inferRisk(task);
+    const reasoningTokens = risk === 'critical' ? 1800 : risk === 'high' ? 1400 : risk === 'medium' ? 900 : 500;
+    const verificationTokens = Math.min(1600, Math.max(260, (task.verifyCommands?.length ?? run.workerManifests?.length ?? 1) * 180));
+    const reserve = Math.max(500, Math.ceil((repoTokens + memoryTokens + codeBlockTokens) * 0.1));
+    const totalTokens = repoTokens
+        + promptTokens
+        + memoryTokens
+        + graphTokens
+        + runtimeTokens
+        + skillTokens
+        + reasoningTokens
+        + codeBlockTokens
+        + verificationTokens
+        + reserve;
     return {
         totalTokens,
-        prompt: Math.min(1200, Math.max(200, Math.ceil(String(task.goal ?? '').length / 4))),
-        memory: Math.min(2400, Math.max(300, (run.backendEvidence?.memory?.recalled?.length ?? 0) * 300)),
-        repo: Math.max(0, totalTokens),
+        prompt: promptTokens,
+        memory: memoryTokens,
+        repo: Math.max(0, repoTokens),
         graph: run.knowledgeFabric ? 800 : 0,
         runtime: run.executionLedger ? 600 : 0,
         skills: skillTokens,
-        reserve: Math.max(500, Math.ceil(totalTokens * 0.1)),
+        reasoning: reasoningTokens,
+        codeBlocks: codeBlockTokens,
+        verification: verificationTokens,
+        reserve,
+        codeBlockPolicy: {
+            detectedBlocks,
+            templateBlocks,
+            reservedTokens: codeBlockTokens,
+            languages: languages.length ? languages : ['markdown', 'text'],
+            templates: [
+                'work-packet',
+                'implementation-notes',
+                'verification-output',
+                'memory-writeback',
+            ].slice(0, templateBlocks),
+        },
     };
 }
 export function buildSelectionPlan(input) {

package/dist/engines/orchestrator/funnel.js

@@ -75,8 +75,15 @@ export function categoryFilter(items, intent, kind) {
  * the command-bar strip progress indicator.
  */
 export function emitFunnelStage(payload) {
-    nexusEventBus.emit('orchestrator.funnel.stage', {
+    const eventPayload = {
         ...payload,
         at: payload.at ?? new Date().toISOString(),
+    };
+    const handle = setImmediate(() => {
+        try {
+            nexusEventBus.emit('orchestrator.funnel.stage', eventPayload);
+        }
+        catch { /* funnel telemetry must not block orchestration */ }
     });
+    handle.unref?.();
 }

package/dist/engines/orchestrator/scoring.d.ts

@@ -23,7 +23,7 @@ export declare function decideWorkers(requestedWorkers: number | undefined, plan
  * (previously read from `this.sessionState.repeatedFailures`).
  */
 export declare function determineMode(intent: AutonomyIntent, phaseCount: number, workers: number, repeatedFailures: number): RuntimeOrchestrationSnapshot['mode'];
-export declare function toSourceAwareTokenBudget(knowledgeFabric: KnowledgeFabricBundle, _selectedFiles: string[], reason: string): RuntimeSourceAwareTokenBudgetSnapshot;
+export declare function toSourceAwareTokenBudget(knowledgeFabric: KnowledgeFabricBundle, selectedFiles: string[], reason: string, task?: string): RuntimeSourceAwareTokenBudgetSnapshot;
 export declare function toRagCandidateStatus(knowledgeFabric: KnowledgeFabricBundle): SessionBootstrapResult['ragCandidateStatus'];
 export declare function toRagUsageSummary(knowledgeFabric: KnowledgeFabricBundle, usage: {
     usedInPlanner: boolean;

package/dist/engines/orchestrator/scoring.js

@@ -81,7 +81,7 @@ export function decomposeTask(task) {
         .filter(Boolean)
         .join(' ');
     const subtasks = normalized
-        .split(/,| then | and then | after that | followed by | also /i)
+        .split(/\s*(?:[.;,]|\band\s+then\b|\bthen\b|\bafter\s+that\b|\bfollowed\s+by\b|\balso\b)\s*/i)
         .map((segment) => segment.trim())
         .filter(Boolean);
     return subtasks.length > 0 ? subtasks : [task];
@@ -325,7 +325,13 @@ export function determineMode(intent, phaseCount, workers, repeatedFailures) {
     return 'single-pass';
 }
 // ─── Token budget / RAG ────────────────────────────────────────────────────────
-export function toSourceAwareTokenBudget(knowledgeFabric, _selectedFiles, reason) {
+export function toSourceAwareTokenBudget(knowledgeFabric, selectedFiles, reason, task = '') {
+    const detectedBlocks = Math.floor((task.match(/```/g) ?? []).length / 2);
+    const requested = detectedBlocks > 0 || /(code blocks?|template|patch|diff|snippet|implementation|verification|memory write)/i.test(task);
+    const templates = requested
+        ? ['work-packet', 'implementation-notes', 'verification-output', 'memory-writeback']
+        : ['verification-output', 'memory-writeback'];
+    const languages = [...new Set([...task.matchAll(/```([a-z0-9_-]+)/gi)].map((match) => match[1]))].slice(0, 8);
     return {
         applied: true,
         reason,
@@ -334,6 +340,22 @@ export function toSourceAwareTokenBudget(knowledgeFabric, _selectedFiles, reason
         byStage: knowledgeFabric.tokenBudget.byStage,
         dropped: knowledgeFabric.tokenBudget.dropped,
         dominantSource: knowledgeFabric.sourceMix.dominantSource,
+        codeBlocks: {
+            requested,
+            detectedBlocks,
+            reservedTokens: Math.min(2400, Math.max(360, detectedBlocks * 320 + templates.length * 220)),
+            templates,
+            languages: languages.length ? languages : ['markdown', 'text'],
+        },
+        qualityGates: [
+            'quote selected files and symbols before reading broadly',
+            'use code blocks for work packets, patches, verification, and memory write-back',
+            selectedFiles.length > 2 ? 'run token optimization before reading selected files' : 'keep single-file reads direct and cheap',
+        ],
+        recommendations: [
+            'Route exploration to cheap lanes, keep implementation and integration on the primary coding model.',
+            'Treat no-diff mutate runs as advisory inspected outcomes unless a binding promised a patch.',
+        ],
     };
 }
 export function toRagCandidateStatus(knowledgeFabric) {

package/dist/engines/orchestrator.d.ts

@@ -48,6 +48,8 @@ export declare class OrchestratorEngine {
     private workflowCatalogCache?;
     private hookCatalogCache?;
     private automationCatalogCache?;
+    private clientSnapshotCache?;
+    private readonly CLIENT_SNAPSHOT_CACHE_TTL_MS;
     private readonly specialistCatalogItems;
     private readonly crewCatalogItems;
     private crGraphClient?;
@@ -137,6 +139,7 @@ export declare class OrchestratorEngine {
     private pruneStaleAutonomySessions;
     private resolvePrimaryClient;
     private listDetectedClients;
+    private getClientSnapshot;
     private detectCurrentClientFromEnv;
     private toClientSnapshot;
     private toRuntimeOrchestrationSnapshot;