@mcp-abap-adt/llm-agent-server-libs 19.2.0 → 20.4.0

package/dist/smart-agent/controller/controller-coordinator-handler.js

@@ -1,55 +1,33 @@
-import { externalToolCallId, } from '@mcp-abap-adt/llm-agent';
+import { externalToolCallId, McpError, } from '@mcp-abap-adt/llm-agent';
 import { summaryToUsage, } from '@mcp-abap-adt/llm-agent-libs';
-import { cosine } from '../embedder-knowledge-index.js';
-import { readClaims, readPlanDecisions, writePlanDecision, } from './artifacts.js';
-import { BoardOverBudgetError, reconstructBoard, renderBoard, } from './board.js';
+import { writePlanDecision } from './artifacts.js';
+import { BoardOverBudgetError, renderLiveBoard, } from './board.js';
 import { writeArtifact } from './memorizer.js';
 import { resolveByPrecedence } from './outcome.js';
-import { makePlanner } from './planner.js';
+import { makeControllerPlanner } from './planner.js';
 import { appendHint } from './prompts.js';
+import { buildRecallBlock, collectApproved, RECALL_ARTIFACT_TYPES, RECALL_EVIDENCE_CHARS, RECALL_K_MCP, RECALL_K_STEP, RECALL_MAX_CHARS_MCP, RECALL_MAX_CHARS_STEP, relevantExtract, runScopedRecall, } from './recall.js';
 import { classifyRequest, readTerminal, writeTerminal } from './run-scope.js';
 import { hydrateBundle, persistBundle, resetRun } from './session-bundle.js';
 import { establishTargetState } from './target-state.js';
-import { validateRequires, } from './types.js';
+import { makeLogUsage } from './usage-logging.js';
 // ---------------------------------------------------------------------------
 // Debug logging — gated behind DEBUG_CONTROLLER (e.g. DEBUG_CONTROLLER=1).
 // Surfaces the steps the planner delegates and per-role/total token usage to
 // stderr, for tuning step granularity and watching token spend. Off by default.
+// (Also in usage-logging.ts — intentional small duplication; no 3rd copy exists.)
 // ---------------------------------------------------------------------------
 function dlog(msg) {
     if (process.env.DEBUG_CONTROLLER)
         console.error(`[controller] ${msg}`);
 }
-/**
- * Build a request-time `logUsage(role, usage)` that writes each subagent call
- * into the per-request `IRequestLogger` (the single aggregator), attributing the
- * role's configured model. The role is explicit at the call site, so the shared
- * planner/finalizer client is attributed correctly. `durationMs: 0` — the seam
- * carries no timing (matches the rag-query precedent).
- */
-export function makeLogUsage(requestLogger, requestId, models) {
-    return (role, u) => {
-        if (!u)
-            return;
-        const model = role === 'finalizer'
-            ? (models.finalizer ?? models.planner)
-            : role === 'reviewer'
-                ? (models.reviewer ?? models.planner)
-                : role === 'embedding'
-                    ? 'embedder'
-                    : (models[role] ?? 'unknown');
-        requestLogger.logLlmCall({
-            component: role,
-            model,
-            promptTokens: u.promptTokens ?? 0,
-            completionTokens: u.completionTokens ?? 0,
-            totalTokens: u.totalTokens ?? 0,
-            durationMs: 0,
-            requestId,
-        });
-        dlog(`tokens ${role}: prompt=${u.promptTokens} completion=${u.completionTokens} total=${u.totalTokens}`);
-    };
-}
+// ---------------------------------------------------------------------------
+// Re-exported for import-path stability (helpers moved to sibling modules).
+// ---------------------------------------------------------------------------
+export { renderLiveBoard } from './board.js';
+export { parseNextStep } from './parser.js';
+export { relevantExtract, runScopedRecall } from './recall.js';
+export { makeLogUsage } from './usage-logging.js';
 // ---------------------------------------------------------------------------
 // Handler
 // ---------------------------------------------------------------------------
