cognitive-core 0.2.5 → 0.3.1

package/dist/runtime/manager.js

@@ -1,65 +1,276 @@
-import { createTrajectory, createStep, successOutcome, failureOutcome, } from '../types/index.js';
+import { createTrajectory, createStep, successOutcome, failureOutcome } from '../types/index.js';
 import { DefaultComputeProvider } from './compute-provider.js';
+import { sectionGuidanceForTask } from '../memory/playbook-incorporation.js';
+/**
+ * Build a compact action recipe from an experience's stored steps, ReMem-style
+ * ("a → b → c").
+ *
+ * Why this exists: `solutionOutput` is a transcript/answer blob whose first 300
+ * chars (the slice the injector shows) are usually the *initial observation*,
+ * not the actions taken — useless for imitation on procedural tasks. The action
+ * sequence IS preserved in `experience.metadata.steps`; this surfaces it so a
+ * retrieved successful trajectory actually teaches the agent the recipe.
+ */
+export function experienceActionRecipe(experience, maxActions = 8) {
+    const steps = experience.metadata?.steps;
+    if (!Array.isArray(steps))
+        return undefined;
+    const actions = steps
+        .map((s) => (typeof s.action === 'string' ? s.action.trim() : ''))
+        // Drop empty actions and the interactive-env "reset" pseudo-step.
+        .filter((a) => a.length > 0 && a.toLowerCase() !== 'reset');
+    if (actions.length < 2)
+        return undefined;
+    const shown = actions.slice(0, maxActions);
+    const more = actions.length > maxActions ? ` … (${actions.length} steps total)` : '';
+    return shown.join(' → ') + more;
+}
+/**
+ * Return a new array with duplicate strings removed (preserves first occurrence).
+ * Used to deduplicate situations + triggers before injection.
+ */
+function deduped(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item))
+            return false;
+        seen.add(item);
+        return true;
+    });
+}
 /**
  * Default knowledge injector - formats memory for context injection
  */
 export class DefaultKnowledgeInjector {
+    /**
+     * Cap how many playbooks / experiences are injected. The router returns them
+     * score-sorted, so we keep the top-N; injecting every match is token-heavy and
+     * noisy (e.g. all 6 ALFWorld recipe playbooks at once). ReMem caps exemplars
+     * at ~4; defaults here are similar.
+     */
+    static DEFAULT_MAX_PLAYBOOKS = 3;
+    static DEFAULT_MAX_EXPERIENCES = 4;
+    /** PR-D2: whether to re-rank playbooks by helpfulness prior before capping. */
+    _curationEnabled = true;
+    /** F1: whether to surface applicability conditions at injection time. */
+    _injectApplicability = true;
+    /** F5: whether to emit the use-time relevance-gating instruction. */
+    _relevanceGating = true;
+    /** Exp 4: how playbooks are rendered — 'full' or 'sectioned' (task-relevant subset). */
+    _incorporation = 'full';
+    /**
+     * Enable/disable helpfulness-weighted injection re-rank (PR-D2).
+     * When false, raw cosine-score order is used (append-only ablation).
+     */
+    setCurationEnabled(enabled) {
+        this._curationEnabled = enabled;
+    }
+    /**
+     * Enable/disable applicability injection (F1).
+     * When true (default), "Apply when:" / "Do NOT apply when:" lines are
+     * included in the injected playbook block.  Set false to reproduce old
+     * behavior (ablation arm: no-applicability-injection).
+     */
+    setInjectApplicability(enabled) {
+        this._injectApplicability = enabled;
+    }
+    /** Exp 4: select playbook incorporation mode ('full' | 'sectioned'). */
+    setIncorporation(mode) {
+        this._incorporation = mode;
+    }
+    /**
+     * Enable/disable use-time relevance-gating instruction (F5).
+     * When true (default), a one-line instruction telling the agent to
+     * self-filter candidates against their "Apply when:" / "Do NOT apply when:"
+     * conditions is prepended to the Candidate Playbooks section.  Only emitted
+     * when there is ≥1 candidate playbook AND injectApplicability is on.
+     * Set false to reproduce old behavior (ablation arm: no-relevance-gating).
+     */
+    setRelevanceGating(enabled) {
+        this._relevanceGating = enabled;
+    }
+    /**
+     * Laplace-smoothed helpfulness prior: (successCount+1)/(successCount+failureCount+2).
+     * Range [0.5, 1.0) for observed playbooks; 0.5 for cold-start (no observations).
+     */
+    static helpfulnessPrior(successCount, failureCount) {
+        return (successCount + 1) / (successCount + failureCount + 2);
+    }
     format(knowledge, _agentType, options) {
         const format = options?.format ?? 'markdown';
+        const maxPlaybooks = options?.maxPlaybooks ?? DefaultKnowledgeInjector.DEFAULT_MAX_PLAYBOOKS;
+        // PR-D2: re-rank by cosineScore * helpfulnessPrior before capping.
+        // When curation is disabled, keep raw cosine order.
+        let rankedPlaybooks = knowledge.playbooks;
+        if (this._curationEnabled && rankedPlaybooks.length > 1) {
+            rankedPlaybooks = [...rankedPlaybooks].sort((a, b) => {
+                const priorA = DefaultKnowledgeInjector.helpfulnessPrior(a.playbook.evolution.successCount, a.playbook.evolution.failureCount);
+                const priorB = DefaultKnowledgeInjector.helpfulnessPrior(b.playbook.evolution.successCount, b.playbook.evolution.failureCount);
+                return b.score * priorB - a.score * priorA;
+            });
+        }
+        // Cap to top-N (lists are already score-sorted by the router).
+        const capped = {
+            ...knowledge,
+            playbooks: rankedPlaybooks.slice(0, maxPlaybooks),
+            experiences: knowledge.experiences.slice(0, options?.maxExperiences ?? DefaultKnowledgeInjector.DEFAULT_MAX_EXPERIENCES),
+        };
         if (format === 'json') {
-            return JSON.stringify(knowledge, null, 2);
+            return JSON.stringify(capped, null, 2);
         }
         if (format === 'xml') {
-            return this.formatXml(knowledge);
+            return this.formatXml(capped, options?.conventions, options?.query);
         }
-        return this.formatMarkdown(knowledge);
+        return this.formatMarkdown(capped, options?.conventions, options?.query);
     }
-    formatMarkdown(knowledge) {
+    /**
+     * Resolve the guidance to render for a playbook under the active incorporation
+     * mode: full guidance, or only the task-relevant tactics/steps when
+     * 'sectioned' and a query is available (Exp 4).
+     */
+    guidanceFor(playbook, query) {
+        if (this._incorporation === 'sectioned' && query) {
+            const s = sectionGuidanceForTask(playbook, query);
+            return { strategy: s.strategy, tactics: s.tactics, steps: s.steps };
+        }
+        return {
+            strategy: playbook.guidance.strategy,
+            tactics: playbook.guidance.tactics,
+            steps: playbook.guidance.steps ?? [],
+        };
+    }
+    /**
+     * Format binding conventions as a must-follow section (PR-D3).
+     * Binding conventions (binding: true) render under "## Conventions (must follow)".
+     * Advisory conventions (binding: false) are omitted from this section.
+     */
+    formatConventions(conventions) {
+        const binding = conventions.filter((n) => n.frontmatter.binding === true);
+        if (binding.length === 0)
+            return '';
+        const lines = ['## Conventions (must follow)\n'];
+        for (const note of binding) {
+            // Extract the convention text from the body (skip heading lines)
+            const bodyLines = note.body.split('\n');
+            const conventionLine = bodyLines.find((l) => l.trim().length > 0 && !l.startsWith('#')) ?? note.body.slice(0, 200);
+            const scope = note.frontmatter.scope ?? 'global';
+            lines.push(`- [${scope}] ${conventionLine.trim()}`);
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+    formatMarkdown(knowledge, conventions, query) {
         const sections = [];
+        // PR-D3: Binding conventions go first, in a dedicated must-follow section
+        if (conventions && conventions.length > 0) {
+            const conventionSection = this.formatConventions(conventions);
+            if (conventionSection)
+                sections.push(conventionSection);
+        }
         if (knowledge.playbooks.length > 0) {
-            sections.push('## Applicable Playbooks\n');
+            sections.push('## Candidate Playbooks (apply only if the conditions match the current task)\n');
+            // F5: relevance-gating instruction — only when applicability conditions
+            // are also being surfaced (so the agent has the criteria to check against).
+            if (this._injectApplicability && this._relevanceGating) {
+                sections.push('> Before using any candidate below, check its **Apply when** / **Do NOT apply when** against the CURRENT task. Use a candidate ONLY if its conditions clearly match; if none match, rely on your own judgment and ignore them. Treat these as fallible hints from past tasks, not instructions.\n');
+            }
             for (const { playbook, score, matchType } of knowledge.playbooks) {
                 sections.push(`### ${playbook.name} (${(score * 100).toFixed(0)}% match via ${matchType})`);
-                sections.push(`**Strategy:** ${playbook.guidance.strategy}`);
-                if (playbook.guidance.tactics.length > 0) {
-                    sections.push(`**Tactics:** ${playbook.guidance.tactics.join(', ')}`);
+                // F1: "Apply when:" from situations + triggers (deduped, token-aware)
+                if (this._injectApplicability && playbook.applicability) {
+                    const applyWhen = deduped([
+                        ...(playbook.applicability.situations ?? []),
+                        ...(playbook.applicability.triggers ?? []),
+                    ]);
+                    if (applyWhen.length > 0) {
+                        sections.push(`**Apply when:** ${applyWhen.join('; ')}`);
+                    }
+                    const antiPatterns = playbook.applicability.antiPatterns ?? [];
+                    if (antiPatterns.length > 0) {
+                        sections.push(`**Do NOT apply when:** ${antiPatterns.join('; ')}`);
+                    }
                 }
-                if (playbook.guidance.steps && playbook.guidance.steps.length > 0) {
+                const g = this.guidanceFor(playbook, query);
+                sections.push(`**Strategy:** ${g.strategy}`);
+                if (g.tactics.length > 0) {
+                    sections.push(`**Tactics:** ${g.tactics.join(', ')}`);
+                }
+                if (g.steps.length > 0) {
                     sections.push('**Steps:**');
-                    playbook.guidance.steps.forEach((step, i) => {
+                    g.steps.forEach((step, i) => {
                         sections.push(`${i + 1}. ${step}`);
                     });
                 }
-                sections.push(`*Confidence: ${(playbook.confidence * 100).toFixed(0)}%*\n`);
+                // F3(b): omit raw confidence % — it is an internal ranking signal, not
+                // agent-facing guidance.  A low number (e.g. "25%") undermines good items.
+                sections.push('');
             }
         }
         if (knowledge.experiences.length > 0) {
             sections.push('## Similar Past Experiences\n');
             for (const { experience, score } of knowledge.experiences) {
-                sections.push(`### Experience (relevance: ${(score * 100).toFixed(0)}%)`);
-                sections.push(`**Task:** ${experience.taskInput.slice(0, 200)}...`);
-                sections.push(`**Outcome:** ${experience.success ? 'Success' : 'Failed'}`);
-                sections.push(`**Approach:** ${experience.solutionOutput.slice(0, 300)}...`);
+                sections.push(`### Experience (relevance: ${(score * 100).toFixed(0)}%) — ${experience.success ? 'Success' : 'Failed'}`);
+                sections.push(`**Task:** ${experience.taskInput.slice(0, 200)}`);
+                // Prefer the action recipe (what to imitate); fall back to the solution
+                // summary only when there's no usable step sequence (e.g. QA answers).
+                const recipe = experienceActionRecipe(experience);
+                if (recipe) {
+                    sections.push(`**Actions:** ${recipe}`);
+                }
+                else {
+                    sections.push(`**Approach:** ${experience.solutionOutput.slice(0, 300)}`);
+                }
                 sections.push('');
             }
         }
         return sections.join('\n');
     }
-    formatXml(knowledge) {
+    formatXml(knowledge, conventions, query) {
         const parts = ['<atlas-knowledge>'];
+        // PR-D3: Binding conventions in XML
+        const bindingConventions = conventions?.filter((n) => n.frontmatter.binding === true) ?? [];
+        if (bindingConventions.length > 0) {
+            parts.push('  <conventions binding="true">');
+            for (const note of bindingConventions) {
+                const scope = note.frontmatter.scope ?? 'global';
+                const bodyLines = note.body.split('\n');
+                const text = bodyLines.find((l) => l.trim().length > 0 && !l.startsWith('#')) ?? '';
+                parts.push(`    <convention scope="${scope}">${this.escapeXml(text.trim())}</convention>`);
+            }
+            parts.push('  </conventions>');
+        }
         if (knowledge.playbooks.length > 0) {
             parts.push('  <playbooks>');
+            // F5: relevance-gating note in XML — mirrors the markdown instruction.
+            if (this._injectApplicability && this._relevanceGating) {
+                parts.push('    <relevanceGuidance>Before using any candidate below, check its applyWhen / doNotApplyWhen against the CURRENT task. Use a candidate ONLY if its conditions clearly match; if none match, rely on your own judgment and ignore them.</relevanceGuidance>');
+            }
             for (const { playbook, score } of knowledge.playbooks) {
                 parts.push(`    <playbook name="${this.escapeXml(playbook.name)}" relevance="${score.toFixed(2)}">`);
-                parts.push(`      <strategy>${this.escapeXml(playbook.guidance.strategy)}</strategy>`);
-                if (playbook.guidance.steps && playbook.guidance.steps.length > 0) {
+                // F1: applicability conditions in XML
+                if (this._injectApplicability && playbook.applicability) {
+                    const applyWhen = deduped([
+                        ...(playbook.applicability.situations ?? []),
+                        ...(playbook.applicability.triggers ?? []),
+                    ]);
+                    if (applyWhen.length > 0) {
+                        parts.push(`      <applyWhen>${this.escapeXml(applyWhen.join('; '))}</applyWhen>`);
+                    }
+                    const antiPatterns = playbook.applicability.antiPatterns ?? [];
+                    if (antiPatterns.length > 0) {
+                        parts.push(`      <doNotApplyWhen>${this.escapeXml(antiPatterns.join('; '))}</doNotApplyWhen>`);
+                    }
+                }
+                const gx = this.guidanceFor(playbook, query);
+                parts.push(`      <strategy>${this.escapeXml(gx.strategy)}</strategy>`);
+                if (gx.steps.length > 0) {
                     parts.push('      <steps>');
-                    playbook.guidance.steps.forEach((step, i) => {
+                    gx.steps.forEach((step, i) => {
                         parts.push(`        <step n="${i + 1}">${this.escapeXml(step)}</step>`);
                     });
                     parts.push('      </steps>');
                 }
-                parts.push(`      <confidence>${playbook.confidence}</confidence>`);
+                // F3(b): omit <confidence> from agent-facing XML (internal signal only).
                 parts.push('    </playbook>');
             }
             parts.push('  </playbooks>');
@@ -70,6 +281,9 @@ export class DefaultKnowledgeInjector {
                 parts.push(`    <experience relevance="${score.toFixed(2)}">`);
                 parts.push(`      <task>${this.escapeXml(experience.taskInput.slice(0, 200))}</task>`);
                 parts.push(`      <outcome>${experience.success ? 'success' : 'failure'}</outcome>`);
+                const recipe = experienceActionRecipe(experience);
+                if (recipe)
+                    parts.push(`      <actions>${this.escapeXml(recipe)}</actions>`);
                 parts.push('    </experience>');
             }
             parts.push('  </experiences>');
@@ -133,8 +347,7 @@ export class DefaultTrajectoryExtractor {
         const toolCallTime = toolCall.startTime.getTime();
         const precedingMessages = messages.filter((m) => m.role === 'assistant' &&
             m.timestamp.getTime() < toolCallTime &&
-            m.timestamp.getTime() > toolCallTime - 60000 // Within 1 minute
-        );
+            m.timestamp.getTime() > toolCallTime - 60000);
         if (precedingMessages.length > 0) {
             const lastMessage = precedingMessages[precedingMessages.length - 1];
             // Extract reasoning/thought from the message
@@ -177,6 +390,7 @@ export class AgentManager {
     observers = [];
     activeSessions = new Map();
     delegate;
+    diagnosticsCollector;
     constructor(memory, options) {
         this.memory = memory;
         this.injector = options?.injector ?? new DefaultKnowledgeInjector();
@@ -244,6 +458,53 @@ export class AgentManager {
     clearDelegate() {
         this.delegate = undefined;
     }
+    /**
+     * Attach (or detach) a diagnostics collector that receives retrieval +
+     * injection snapshots from each spawnViaDelegate call. Pass `undefined`
+     * to detach. Has no effect when the delegate is not set.
+     */
+    setDiagnosticsCollector(collector) {
+        this.diagnosticsCollector = collector;
+    }
+    /**
+     * PR-D2: Enable/disable helpfulness-weighted playbook re-rank in the injector.
+     * Delegates to DefaultKnowledgeInjector.setCurationEnabled() when the injector
+     * is the default implementation; no-ops for custom injectors.
+     */
+    setCurationEnabled(enabled) {
+        if (this.injector instanceof DefaultKnowledgeInjector) {
+            this.injector.setCurationEnabled(enabled);
+        }
+    }
+    /**
+     * F1: Enable/disable applicability injection (situations + antiPatterns).
+     * Delegates to DefaultKnowledgeInjector.setInjectApplicability() when the
+     * injector is the default implementation; no-ops for custom injectors.
+     */
+    setInjectApplicability(enabled) {
+        if (this.injector instanceof DefaultKnowledgeInjector) {
+            this.injector.setInjectApplicability(enabled);
+        }
+    }
+    /**
+     * F5: Enable/disable use-time relevance-gating instruction.
+     * Delegates to DefaultKnowledgeInjector.setRelevanceGating() when the
+     * injector is the default implementation; no-ops for custom injectors.
+     */
+    setRelevanceGating(enabled) {
+        if (this.injector instanceof DefaultKnowledgeInjector) {
+            this.injector.setRelevanceGating(enabled);
+        }
+    }
+    /**
+     * Exp 4: select playbook incorporation mode ('full' | 'sectioned').
+     * Delegates to DefaultKnowledgeInjector; no-ops for custom injectors.
+     */
+    setIncorporation(mode) {
+        if (this.injector instanceof DefaultKnowledgeInjector) {
+            this.injector.setIncorporation(mode);
+        }
+    }
     /**
      * Get the current delegate, if any.
      */
@@ -255,48 +516,51 @@ export class AgentManager {
      * This is the main entry point for running agents
      */
     async spawn(config) {
+        const diagnosticKnowledge = config.diagnosticKnowledge;
+        const configForSpawn = stripDiagnosticKnowledge(config);
         // Use delegate if available (bypasses backend resolution)
         if (this.delegate) {
-            return this.spawnViaDelegate(config);
+            return this.spawnViaDelegate(configForSpawn, diagnosticKnowledge);
         }
         // Resolve compute target via provider
-        const target = await this.computeProvider.resolve(config.agentType, config.computeRequirements);
+        const target = await this.computeProvider.resolve(configForSpawn.agentType, configForSpawn.computeRequirements);
         const backend = target.backend;
         // Merge any overrides from compute resolution
+        let runtimeConfig = configForSpawn;
         if (target.overrides) {
-            config = { ...config, ...target.overrides };
+            runtimeConfig = stripDiagnosticKnowledge({ ...runtimeConfig, ...target.overrides });
         }
         // Query memory for relevant knowledge if not provided
-        let knowledge = config.injectedKnowledge;
+        let knowledge = runtimeConfig.injectedKnowledge;
         if (!knowledge) {
-            knowledge = await this.memory.queryV2(config.task.description, {
-                domains: config.task.domain ? [config.task.domain] : undefined,
+            knowledge = await this.memory.queryV2(runtimeConfig.task.description, {
+                domains: runtimeConfig.task.domain ? [runtimeConfig.task.domain] : undefined,
             });
         }
         // Format knowledge for injection
-        const formattedKnowledge = this.injector.format(knowledge, config.agentType);
+        const formattedKnowledge = this.injector.format(knowledge, runtimeConfig.agentType, {
+            query: runtimeConfig.task?.description,
+        });
         // Use a session holder to allow callbacks to reference the session
         // before it's assigned (closures capture the holder object, not the value)
         const sessionHolder = { current: null };
         // Build full config with knowledge injection
         const fullConfig = {
-            ...config,
+            ...runtimeConfig,
             systemPromptAdditions: [
-                config.systemPromptAdditions,
-                formattedKnowledge
-                    ? `\n## Atlas Knowledge\n${formattedKnowledge}`
-                    : undefined,
+                runtimeConfig.systemPromptAdditions,
+                formattedKnowledge ? `\n## Atlas Knowledge\n${formattedKnowledge}` : undefined,
             ]
                 .filter(Boolean)
                 .join('\n\n'),
             onMessage: (message) => {
-                config.onMessage?.(message);
+                runtimeConfig.onMessage?.(message);
                 if (sessionHolder.current) {
                     this.notifyMessage(sessionHolder.current, message);
                 }
             },
             onToolCall: (toolCall) => {
-                config.onToolCall?.(toolCall);
+                runtimeConfig.onToolCall?.(toolCall);
                 if (sessionHolder.current) {
                     this.notifyToolCall(sessionHolder.current, toolCall);
                 }
@@ -310,7 +574,7 @@ export class AgentManager {
         // Wait for completion and extract trajectory
         const finalSession = await this.waitForCompletion(backend, session.id);
         this.activeSessions.delete(session.id);
-        const trajectory = this.extractor.extract(finalSession, config.task);
+        const trajectory = this.extractor.extract(finalSession, runtimeConfig.task);
         this.notifySessionEnd(finalSession, trajectory);
         return {
             session: finalSession,
@@ -329,7 +593,7 @@ export class AgentManager {
      * Spawn via caller-provided delegate.
      * Handles knowledge injection, builds trajectory, notifies observers.
      */
-    async spawnViaDelegate(config) {
+    async spawnViaDelegate(config, diagnosticKnowledge) {
         const startTime = new Date();
         // Query memory for relevant knowledge if not provided
         let knowledge = config.injectedKnowledge;
@@ -339,38 +603,81 @@ export class AgentManager {
             });
         }
         // Format knowledge for injection
-        const formattedKnowledge = this.injector.format(knowledge, 'delegate');
+        const formattedKnowledge = this.injector.format(knowledge, 'delegate', {
+            query: config.task?.description,
+        });
+        // Diagnostics hook: capture retrieval + injection snapshot before the delegate call.
+        if (this.diagnosticsCollector) {
+            // Derive counts from the capped knowledge that the injector actually serialized.
+            const cappedPlaybooks = knowledge.playbooks.slice(0, DefaultKnowledgeInjector.DEFAULT_MAX_PLAYBOOKS);
+            const cappedExperiences = knowledge.experiences.slice(0, DefaultKnowledgeInjector.DEFAULT_MAX_EXPERIENCES);
+            this.diagnosticsCollector({
+                knowledge: diagnosticKnowledge ?? knowledge,
+                formattedKnowledge,
+                playbookCount: cappedPlaybooks.length,
+                experienceCount: cappedExperiences.length,
+                threshold: 0,
+            });
+        }
         // Build system context from prompt additions + formatted knowledge
         const systemContext = [
             config.systemPromptAdditions,
-            formattedKnowledge
-                ? `\n## Atlas Knowledge\n${formattedKnowledge}`
-                : undefined,
+            formattedKnowledge ? `\n## Atlas Knowledge\n${formattedKnowledge}` : undefined,
         ]
             .filter(Boolean)
             .join('\n\n') || undefined;
+        // Isolated replay rollout: drive the (stateful) delegate off THIS config's
+        // task and snapshot its mutable accounting so the rollout can't corrupt the
+        // solve path. Stateful benchmark delegates run off an internal `currentTask`
+        // and accumulate `totalCostUsd`; a live-replay rollout must (a) point the
+        // delegate at the experience being judged — not the last-solved task — and
+        // (b) leave both untouched afterward. Feature-detected so plain delegates
+        // (which have no such state to corrupt) are unaffected.
+        const statefulDelegate = this.delegate;
+        const isolateReplay = !!config.replay;
+        const savedTask = isolateReplay ? statefulDelegate.getCurrentTask?.() : undefined;
+        const savedCost = isolateReplay ? statefulDelegate.getTotalCostUsd?.() : undefined;
+        if (isolateReplay) {
+            statefulDelegate.setCurrentTask?.(config.task);
+        }
         // Call the delegate
-        const result = await this.delegate.execute(config.task.description, {
-            cwd: config.cwd ?? process.cwd(),
-            systemContext,
-            timeoutMs: config.timeout,
-        });
+        let result;
+        try {
+            result = await this.delegate.execute(config.task.description, {
+                cwd: config.cwd ?? process.cwd(),
+                systemContext,
+                injectedKnowledge: knowledge,
+                timeoutMs: config.timeout,
+            });
+        }
+        finally {
+            if (isolateReplay) {
+                // Restore in reverse: cost first (drop the rollout's spend), then the
+                // solve path's task. Guarded by the pre-call reads so we never fabricate
+                // state on a delegate that doesn't expose these hooks.
+                if (savedCost !== undefined)
+                    statefulDelegate.setTotalCostUsd?.(savedCost);
+                if (savedTask !== undefined)
+                    statefulDelegate.setCurrentTask?.(savedTask);
+            }
+        }
         const endTime = new Date();
         // Build trajectory — use delegate's if provided, otherwise build minimal
-        const trajectory = result.trajectory ?? createTrajectory({
-            task: config.task,
-            steps: [
-                createStep({
-                    action: 'delegate_execution',
-                    observation: result.output,
-                }),
-            ],
-            outcome: result.success
-                ? successOutcome(result.structured ?? result.output)
-                : failureOutcome(result.output),
-            agentId: 'delegate',
-            wallTimeSeconds: (endTime.getTime() - startTime.getTime()) / 1000,
-        });
+        const trajectory = result.trajectory ??
+            createTrajectory({
+                task: config.task,
+                steps: [
+                    createStep({
+                        action: 'delegate_execution',
+                        observation: result.output,
+                    }),
+                ],
+                outcome: result.success
+                    ? successOutcome(result.structured ?? result.output)
+                    : failureOutcome(result.output),
+                agentId: 'delegate',
+                wallTimeSeconds: (endTime.getTime() - startTime.getTime()) / 1000,
+            });
         // Build session for observer compatibility
         const session = {
             id: crypto.randomUUID(),
@@ -492,13 +799,13 @@ export class AgentManager {
     // Private helpers
     async waitForCompletion(backend, sessionId) {
         // Poll for completion
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             const session = await backend.getSession(sessionId);
             if (!session) {
                 throw new Error(`Session ${sessionId} not found`);
             }
-            if (session.state === 'completed' ||
-                session.state === 'failed') {
+            if (session.state === 'completed' || session.state === 'failed') {
                 return session;
             }
             // Wait before polling again
@@ -526,6 +833,10 @@ export class AgentManager {
         }
     }
 }
+function stripDiagnosticKnowledge(config) {
+    const { diagnosticKnowledge: _diagnosticKnowledge, ...runtimeConfig } = config;
+    return runtimeConfig;
+}
 /**
  * Create an agent manager
  */