agent-nuvira 3.3.12 → 3.3.14

package/dist/agents/orchestrator.js

@@ -64,7 +64,7 @@ import { scanForInjections, formatScanReport } from '../security/scanner.js';
 import { withLogCorrelation } from '../enterprise/log.js';
 import { withAgentAnswerQualityGate } from './answer-quality-gate.js';
 import { getMetrics } from '../enterprise/metrics.js';
-import { getAutoRouter, isAgenticTask, isAutoModel, isAutoProvider, } from '../learning/auto-router.js';
+import { getAutoRouter, isAgentAutoRoute, isAgenticTask, isAutoModel, isAutoProvider, isProviderOwnAuto, } from '../learning/auto-router.js';
 import { isAgenticCapableModel } from '../learning/model-harness.js';
 import { weakRouteNotice } from '../learning/agentic-route-gate.js';
 import { analyzeComplexity } from '../learning/hybrid-router.js';
@@ -166,6 +166,33 @@ export const DEFAULT_USE_TOOL_CALLING = true;
 export function resolveUseToolCalling(options) {
     return options.useToolCalling ?? DEFAULT_USE_TOOL_CALLING;
 }
+/**
+ * A5 — the trace-capture context for a pipeline HOUSEKEEPING call (the planner,
+ * memory retrieval, trajectory summarization, self-improvement), or `null` when
+ * the call must NOT be wrapped again.
+ *
+ * WHY THIS EXISTS. Those calls all run through `defaultCallLLM`, and each used to
+ * be wrapped at its use site with no provider/model:
+ *  - in AUTO mode `defaultCallLLM` is already traced by `createAutoRoutedLLM`, so
+ *    the second wrap logged every housekeeping call TWICE — once routed, once
+ *    `unknown/unknown` (the duplicate the planner already guarded against);
+ *  - on the EXPLICIT (pinned) path it is raw and must be wrapped — and NAMED, or
+ *    the step recorded `unknown/unknown` even though `options.provider/model`
+ *    were known, leaving the trace unable to say which model ran.
+ * `null` means "already traced — reuse it". The explicit context carries the
+ * audit route when one is known; `resolveAuditRoute` is best-effort and leaves
+ * its own `unknown` marker when nothing is known, exactly as before.
+ */
+export function housekeepingTraceContext(autoRoutingActive, base, audit) {
+    if (autoRoutingActive)
+        return null;
+    const context = { ...base };
+    if (audit?.provider)
+        context.provider = audit.provider;
+    if (audit?.model)
+        context.model = audit.model;
+    return context;
+}
 export class Orchestrator {
     configManager;
     /** The module registry used for agent lookups */
@@ -515,7 +542,7 @@ export class Orchestrator {
         // AutoModelRouter so no call ever sends a literal 'auto' model to a real API.
         // Matches executeSingleTask's rule: an explicit --model always wins.
         const autoRoutingActive = (options.autoRouteModels === true && !options.model) ||
-            isAutoModel(options.model) || isAutoProvider(options.provider);
+            isAgentAutoRoute(options.provider, options.model);
         // Cold-start learning: when auto routing is active but the registry has ZERO
         // verified providers (fresh install / stale store), fire ONE background probe
         // pass so later tasks in this pipeline — and the next session — route on
@@ -572,22 +599,27 @@ export class Orchestrator {
         const defaultCallLLM = autoRoutingActive
             ? this.createAutoRoutedLLM({ agentType: 'planner', description: goal }, options)
             : this.createLLMProvider(options);
-        // P0 reasoning trace: the planner + memory + trajectory calls share the
-        // raw defaultCallLLM, so wrap AT EACH USE SITE (never at creation) — a
-        // task fallback re-uses defaultCallLLM and wrapping it here would cause
-        // every task call to be recorded twice (once as planner, once as task).
+        // P0 reasoning trace: the planner + memory + trajectory + self-improver
+        // calls share `defaultCallLLM`, so they are wrapped at ONE use-site helper
+        // (never at creation) — a task fallback re-uses defaultCallLLM, and wrapping
+        // it at creation would record every task call twice (planner and task).
         //
-        // FIX: When auto-routing is active, createAutoRoutedLLMFromDecision already
-        // wraps with withTraceCapture — adding another layer causes DUPLICATE trace
-        // entries (the same call logged twice with 'unknown/unknown' provider info).
-        // Only wrap when NOT auto-routing (explicit provider path).
-        const plannerCallLLM = autoRoutingActive
-            ? defaultCallLLM
-            : withTraceCapture(defaultCallLLM, {
-                traceId: this.activeTraceId ?? '',
-                agentType: 'planner',
-                description: goal,
-            });
+        // A5 — THE HOUSEKEEPING STEPS WERE NOT NAMED, AND IN AUTO MODE WERE LOGGED
+        // TWICE. Two facts, one helper:
+        //  - When auto-routing is active `defaultCallLLM` is ALREADY traced by
+        //    `createAutoRoutedLLM`, so wrapping it again logged each housekeeping
+        //    call twice (once 'unknown/unknown', once routed). The planner guarded
+        //    against this; memory/trajectory/self-improver did not.
+        //  - On the explicit (pinned) path the wrapper carried NO provider/model, so
+        //    the step recorded `unknown/unknown` even though the pair was known.
+        // Reuse the already-traced LLM when auto-routing, and attribute the step to
+        // the audit route otherwise. `resolveAuditRoute` is best-effort and leaves
+        // its own 'unknown' marker when nothing is known, exactly as before.
+        const housekeepingCallLLM = (agentType, description) => {
+            const context = housekeepingTraceContext(autoRoutingActive, { traceId: this.activeTraceId ?? '', agentType, description }, this.resolveAuditRoute(options));
+            return context ? withTraceCapture(defaultCallLLM, context) : defaultCallLLM;
+        };
+        const plannerCallLLM = housekeepingCallLLM('planner', goal);
         // On resume, seed the report with the steps already finished in the original
         // run (completed/failed) so the final agent breakdown is complete — these
         // steps are never re-executed, but they still count toward the summary.
@@ -696,11 +728,7 @@ export class Orchestrator {
                 // plus the is_trivial_prompt gate — a one-word goal returns empty
                 // without touching the stores.
                 const { getMemoryManager } = await import('../memory/manager.js');
-                const memoryResult = await getMemoryManager().buildMemoryBlock(goal, withTraceCapture(defaultCallLLM, {
-                    traceId: this.activeTraceId ?? '',
-                    agentType: 'memory',
-                    description: `Memory retrieval for: ${goal.slice(0, 80)}`,
-                }));
+                const memoryResult = await getMemoryManager().buildMemoryBlock(goal, housekeepingCallLLM('memory', `Memory retrieval for: ${goal.slice(0, 80)}`));
                 // The manager composes the FULL persistent-memory block (provider's
                 // static system block framing the per-field recall). Consume it
                 // directly — the old re-composition here was redundant work.
@@ -770,109 +798,33 @@ export class Orchestrator {
         // ── 3b. Auto-route models ─────────────────────────────────────────────
         // `--auto-route` / autoRouteModels enables per-task AutoModelRouter
         // routing in executeSingleTask (no static map needed).
-        // ── 3c. Skill guidance (progressive disclosure, industry pattern) ──────
-        // Level 1 metadata lives in the skill store; when the goal matches a
-        // skill (findMatch), Level 2 (the methodology) is injected into the
-        // planner's context so deploy-style goals produce the correct steps
-        // automatically. Model-selected activation: the skill is a recommendation,
-        // the planner still owns the final plan. Best-effort — a skill-store
-        // failure must never break planning.
+        // ── 3c. Skill discovery (MODEL-DRIVEN) ──────────────────────────────────
+        // This step used to KEYWORD-MATCH one skill to the goal (findMatch +
+        // findHubSkillMatch, then the isSkillActivated evidence filter) and inject
+        // its methodology. That shipped a hand-written stopword/generic-word/host
+        // list that kept getting a case wrong ("blood test report" → the software
+        // test-strategy skill; "Windows and Linux" → wsl-setup). Word matching
+        // cannot decide what a goal MEANS, so it is gone from the pipeline too:
+        // the planner is a MODEL, so it is handed the CATALOG and picks the skill
+        // (by name) that fits, and the writer can load one in full with
+        // skill_view(name). The disabled gate still applies at catalog build time.
+        // Best-effort — a skill-store failure must never break planning.
         try {
-            const { getSkillStore } = await import('../learning/skill-store.js');
-            let matchedSkill = getSkillStore().findMatch(goal);
-            // P3 — skills.disabled[] gate: a dashboard/CLI-disabled skill is never
-            // injected, for COMPILED skills too. (The hub path already filters via
-            // listMatchableHubSkills; this closes the compiled gap so the Agent Hub
-            // toggle is never cosmetic.)
-            const { readDisabledSkills } = await import('../learning/hub-skill-catalog.js');
-            if (matchedSkill && new Set(readDisabledSkills()).has(matchedSkill.id))
-                matchedSkill = null;
-            // Activation gate (industry practice: model-selected activation).
-            // findMatch's threshold is intentionally low (score >= 1) for manual
-            // discovery; auto-injection must be tighter so a generic "deploy the
-            // API" goal does NOT get website-deployment methodology. For a
-            // website-deployment skill (bundled OR hub-installed), require
-            // hosting-specific intent words.
-            //
-            // This pipeline path used to apply ONLY the website-deploy rule and NO
-            // evidence filter at all — so it was the most exposed injection surface
-            // (live 2026-09-21: `wsl-setup` methodology injected into a cross-platform
-            // GUI app plan because the goal named "Windows and Linux"). It now uses
-            // the SAME `isSkillActivated` predicate as the chat/execute loop, so the
-            // three surfaces cannot disagree about what a goal is evidence FOR.
-            const { isSkillActivated } = await import('../tools/loop-skill-hint.js');
-            if (matchedSkill && !isSkillActivated(goal, matchedSkill))
-                matchedSkill = null;
-            if (matchedSkill) {
-                // Load full methodology from skill_view() (Hermes progressive disclosure)
-                let fullMethodology = '';
-                try {
-                    const { getSkillStore } = await import('../learning/skill-store.js');
-                    const store = getSkillStore();
-                    fullMethodology = store.skillView(matchedSkill.name);
-                }
-                catch {
-                    // Best-effort — skill_view failure must never break the pipeline
-                }
-                vault.setMeta('skillGuidance', {
-                    name: matchedSkill.name,
-                    description: matchedSkill.description,
-                    steps: matchedSkill.steps.map((s) => ({ agentType: s.agentType, description: s.description })),
-                    fullMethodology,
-                });
+            const { buildConfiguredSkillHint } = await import('../tools/loop-skill-hint.js');
+            // `skill-view` tail: the pipeline's load path is the writer's skill_view,
+            // not the loop's skill tool.
+            const skillCatalog = await buildConfiguredSkillHint(this.configManager, { loadHint: 'skill-view' });
+            if (skillCatalog) {
+                vault.setMeta('skillCatalog', skillCatalog);
                 this.eventBus.emit(EventNames.ORCHESTRATOR_AGENT_UPDATE, {
                     agentType: 'orchestrator',
                     stage: 'skill',
-                    message: `🧠 Matched skill '${matchedSkill.name}' — injecting its methodology into the planner`,
+                    message: '🧠 Handing the planner the skill catalog — the model picks which skill (if any) a step needs',
                 }, 'orchestrator');
-                if (options.verbose) {
-                    logger.info(`   🧠 Matched skill '${matchedSkill.name}' — injecting its methodology into the planner`);
-                }
-            }
-            else {
-                // I7 P0: no compiled skill matched — consult the HUB catalog (installed
-                // SKILL.md skills). These are first-class runtime capabilities too: a
-                // fresh `nuvira skills install` is matchable with zero recompilation.
-                // Same model-selected activation contract: the skill is a
-                // recommendation, the planner still owns the final plan.
-                const { findHubSkillMatch } = await import('../learning/hub-skill-catalog.js');
-                let hubMatch = findHubSkillMatch(goal);
-                // SAME activation gate as the compiled skill (website-deploy needs
-                // hosting intent) AND the evidence filter the hub scorer has never had:
-                // its name/description keyword score is a candidate RANKING, not proof
-                // the goal asked for the methodology.
-                if (hubMatch && !isSkillActivated(goal, hubMatch))
-                    hubMatch = null;
-                if (hubMatch) {
-                    // Load full methodology from skill_view() (Hermes progressive disclosure)
-                    let fullMethodology = '';
-                    try {
-                        const { getSkillStore } = await import('../learning/skill-store.js');
-                        const store = getSkillStore();
-                        fullMethodology = store.skillView(hubMatch.name);
-                    }
-                    catch {
-                        // Best-effort — skill_view failure must never break the pipeline
-                    }
-                    vault.setMeta('skillGuidance', {
-                        name: hubMatch.name,
-                        description: hubMatch.description,
-                        body: hubMatch.body,
-                        fullMethodology,
-                    });
-                    this.eventBus.emit(EventNames.ORCHESTRATOR_AGENT_UPDATE, {
-                        agentType: 'orchestrator',
-                        stage: 'skill',
-                        message: `🧠 Matched hub skill '${hubMatch.name}' — injecting its SKILL.md methodology into the planner`,
-                    }, 'orchestrator');
-                    if (options.verbose) {
-                        logger.info(`   🧠 Matched hub skill '${hubMatch.name}' — injecting its SKILL.md methodology into the planner`);
-                    }
-                }
             }
         }
         catch {
-            // Best-effort — skill guidance must never break the pipeline.
+            // Best-effort — skill discovery must never break the pipeline.
         }
         // ── 4. Planner (or pre-built plan from workflow template) ────────────
         // When resuming from a checkpoint the plan is already in the vault — skip
@@ -1396,20 +1348,12 @@ export class Orchestrator {
                     taskPlan: vault.context.taskPlan,
                 };
                 const { storeExecutionTrajectory } = await import('../memory/memory-integration.js');
-                trajectoryId = await storeExecutionTrajectory(orchestrationSummary, withTraceCapture(defaultCallLLM, {
-                    traceId: this.activeTraceId ?? '',
-                    agentType: 'memory',
-                    description: `Trajectory summarization for: ${goal.slice(0, 80)}`,
-                }), vault.context.taskPlan, contextFiles, options.verbose);
+                trajectoryId = await storeExecutionTrajectory(orchestrationSummary, housekeepingCallLLM('memory', `Trajectory summarization for: ${goal.slice(0, 80)}`), vault.context.taskPlan, contextFiles, options.verbose);
                 // Self-improvement
                 try {
                     const { getSelfImprover } = await import('../learning/self-improver.js');
                     const improver = getSelfImprover();
-                    await improver.processRun({ ...orchestrationSummary, trajectoryId }, withTraceCapture(defaultCallLLM, {
-                        traceId: this.activeTraceId ?? '',
-                        agentType: 'self-improver',
-                        description: `Pattern/failure-lesson extraction for: ${goal.slice(0, 80)}`,
-                    }), options.agentModels, options.verbose);
+                    await improver.processRun({ ...orchestrationSummary, trajectoryId }, housekeepingCallLLM('self-improver', `Pattern/failure-lesson extraction for: ${goal.slice(0, 80)}`), options.agentModels, options.verbose);
                     if (options.verbose && trajectoryId) {
                         logger.info('   Self-improvement stats saved. Run `nuvira learn optimize` to see recommendations.');
                     }
@@ -1766,7 +1710,11 @@ export class Orchestrator {
             // configured model BEFORE validating, so the validator is never asked to
             // repair a sentinel and the 'auto is not available on X' warning is not
             // printed for a value the user never chose as a model.
-            if (isAutoModel(requestedModel)) {
+            //
+            // A8 EXCEPTION: a CONCRETE provider pinned with `-m auto` means that
+            // provider's own auto (an OmniRoute combo), so the sentinel is NOT ours
+            // to resolve — it must reach the provider as-is.
+            if (isAutoModel(requestedModel) && !isProviderOwnAuto(rawProvider, requestedModel)) {
                 requestedModel = config.model || undefined;
             }
             // ALWAYS validate the pair — the model against THIS provider instance,
@@ -2221,7 +2169,7 @@ export class Orchestrator {
             // cheap model while complex tasks get a stronger one. An explicit
             // `--model` always wins over auto routing.
             const autoRouting = (options.autoRouteModels === true && !options.model) ||
-                isAutoModel(options.model) || isAutoProvider(options.provider);
+                isAgentAutoRoute(options.provider, options.model);
             const effectiveAgentType = strategy.effectiveAgentType || task.agentType;
             const agentModel = options.model || options.agentModels?.[effectiveAgentType] || options.agentModels?.[task.agentType];
             let taskBoundProvider;
@@ -2422,6 +2370,13 @@ export class Orchestrator {
                         // model exists to escalate to (never for a healthy pipeline).
                         try {
                             vault.context.metadata.lenientFileParsing = true;
+                            // Name the task's DECLARED artifacts so a `shrink-scope` repair
+                            // can ask for the FIRST one concretely ("produce exactly this
+                            // file") instead of a vague "do less". Absent → the narrowed ask
+                            // stays generic and never invents a filename.
+                            if (task.expectedFiles?.length) {
+                                vault.context.metadata.expectedFiles = task.expectedFiles;
+                            }
                         }
                         catch {
                             // Best-effort — metadata must never break repair.
@@ -2488,20 +2443,29 @@ export class Orchestrator {
                                 spl.start();
                         }
                     }
-                    // No-op escalation → cap this task's repair budget at 1 (lenient
-                    // parsing already gives the weak writer its best shot; a second
-                    // cycle on the same weak model only burns minutes re-running the
-                    // identical failure). Healthy pipelines keep the configured budget.
+                    // No-op escalation → a bounded WEAK-MODEL CLOSE-THE-LOOP ladder.
+                    //
+                    // This used to cap the budget at 1 because attempt 2 was the SAME
+                    // weak model re-running the SAME failure — pure wasted minutes. It is
+                    // now 2, because `weakModel: true` changes what attempt 2 IS: a
+                    // `shrink-scope` ask for the smallest single unit (see
+                    // error-repair.ts). That is the step that turns a stuck loop around:
+                    // re-prompt with the failure, then ask for LESS and move the work
+                    // forward, then stop honestly at 3. Healthy pipelines keep the
+                    // configured budget and the ordinary per-category ladder.
                     //
                     // 'abort' skips repair entirely: the user chose to fix the provider
                     // config, so re-running the weak model is wasted work. The task is
                     // marked failed with an actionable message; the pipeline stops.
                     const userAborted = this.weakModelChoice === 'abort';
-                    const effectiveMaxRepairs = noOpEscalation && autoRouting ? 1 : maxRepairs;
+                    const weakModelOnly = noOpEscalation && autoRouting;
+                    const effectiveMaxRepairs = weakModelOnly ? 2 : maxRepairs;
                     const repairEngine = new ErrorRepairEngine({
                         maxRepairs: effectiveMaxRepairs,
                         repairMode,
                         verbose: options.verbose,
+                        // Only the weak/no-op-escalation path takes the bounded ladder.
+                        weakModel: weakModelOnly,
                         fallbackModels: options.repairFallbackModels,
                         // LLM AVAILABILITY GUARD: check if the escalated task's provider
                         // is rate-limited before retrying. Prevents retry-tool and
@@ -3336,7 +3300,11 @@ export class Orchestrator {
                             complexity: decision.complexity,
                             provider: decision.provider,
                             model: workingModel ?? decision.model,
-                            score: decision.score,
+                            // B2-a — this block runs only when the model was REPAIRED
+                            // (`workingModel !== decision.model`), so `decision.score`
+                            // describes the model that was replaced. The repaired model was
+                            // substituted, never ranked: record it with no score rather than
+                            // with a number that belongs to a different model.
                         });
                     }
                     catch {