@@ -106,7 +84,7 @@ export class ControllerCoordinatorHandler {
         const externalNames = new Set((ctx.externalTools ?? []).map((t) => t.name));
         const isExternalTool = (name) => externalNames.has(name) || (deps.isExternalTool?.(name) ?? false);
         // True for the first planner.next of a turn that resumed an external-tool
-        // result (the result is now in plannerPrivate) → the adaptive planner replans
+        // result (the result is now in plannerPrivate) → the plan-first planner replans
         // with it rather than blindly re-running the suspended step. Set in the
         // external-tool resume branch below.
         let resumedExternal = false;
@@ -187,10 +165,11 @@ export class ControllerCoordinatorHandler {
         }
         // -- Resume from a persisted pending marker -----------------------------
         // Planner is constructed BEFORE the resume preamble: the artifact-first
-        // external-resume adopt below calls planner.commit() to keep the adaptive
+        // external-resume adopt below calls planner.commit() to keep the plan-first
         // planCursor in lockstep with nextSeq. Stateless construction; the main loop
         // reuses this same instance.
-        const planner = makePlanner(deps.config.planner ?? 'incremental', deps.planner, deps.config.subagents.planner?.hint, deps.skillsRecall);
+        const planner = deps.controllerPlanner ??
+            makeControllerPlanner(deps.plannerKind ?? 'smart-executor', deps.planner, deps.config.subagents.planner?.hint, deps.skillsRecall);
         if (bundle.pending?.kind === 'external-tool') {
             const { extId, toolName } = bundle.pending;
             const seq = bundle.inFlightStep?.seq;
@@ -217,7 +196,7 @@ export class ControllerCoordinatorHandler {
                     bundle.pending = undefined;
                     bundle.runState = 'active';
                     // Same commit side effects as settle(), incl. planner.commit() so the
-                    // adaptive planCursor advances with nextSeq.
+                    // plan-first planCursor advances with nextSeq.
                     const mapped = mapOutcome(resolved.status);
                     bundle.lastOutcome = mapped;
                     planner.commit?.(bundle, mapped);
@@ -292,7 +271,7 @@ export class ControllerCoordinatorHandler {
                     externalContinuation = true;
                 }
                 else {
-                    // Legacy path (no inFlightStep — e.g. a seeded adaptive bundle): feed the
+                    // Legacy path (no inFlightStep — e.g. a seeded plan-first bundle): feed the
                     // result via plannerPrivate and let the planner replan.
                     bundle.plannerPrivate += `\n[external tool ${toolName} result] ${result}`;
                     bundle.pending = undefined;
@@ -383,7 +362,7 @@ export class ControllerCoordinatorHandler {
         let planParseRetries = 0;
         // bundle.lastOutcome is the SINGLE source of truth for the last step's
         // outcome — durable, so a resume after a FAILED step replans instead of
-        // repeating it. runStep.settle() sets it; the adaptive replan branch clears it
+        // repeating it. runStep.settle() sets it; the plan-first replan branch clears it
         // once the failure has been consumed into a new plan (so a crash after the
         // replan, or a finalizer retry after an empty replan, does NOT replan again).
         while (bundle.budgets.stepsUsed < cfg.maxSteps) {
@@ -404,7 +383,7 @@ export class ControllerCoordinatorHandler {
                 })));
                 if (resolved) {
                     // Already committed → adopt, do NOT re-run. Same commit side effects as
-                    // settle(), including planner.commit() so the adaptive planCursor advances
+                    // settle(), including planner.commit() so the plan-first planCursor advances
                     // in lockstep with nextSeq.
                     const mapped = mapOutcome(resolved.status);
                     bundle.lastOutcome = mapped;
@@ -450,7 +429,7 @@ export class ControllerCoordinatorHandler {
             }
             // Planner crash-guard: a prior crash mid-call left plannerCallInFlight set →
             // charge plannerResumeCount; exhausting maxPlannerResumes is a TERMINAL abort
-            // (store-first). The adaptive replan runs through planner.next too, so this one
+            // (store-first). The plan-first replan runs through planner.next too, so this one
             // guard covers the awaiting-replan replan with no separate site.
             if (bundle.plannerCallInFlight) {
                 bundle.plannerResumeCount = (bundle.plannerResumeCount ?? 0) + 1;
@@ -505,8 +484,8 @@ export class ControllerCoordinatorHandler {
             // NB: do NOT reset resumedExternal here — if this replan reply was malformed
             // (next === null), the parse-retry below must keep replanning. It is reset
             // only after a VALID decision (beside planParseRetries = 0;).
-            // The adaptive planner mutates bundle.plan/planCursor in next(); persist so
-            // a stateless resume continues from the same point. (No-op for incremental.)
+            // The plan-first planner mutates bundle.plan/planCursor in next(); persist so
+            // a stateless resume continues from the same point. (No-op for a planner without plan-state.)
             await persistBundle(deps.backend, sessionId, bundle);
             // Format failure (not valid NextStep JSON) → re-ask the planner with a
             // stern reminder, bounded by maxRetries. This does NOT touch rewindsUsed:
@@ -522,7 +501,7 @@ export class ControllerCoordinatorHandler {
             resumedExternal = false; // a valid decision consumed any external-resume replan
             if (next.kind === 'done') {
                 // Pass next.result as the legacy answer: used only when no finalizer is
-                // injected (3-role config) — the adaptive planner already composed it.
+                // injected (3-role config) — the plan-first planner already composed it.
                 return this.finalize(ctx, sessionId, bundle, rag, prompt, logUsage, usageNow, now, terminalTtlMs, next.result);
             }
             if (next.kind === 'rewind') {
@@ -823,7 +802,32 @@ export class ControllerCoordinatorHandler {
                 bundle.plannerPrivate += `\n[step ${step.name} failed] empty tool call`;
                 return settle('failed');
             }
-            const call = toLlmToolCall(firstCall);
+            // Normalize the StreamToolCall (full or delta) into an LlmToolCall inline.
+            const call = 'arguments' in firstCall &&
+                typeof firstCall.arguments === 'object' &&
+                firstCall.arguments !== null
+                ? {
+                    id: ('id' in firstCall && firstCall.id) || 'call',
+                    name: ('name' in firstCall && firstCall.name) || '',
+                    arguments: firstCall.arguments,
+                }
+                : (() => {
+                    let iArgs = {};
+                    const raw = 'arguments' in firstCall ? firstCall.arguments : undefined;
+                    if (typeof raw === 'string' && raw.length > 0) {
+                        try {
+                            iArgs = JSON.parse(raw);
+                        }
+                        catch {
+                            iArgs = {};
+                        }
+                    }
+                    return {
+                        id: ('id' in firstCall && firstCall.id) || 'call',
+                        name: ('name' in firstCall && firstCall.name) || '',
+                        arguments: iArgs,
+                    };
+                })();
             const name = call.name;
             const args = call.arguments;
             if (isExternalTool(name)) {
@@ -900,7 +904,27 @@ export class ControllerCoordinatorHandler {
                 return settle('failed');
             }
             // Execute locally, memorize, re-send to the executor.
-            const result = await deps.callMcp(name, args);
+            // FAIL LOUD: surface an MCP-unavailable failure as a terminal abort (not a
+            // silent empty response). The bridge (buildMcpBridge) throws an McpError
+            // IFF the injected classifier deemed it 'unavailable'; a tool-level error
+            // is returned as TEXT, never thrown. So ANY McpError reaching this catch is
+            // already a classifier-unavailable verdict — trust that throw-contract
+            // rather than re-checking the code (which would drop a CUSTOM classifier's
+            // decision → rethrow → outer catch swallow → (no response)). A non-McpError
+            // is a genuine unexpected error and is re-thrown for the outer handler.
+            let result;
+            try {
+                result = await deps.callMcp(name, args);
+            }
+            catch (mcpErr) {
+                if (mcpErr instanceof McpError) {
+                    const now = deps.now ?? (() => new Date().toISOString());
+                    const terminalTtlMs = deps.terminalTtlMs ?? 24 * 60 * 60 * 1000;
+                    await this.abortTerminal(ctx, sessionId, bundle, `MCP server unavailable: ${mcpErr.message}`, now, terminalTtlMs, usageNow?.());
+                    return 'aborted';
+                }
+                throw mcpErr;
+            }
             bundle.writeOrdinal = (bundle.writeOrdinal ?? 0) + 1;
             await writeArtifact(rag, {
                 ...meta,
@@ -959,7 +983,7 @@ export class ControllerCoordinatorHandler {
         this.surfaceFinal(ctx, `Error: ${error}`, usage);
     }
     async finalize(ctx, sessionId, bundle, rag, prompt, logUsage, usageNow, now, terminalTtlMs, 
-    /** Used ONLY when no finalizer is injected (3-role config): the adaptive
+    /** Used ONLY when no finalizer is injected (3-role config): the plan-first
      *  planner's already-composed done.result. */
     legacyAnswer) {
         const deps = this.deps;
@@ -1003,12 +1027,18 @@ export class ControllerCoordinatorHandler {
         await persistBundle(deps.backend, sessionId, bundle);
         let answer;
         if (deps.finalizer && bundle.runId) {
+            // Recall the skills block ONCE (not per finalize retry — re-embedding on
+            // every attempt is wasteful; the recall is invariant across retries).
+            const skillsBlock = deps.skillsRecall
+                ? await deps.skillsRecall(bundle.goal, ctx.options)
+                : undefined;
             while (answer === undefined) {
                 try {
                     const composed = await deps.finalizer.finalize(bundle.goal, request, approved, {
                         hint: deps.config.subagents.finalizer?.hint,
                         logUsage,
                         log: (m) => dlog(m),
+                        skillsBlock,
                     });
                     // Empty-but-ok finalizer output is a JUDGE failure (spec), not a valid
                     // answer → throw so it retries within maxFinalizeRetries.
@@ -1032,7 +1062,7 @@ export class ControllerCoordinatorHandler {
             }
         }
         else {
-            // Legacy: the adaptive planner already composed the answer in done.result.
+            // Legacy: the plan-first planner already composed the answer in done.result.
             // Prefer the live param, else the durable copy persisted on finalizing-entry.
             answer = legacyAnswer ?? bundle.legacyFinalAnswer ?? '';
         }
@@ -1079,7 +1109,7 @@ export class ControllerCoordinatorHandler {
     }
 }
 // ---------------------------------------------------------------------------
-// Episodic recall tuning
+// Goal-clarification helpers
 // ---------------------------------------------------------------------------
 /** Bare confirmations that, on a goal clarify, commit the evaluator's proposed
  *  target rather than the literal answer. Anything else = a refinement. */
@@ -1110,7 +1140,6 @@ function isAffirmation(answer) {
         .replace(/[.!]+$/, '');
     return AFFIRMATIONS.has(t);
 }
-/** Top-K tools surfaced from toolsRag per planner/step query. */
 /** Agnostic executor system prompt. Domain specifics (e.g. SAP/ABAP fact kinds)
  *  are layered on via `subagents.executor.hint` (see {@link appendHint}). */
 const EXECUTOR_SYSTEM = 'You are the executor. You have tools that read the live target system. ' +
@@ -1123,44 +1152,11 @@ const EXECUTOR_SYSTEM = 'You are the executor. You have tools that read the live
     'if the step asks for a LIST or overview, return the list; do NOT then go and ' +
     'fetch the full details of every listed item unless the step explicitly asks ' +
     'for per-item details.';
+/** Top-K tools surfaced from toolsRag per planner/step query. */
 const TOOL_SELECT_K = 20;
-/** Top-k recalled artifacts injected into the executor context per step. */
-/** Artifact types eligible for recall (excludes the 'controller-bundle' record
- *  that shares the same backend). */
-const RECALL_ARTIFACT_TYPES = ['step-result', 'mcp-result'];
-/** Per-kind recall counts (distinct artifacts kept after dedup + cap). */
-const RECALL_K_STEP = 4;
-const RECALL_K_MCP = 4;
-/** SEPARATE char budgets per kind, so a huge step-result cannot starve MCP context. */
-const RECALL_MAX_CHARS_STEP = 2000;
-const RECALL_MAX_CHARS_MCP = 2000;
-/** Char budget for a single per-`requires` evidence extract handed to the reviewer. */
-const RECALL_EVIDENCE_CHARS = 800;
 // ---------------------------------------------------------------------------
 // Pure helpers
 // ---------------------------------------------------------------------------
-/** Build a bounded "Relevant prior context" block from recalled artifacts under
- *  the given char budget, or undefined when there is nothing to inject. */
-function buildRecallBlock(hits, maxChars) {
-    if (hits.length === 0)
-        return undefined;
-    const parts = [];
-    let used = 0;
-    for (const h of hits) {
-        const c = h.content ?? '';
-        if (c.length === 0)
-            continue;
-        if (used + c.length > maxChars) {
-            parts.push(c.slice(0, maxChars - used));
-            break;
-        }
-        parts.push(c);
-        used += c.length;
-    }
-    if (parts.length === 0)
-        return undefined;
-    return `Relevant prior context:\n${parts.join('\n')}`;
-}
 /** Extract the user prompt from the request's textOrMessages. */
 function extractPrompt(textOrMessages) {
     if (typeof textOrMessages === 'string')
@@ -1171,131 +1167,6 @@ function extractPrompt(textOrMessages) {
     }
     return '';
 }
-/** Parse a planner content string into a NextStep, defensively. */
-/** Parse the planner's reply into a NextStep, tolerating ```json fences and
- *  surrounding prose. Returns null when no valid decision can be extracted — the
- *  caller treats that as a FORMAT error (re-ask the planner), NOT a rewind, so a
- *  badly-formatted reply never silently burns the rewind budget. */
-export function parseNextStep(content) {
-    const json = extractJsonObject(content);
-    if (json === null)
-        return null;
-    try {
-        const obj = JSON.parse(json);
-        if (obj.kind === 'done' && typeof obj.result === 'string')
-            return { kind: 'done', result: obj.result };
-        if (obj.kind === 'rewind' && typeof obj.reason === 'string')
-            return { kind: 'rewind', reason: obj.reason };
-        if (obj.kind === 'next' &&
-            obj.step &&
-            typeof obj.step.name === 'string' &&
-            typeof obj.step.instructions === 'string') {
-            // Validate requires[] so a non-string / empty / oversized reference never
-            // reaches the semantic query / embedder; a malformed value is a parse
-            // failure that drives the existing parse-retry.
-            const req = validateRequires(obj.step.requires);
-            if (req === false)
-                return null;
-            return {
-                kind: 'next',
-                step: {
-                    name: obj.step.name,
-                    instructions: obj.step.instructions,
-                    ...(obj.step.type ? { type: obj.step.type } : {}),
-                    ...(req ? { requires: req } : {}),
-                },
-            };
-        }
-    }
-    catch {
-        // fall through
-    }
-    return null;
-}
-/** Extract the first balanced JSON object from a planner reply, ignoring ```json
- *  fences and prose around it. String-aware (braces inside strings don't count).
- *  Returns null if no balanced object is present. */
-export function extractJsonObject(raw) {
-    const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    const body = fence ? fence[1] : raw;
-    const start = body.indexOf('{');
-    if (start < 0)
-        return null;
-    let depth = 0;
-    let inStr = false;
-    let esc = false;
-    for (let i = start; i < body.length; i++) {
-        const ch = body[i];
-        if (inStr) {
-            if (esc)
-                esc = false;
-            else if (ch === '\\')
-                esc = true;
-            else if (ch === '"')
-                inStr = false;
-            continue;
-        }
-        if (ch === '"')
-            inStr = true;
-        else if (ch === '{')
-            depth++;
-        else if (ch === '}') {
-            depth--;
-            if (depth === 0)
-                return body.slice(start, i + 1);
-        }
-    }
-    return null;
-}
-/** Normalize a StreamToolCall (full or delta) into an LlmToolCall. */
-function toLlmToolCall(c) {
-    if ('arguments' in c &&
-        typeof c.arguments === 'object' &&
-        c.arguments !== null) {
-        // Full LlmToolCall: arguments is already a parsed object.
-        return {
-            id: ('id' in c && c.id) || 'call',
-            name: ('name' in c && c.name) || '',
-            arguments: c.arguments,
-        };
-    }
-    // Delta: arguments is a (possibly partial) JSON string.
-    let args = {};
-    const raw = 'arguments' in c ? c.arguments : undefined;
-    if (typeof raw === 'string' && raw.length > 0) {
-        try {
-            args = JSON.parse(raw);
-        }
-        catch {
-            args = {};
-        }
-    }
-    return {
-        id: ('id' in c && c.id) || 'call',
-        name: ('name' in c && c.name) || '',
-        arguments: args,
-    };
-}
-/** Reconstruct and render the live step-state board from artifacts.
- *  Returns '' when there is no runId (the board has nothing to show yet). */
-async function renderLiveBoard(rag, bundle, budget) {
-    const runId = bundle.runId;
-    if (!runId)
-        return '';
-    const [structure, claims] = await Promise.all([
-        readPlanDecisions(rag, runId),
-        readClaims(rag, runId),
-    ]);
-    const stepResults = await rag.list({ runId, artifactType: 'step-result' });
-    const board = reconstructBoard({
-        structure,
-        stepResults,
-        claims,
-        inFlight: bundle.inFlightStep,
-        pending: bundle.pending,
-    });
-    return renderBoard(board, budget);
-}
 /** Synthesize the strict KnowledgeEntryMetadata for controller artifacts. */
 function synthMeta(ctx, sessionId) {
     const traceId = ctx.options?.trace?.traceId ?? sessionId;
@@ -1327,163 +1198,4 @@ function recordStepControl(bundle, rec) {
             (rec.note ? ` ${rec.note}` : '') +
             (rec.remainder ? ` remainder: ${rec.remainder}` : '');
 }
-/** Gather the run's approved results, one per seq, resolved by outcome precedence
- *  (ok/exists > partial > failed), ordered by seq. Reconstructs the complete
- *  Outcome from artifact metadata (status/note/remainder) + content. */
-async function collectApproved(rag, runId) {
-    const all = await rag.list({ runId, artifactType: 'step-result' });
-    const bySeq = new Map();
-    for (const e of all) {
-        const seq = e.metadata.seq ?? 0;
-        const o = {
-            status: (e.metadata.status ?? 'failed'),
-            approved: e.content,
-            remainder: e.metadata.remainder ?? '',
-            note: e.metadata.note ?? '',
-        };
-        const arr = bySeq.get(seq);
-        if (arr)
-            arr.push(o);
-        else
-            bySeq.set(seq, [o]);
-    }
-    const out = [];
-    for (const [seq, outcomes] of [...bySeq.entries()].sort((a, b) => a[0] - b[0])) {
-        const resolved = resolveByPrecedence(outcomes);
-        if (resolved && resolved.status !== 'failed')
-            out.push({ seq, content: resolved.approved });
-    }
-    return out;
-}
-/** The ONE run-scoped results-RAG recall primitive — used by BOTH the whole-step
- *  recall AND the per-`requires` evidence. EMBEDDING-based similarity via the
- *  backend's semantic query (NO homemade lexical scoring): the backend embeds the
- *  query + ranks by vector similarity, with the `runId` filter applied PRE-cap.
- *  Over-fetch `kPrime` (caller-supplied so the duplication bound is justified PER
- *  KIND), then dedup and cap to `k`. Dedup: step-results (have `seq`) →
- *  precedence-winner per seq; mcp-results → by `identityKey`. Embedding rank order
- *  is preserved through the dedup.
- *  `options` is forwarded into the embedder so recall-time embeds are metered. */
-export async function runScopedRecall(rag, text, k, runId, kPrime, artifactType, options) {
-    const hits = await rag.query(text, {
-        k: kPrime,
-        filter: { runId, artifactType },
-        options,
-    });
-    const bestStep = new Map();
-    const bestMcp = new Map();
-    for (const e of hits) {
-        if (e.metadata.seq !== undefined && e.metadata.status !== undefined) {
-            const prev = bestStep.get(e.metadata.seq);
-            if (!prev || isBetterStep(e, prev))
-                bestStep.set(e.metadata.seq, e);
-        }
-        else if (e.metadata.identityKey) {
-            const prev = bestMcp.get(e.metadata.identityKey);
-            if (!prev || isBetterMcp(e, prev))
-                bestMcp.set(e.metadata.identityKey, e);
-        }
-    }
-    // Walk hits in embedding-rank order; emit each (runId,seq) / identityKey once.
-    const out = [];
-    const seenSeq = new Set();
-    const seenMcp = new Set();
-    for (const e of hits) {
-        if (e.metadata.seq !== undefined && e.metadata.status !== undefined) {
-            if (seenSeq.has(e.metadata.seq))
-                continue;
-            seenSeq.add(e.metadata.seq);
-            // biome-ignore lint/style/noNonNullAssertion: bestStep has this seq (set above).
-            out.push(bestStep.get(e.metadata.seq));
-        }
-        else if (e.metadata.identityKey) {
-            if (seenMcp.has(e.metadata.identityKey))
-                continue;
-            seenMcp.add(e.metadata.identityKey);
-            // biome-ignore lint/style/noNonNullAssertion: bestMcp has this key (set above).
-            out.push(bestMcp.get(e.metadata.identityKey));
-        }
-        else {
-            out.push(e);
-        }
-        if (out.length >= k)
-            break;
-    }
-    return out.slice(0, k);
-}
-/** Outcome-precedence rank for step-result dedup (ok/exists > partial > failed). */
-function rankStatus(s) {
-    return s === 'ok' || s === 'exists'
-        ? 3
-        : s === 'partial'
-            ? 2
-            : s === 'failed'
-                ? 1
-                : 0;
-}
-/** True when candidate `a` is a better winner than current `b` for step-result
- *  dedup. Latest-wins by EXECUTION IDENTITY, not by semantic-rank position:
- *  1. Higher status rank wins; on tie →
- *  2. Higher attempt wins; on further tie →
- *  3. Higher writeOrdinal wins (tie-breaks same-timestamp artifacts from one run); on tie →
- *  4. Later createdAt wins (missing = older: compare with '' as sentinel). */
-function isBetterStep(a, b) {
-    const ra = rankStatus(a.metadata.status);
-    const rb = rankStatus(b.metadata.status);
-    if (ra !== rb)
-        return ra > rb;
-    const aa = a.metadata.attempt ?? 0;
-    const ba = b.metadata.attempt ?? 0;
-    if (aa !== ba)
-        return aa > ba;
-    const ao = a.metadata.writeOrdinal ?? -1;
-    const bo = b.metadata.writeOrdinal ?? -1;
-    if (ao !== bo)
-        return ao > bo;
-    return (a.metadata.createdAt ?? '') > (b.metadata.createdAt ?? '');
-}
-/** True when candidate `a` is a better winner than current `b` for mcp-result
- *  dedup. Latest-fetch wins by writeOrdinal first (handles same-timestamp), then
- *  falls back to createdAt (missing = older). */
-function isBetterMcp(a, b) {
-    const ao = a.metadata.writeOrdinal ?? -1;
-    const bo = b.metadata.writeOrdinal ?? -1;
-    if (ao !== bo)
-        return ao > bo;
-    return (a.metadata.createdAt ?? '') > (b.metadata.createdAt ?? '');
-}
-const MAX_EXTRACT_WINDOWS = 64;
-/** Return the ≤`maxChars` fragment of `content` most similar to `ref` by EMBEDDING
- *  (NOT ASCII lexical overlap). DIRECT single-pass ranking: every candidate is
- *  scored on its own. The SCORED window IS the RETURNED body: candidates are
- *  `body = maxChars - 2` chars (head+tail '…' reserved up front), so the
- *  highest-scoring fragment is never truncated by the markers. Stride is 50%
- *  overlap, widened to span the whole content within MAX_EXTRACT_WINDOWS windows
- *  (point coverage for content ≤ MAX_EXTRACT_WINDOWS×maxChars; larger thins to
- *  non-overlapping, best-effort). Embeds are SEQUENTIAL and BOUNDED to ≤
- *  MAX_EXTRACT_WINDOWS + 1 — touches NO public embedder API (batch is a deferred
- *  optimization). Result STRICTLY ≤ maxChars; tiny maxChars (< 3) → bare slice.
- *  The `requires` ref is English (planner invariant) → a normal embedder suffices. */
-export async function relevantExtract(content, ref, maxChars, embedder, options) {
-    if (content.length <= maxChars)
-        return content;
-    if (maxChars < 3)
-        return content.slice(0, Math.max(0, maxChars));
-    const body = maxChars - 2;
-    const stride = Math.max(Math.floor(body / 2), Math.ceil(content.length / MAX_EXTRACT_WINDOWS));
-    const { vector: q } = await embedder.embed(ref, options);
-    let bestStart = 0;
-    let bestScore = Number.NEGATIVE_INFINITY;
-    for (let s = 0; s < content.length; s += stride) {
-        const { vector } = await embedder.embed(content.slice(s, s + body), options);
-        const score = cosine(q, vector);
-        if (score > bestScore) {
-            bestScore = score;
-            bestStart = s;
-        }
-    }
-    const head = bestStart > 0 ? '…' : '';
-    const tail = bestStart + body < content.length ? '…' : '';
-    return head + content.slice(bestStart, bestStart + body) + tail;
-}
 //# sourceMappingURL=controller-coordinator-handler.js.map