agent-nuvira 3.1.0 → 3.1.3

package/dist/agents/prompt-assembly.js

@@ -31,9 +31,9 @@ const CONTEXT_SCAN_DIRS = ['.agents', '.nuvira', '.cursor'];
 // ─── Project Assessment ─────────────────────────────────────────────────────
 /**
  * Assess the project before executing tasks.
- * Adopts Codebuff's pattern: detect framework, language, and project state
- * before generating prompts. This replaces the generic context-gatherer
- * with a fast, deterministic assessment.
+ * Detect framework, language, and project state before generating prompts.
+ * This replaces the generic context-gatherer with a fast, deterministic
+ * assessment.
  */
 export function assessProject(workingDirectory) {
     const assessment = {

package/dist/agents/tool-calling-agent.d.ts

@@ -1,7 +1,7 @@
 /**
  * ToolCallingAgent — Base class for agents that use a tool-calling loop.
  *
- * Adopts the proven pattern from Freebuff and Hermes:
+ * Adopts the proven agentic pattern:
  *   LLM generates tool call → Agent executes tool → Result fed back → Loop
  *
  * KEY CONSTRAINT: This agent does NOT write to disk. Tools propose FileChange
@@ -9,8 +9,8 @@
  * agent returns. This preserves dry-run mode, rollback, and audit trail.
  *
  * Reference:
- * - Freebuff: packages/agent-runtime/src/run-agent-step.ts (tool-calling loop)
- * - Hermes: run_agent.py AIAgent.run_conversation() (tool dispatch loop)
+ * - tool-calling loop: LLM step → tool dispatch → observation → next step
+ * - tool dispatch loop: run the requested tool, feed the result back
  *
  * The tool-calling is prompt-based (not native function calling) because
  * the existing LLMCallFn interface doesn't support tool definitions.

package/dist/agents/tool-calling-agent.js

@@ -1,7 +1,7 @@
 /**
  * ToolCallingAgent — Base class for agents that use a tool-calling loop.
  *
- * Adopts the proven pattern from Freebuff and Hermes:
+ * Adopts the proven agentic pattern:
  *   LLM generates tool call → Agent executes tool → Result fed back → Loop
  *
  * KEY CONSTRAINT: This agent does NOT write to disk. Tools propose FileChange
@@ -9,8 +9,8 @@
  * agent returns. This preserves dry-run mode, rollback, and audit trail.
  *
  * Reference:
- * - Freebuff: packages/agent-runtime/src/run-agent-step.ts (tool-calling loop)
- * - Hermes: run_agent.py AIAgent.run_conversation() (tool dispatch loop)
+ * - tool-calling loop: LLM step → tool dispatch → observation → next step
+ * - tool dispatch loop: run the requested tool, feed the result back
  *
  * The tool-calling is prompt-based (not native function calling) because
  * the existing LLMCallFn interface doesn't support tool definitions.

package/dist/cli/chat.d.ts

@@ -32,18 +32,24 @@ export interface DispatchAssessmentOptions {
     text?: string;
 }
 /**
- * E3a/E3c — the rule assessment (hint + no-model fallback source).
+ * E3a/E3c — the rule assessment (no-model fallback source).
  *
  * The legacy `promptDeveloperMode` menu ("1. Chat mode / 2. Developer mode")
  * is DELETED (Session 7c re-scope, landed in E3a). E3c demotes the rules
- * further (model-decides): EVERY request runs as a
- * tool-call turn and the MODEL decides what to do. This function computes
- * what the RULES would say, used for two things only:
- * - the rule hint injected into the model's context (buildToolSystemPrompt),
- * - the no-model fallback decision: when the tool loop fails to generate a
- *   single response AND the rules assessed a high-confidence pipeline intent,
- *   the pipeline runs directly — rules act ONLY when the model is unavailable,
- *   never as a bypass.
+ * further (model-decides): EVERY request runs as a tool-call turn and the
+ * MODEL decides what to do. This function computes what the RULES would say,
+ * used for ONE thing only: the no-model fallback — when the tool loop fails to
+ * generate a single response AND the rules assessed a high-confidence pipeline
+ * intent, the pipeline runs directly. Rules act ONLY when the model is
+ * unavailable, never as a bypass.
+ *
+ * It is deliberately NOT injected into the model's system prompt: commit
+ * 4d30b7e removed prompt-level intent steering ("give the LLM tools and let it
+ * decide") and a test guards against its return. So on THIS surface the model
+ * decides, and `resolveAskKind` does not determine the outcome — that is only
+ * true of the GATEWAY, which routes on it BEFORE the model is called. Same
+ * rule, two different consequences: do not read a routing table here as a
+ * prediction of what `nuvira chat` will do.
  * `dev` (the --dev flag / /dev toggle) forces the assessment to dispatch.
  */
 export declare function resolvePipelineDispatch(parsed: ParsedRequest, opts?: DispatchAssessmentOptions): PipelineDispatchDecision;
@@ -241,6 +247,11 @@ export declare class ChatCommand extends BaseCommand {
          * unverified claim. Every surface must treat this as "not confirmed done".
          */
         unverifiedActionClaim?: boolean;
+        /**
+         * True when the answer closed on a promise to act that the turn never
+         * carried out. Surfaces must not present such a turn as "in progress".
+         */
+        unfulfilledPromise?: boolean;
         provider?: string;
         model?: string;
     }>;

package/dist/cli/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/cli/chat.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/cli/chat.ts"],"names":[],"mappings":"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"}

package/dist/cli/chat.js

@@ -19,7 +19,7 @@ import { applyActiveModel } from './model.js';
 import { getProviderFallback, classifyFallbackError, isRetryableError, isTransientForRetry, recordRegistrySuccess } from '../learning/provider-fallback.js';
 import { recordActionFailure } from '../learning/failure-bookkeeping.js';
 import { resolveThreadBudgetChars } from '../learning/context-budget.js';
-import { getAutoRouter, isAutoModel, isAutoProvider } from '../learning/auto-router.js';
+import { getAutoRouter, isAutoModel, isAutoProvider, governanceVerdict } from '../learning/auto-router.js';
 import { estimateTokens } from '../learning/cost-tracker.js';
 import { getModelRegistry } from '../learning/model-registry.js';
 import { refreshModelRegistry } from '../inference/model-probe.js';
@@ -34,11 +34,11 @@ import { recordMetricTime, getMetrics } from '../enterprise/metrics.js';
 import { resolveDispatch } from '../nlu/actions.js';
 import { hasCodingAction, resolveAskKind } from '../nlu/conversation-gate.js';
 import { runToolLoop, extractFallbackToolCalls } from '../tools/tool-loop.js';
-import { looksLikeConfusedScaffoldingReply, toUserFacingGenerationError, isToolCallingUnsupported, stripToolCallArtifacts, } from '../inference/tool-call-utils.js';
+import { detectAnswerQualityFailure, answerQualityError, toUserFacingGenerationError, isToolCallingUnsupported, stripToolCallArtifacts, } from '../inference/tool-call-utils.js';
 import { beginTrace, endTrace, recordStep, buildTraceOutcome } from '../learning/reasoning-trace.js';
 import { getLoopExposureMode } from '../tools/toolsets.js';
 import { resolveModelHarnessProfile, shouldSkipNativeTools } from '../learning/model-harness.js';
-import { resolveAdapterDefault } from '../learning/model-selection.js';
+import { resolveAdapterDefault, hasCredentials } from '../learning/model-selection.js';
 import { buildLoopProjectContext } from '../tools/loop-project-context.js';
 import { sweepTransientFailures, collectionRevivalStore } from '../learning/provider-revival.js';
 import { analyzeComplexity } from '../learning/hybrid-router.js';
@@ -148,18 +148,24 @@ async function handleInferenceError(err, providerName, configManager) {
     return { action: answer.action };
 }
 /**
- * E3a/E3c — the rule assessment (hint + no-model fallback source).
+ * E3a/E3c — the rule assessment (no-model fallback source).
  *
  * The legacy `promptDeveloperMode` menu ("1. Chat mode / 2. Developer mode")
  * is DELETED (Session 7c re-scope, landed in E3a). E3c demotes the rules
- * further (model-decides): EVERY request runs as a
- * tool-call turn and the MODEL decides what to do. This function computes
- * what the RULES would say, used for two things only:
- * - the rule hint injected into the model's context (buildToolSystemPrompt),
- * - the no-model fallback decision: when the tool loop fails to generate a
- *   single response AND the rules assessed a high-confidence pipeline intent,
- *   the pipeline runs directly — rules act ONLY when the model is unavailable,
- *   never as a bypass.
+ * further (model-decides): EVERY request runs as a tool-call turn and the
+ * MODEL decides what to do. This function computes what the RULES would say,
+ * used for ONE thing only: the no-model fallback — when the tool loop fails to
+ * generate a single response AND the rules assessed a high-confidence pipeline
+ * intent, the pipeline runs directly. Rules act ONLY when the model is
+ * unavailable, never as a bypass.
+ *
+ * It is deliberately NOT injected into the model's system prompt: commit
+ * 4d30b7e removed prompt-level intent steering ("give the LLM tools and let it
+ * decide") and a test guards against its return. So on THIS surface the model
+ * decides, and `resolveAskKind` does not determine the outcome — that is only
+ * true of the GATEWAY, which routes on it BEFORE the model is called. Same
+ * rule, two different consequences: do not read a routing table here as a
+ * prediction of what `nuvira chat` will do.
  * `dev` (the --dev flag / /dev toggle) forces the assessment to dispatch.
  */
 export function resolvePipelineDispatch(parsed, opts) {
@@ -430,7 +436,11 @@ export class ChatCommand extends BaseCommand {
         // pipeline resolves its own working provider/model).
         if (answer.generationFailed && dispatchDecision.dispatch && !dispatchDecision.needConfirm) {
             const r = await runPipelineTool(message, this.configManager, { provider: type, model, board: false });
-            if (r.error) {
+            // `success`, not `error`: a pipeline that RAN and failed reports its
+            // outcome in `summary` and only sometimes sets `error`, so keying off
+            // `error` alone returned a failed run's summary with NO failure flag —
+            // i.e. reported it as a successful turn on every surface.
+            if (!r.success) {
                 return { content: '', followups: [], generationFailed: true, provider: type, model };
             }
             return { content: r.result?.summary ?? '', followups: [], provider: type, model };
@@ -445,6 +455,7 @@ export class ChatCommand extends BaseCommand {
             bounded: answer.bounded,
             toolCalls: answer.toolCalls,
             unverifiedActionClaim: answer.unverifiedActionClaim,
+            unfulfilledPromise: answer.unfulfilledPromise,
             provider: type,
             model,
         };
@@ -548,10 +559,9 @@ export class ChatCommand extends BaseCommand {
                 model = routed.model;
             }
             // E3c: model-decides — EVERY request runs as a TOOL-CALL TURN. The
-            // rule assessment is a HINT in the model's context (buildToolSystemPrompt)
-            // — the model decides what to do. Rules act
-            // ONLY as the no-model fallback below (generation failed entirely), never
-            // as a bypass.
+            // model decides what to do; the rule assessment is NOT in its context
+            // (4d30b7e) and acts ONLY as the no-model fallback below (generation
+            // failed entirely), never as a bypass.
             const parsed = parseRequestSync(prompt);
             const dispatchDecision = resolvePipelineDispatch(parsed, { dev: options?.dev, text: prompt });
             const answer = await this.runChatAnswer(prompt, [], { type, provider, model }, options || {}, cacheEnabled, { auto: autoMode }, parsed);
@@ -814,8 +824,11 @@ export class ChatCommand extends BaseCommand {
         history.push({ role: 'user', content: message });
         // System prompt: base identity + the tool contract — the
         // model clarifies with ask_user and ends every response with followups.
-        // E3c: the rule assessment rides in as a hint when the rules parsed a
-        // confident intent (model decides; hint only).
+        //
+        // NO rule-based intent steering goes in here (commit 4d30b7e removed it on
+        // purpose: "give the LLM tools and let it decide"). `dispatchDecision` is
+        // computed for the generation-FAILED fallback only — it does NOT reach the
+        // prompt, so on this surface the MODEL decides and the rules are invisible.
         const systemText = buildToolSystemPrompt(parsed);
         // Phase 3.2 (assessment Addendum v4) — loop-side skill match hint: the
         // orchestrator consults SkillStore.findMatch + the hub catalog before
@@ -1080,7 +1093,10 @@ export class ChatCommand extends BaseCommand {
             });
         }
         catch (err) {
-            // The tool loop never throws by design; this guards future changes.
+            // The tool loop does not throw on its own; this catches the errors that
+            // ARE meant to propagate — most importantly the ANSWER-QUALITY rejection
+            // (`answerQualityError`), which the loop rethrows once every candidate has
+            // narrated.
             logger.error(String(err));
             endTrace(chatTraceId, false, { kind: 'failed' });
             result = {
@@ -1091,6 +1107,14 @@ export class ChatCommand extends BaseCommand {
                 toolCalls: [],
                 steps: 0,
                 bounded: false,
+                // AND it is a FAILURE. Without this the honest line was returned as a
+                // SUCCESSFUL turn: the dashboard offered no retry and queued nothing,
+                // the gateway reported the turn as fine, and the line was free to be
+                // cached as the model's answer. Caught live on the dashboard surface —
+                // the bubble read "The model wrote its own working notes instead of an
+                // answer…" while `generationFailed` was false, so the one thing the
+                // reader could have done about it (retry) was never offered.
+                generationFailed: true,
             };
         }
         // Record WHAT HAPPENED, not just "the model answered": a hallucinated
@@ -1099,8 +1123,12 @@ export class ChatCommand extends BaseCommand {
         endTrace(chatTraceId, !result.generationFailed, buildTraceOutcome({
             generationFailed: result.generationFailed,
             cancelled: result.cancelled,
-            tools: result.toolCalls,
+            // What actually RAN successfully, not what was attempted: a failed
+            // `gateway_send` must not make the trace read
+            // "✅ action performed — message sent".
+            tools: result.successfulToolCalls ?? result.toolCalls,
             unverifiedActionClaim: result.unverifiedActionClaim,
+            unfulfilledPromise: result.unfulfilledPromise,
         }));
         // Finalize the turn (cache + memory + registry telemetry).
         // E3c: a generationFailed turn is NOT cached/persisted — the caller may
@@ -1146,6 +1174,7 @@ export class ChatCommand extends BaseCommand {
             followups: result.followups,
             toolCalls: result.toolCalls,
             unverifiedActionClaim: result.unverifiedActionClaim,
+            unfulfilledPromise: result.unfulfilledPromise,
         };
     }
     /**
@@ -1212,6 +1241,33 @@ export class ChatCommand extends BaseCommand {
              * path automatically.
              */
             const nativeToolsRejected = new Set();
+            /**
+             * GOVERNANCE PRE-FLIGHT (pinned path).
+             *
+             * An explicit pin bypasses `autoRouter.resolve`, and the admin policy
+             * (provider/model allow+deny lists, the PII privacy hard-gate) is enforced
+             * inside resolve — so a pinned turn was the one way to serve a provider
+             * the policy rules out, and a failed pinned turn would happily fall back
+             * to one. A privacy policy any pin can bypass is not a policy. Checked
+             * BEFORE the first network call so a blocked turn costs nothing, and
+             * thrown as a typed policy error so `toUserFacingGenerationError` surfaces
+             * the REASON instead of "the language model was unavailable".
+             *
+             * No policy configured → `governanceVerdict` is permissive and this is a
+             * no-op (unchanged behaviour for every existing setup).
+             */
+            if (!mode.auto) {
+                const verdict = governanceVerdict(this.configManager, session.type, {
+                    model: session.model,
+                    taskText: message,
+                });
+                if (!verdict.allowed) {
+                    // Prefixed so `toUserFacingGenerationError` reports the POLICY, not a
+                    // phantom unavailable model (nothing was unreachable — a rule
+                    // refused it). The reason names the provider and the rule.
+                    throw new Error(`Governance policy: ${verdict.reason}`);
+                }
+            }
             const resolveEffectiveModel = (providerType, requested) => {
                 if (requested && requested !== 'default')
                     return requested;
@@ -1236,16 +1292,25 @@ export class ChatCommand extends BaseCommand {
                 // the tool contract (e.g. apologizing that "the provided example call
                 // to suggest_followups is incomplete") instead of executing it — never
                 // throws, so failover never fired and the confusion went to the user
-                // verbatim (live WhatsApp incident). Treat it like a generation
-                // failure: THROWS so the caller's failover walk retries with the next
-                // candidate; the raw reply is carried on the error for the final
-                // fallback.
-                const confuseCheck = (content) => {
-                    if (looksLikeConfusedScaffoldingReply(content)) {
-                        const err = new Error(`model answered with tool-contract confusion instead of the task (reply: ${content.slice(0, 160)})`);
-                        err.confusedReply = content;
-                        throw err;
-                    }
+                // verbatim (live WhatsApp incident). Same for the OTHER quality failure:
+                // the model delivering its own REASONING ("The user said \"Hi\" …
+                // According to the instructions: …"). One shared detector
+                // (`detectAnswerQualityFailure`) is used here and by the loop engine
+                // (`nuvira execute` / the pipeline), so neither surface can drift.
+                // Treat it like a generation failure: THROWS so the caller's failover
+                // walk retries with the next candidate; the raw reply is carried on the
+                // error for the final fallback.
+                // `hasToolCalls` selects the strictness tier: a step that is ACTING may
+                // legitimately open with a first-person narration ("Let me check the
+                // config.") before its tool call, and rejecting it would throw the call
+                // away — so a tool-carrying step is judged on the high-precision
+                // signals only, while the step that IS the answer is judged on all.
+                const confuseCheck = (content, hasToolCalls = false) => {
+                    const failure = detectAnswerQualityFailure(content, undefined, {
+                        highPrecisionOnly: hasToolCalls,
+                    });
+                    if (failure)
+                        throw answerQualityError(content, failure);
                 };
                 /** Mark the model that actually produced this response. */
                 const answered = (resp) => {
@@ -1268,11 +1333,11 @@ export class ChatCommand extends BaseCommand {
                         // still receives the answer (appears at once — today's behavior).
                         if (sink && typeof prov.generateToolsStream === 'function') {
                             const result = await prov.generateToolsStream(messages, schemas, { ...options, model: effectiveModel, signal: abort }, sink);
-                            confuseCheck(result.content);
+                            confuseCheck(result.content, result.toolCalls.length > 0);
                             return answered(result);
                         }
                         const result = await prov.generateTools(messages, schemas, { ...options, model: effectiveModel, signal: abort });
-                        confuseCheck(result.content);
+                        confuseCheck(result.content, result.toolCalls.length > 0);
                         if (sink && result.content)
                             sink(result.content);
                         return answered(result);
@@ -1286,7 +1351,7 @@ export class ChatCommand extends BaseCommand {
                         if (salvaged) {
                             // The salvaged essay can itself be contract-confusion — check it
                             // too, otherwise a confused 400 payload sails through salvage.
-                            confuseCheck(salvaged.content);
+                            confuseCheck(salvaged.content, (salvaged.followups?.length ?? 0) > 0);
                             logger.warn("   ⚠️ Tool call rejected (400) — salvaging the model's generated answer.");
                             // Re-run the recovered suggest_followups through the normal tool
                             // path so the followups land in the sink (and the loop's
@@ -1327,7 +1392,7 @@ export class ChatCommand extends BaseCommand {
                     raw = await prov.generate(prompt, { ...options, model: effectiveModel, signal: abort });
                 }
                 const { text, calls } = extractFallbackToolCalls(raw);
-                confuseCheck(text);
+                confuseCheck(text, calls.length > 0);
                 return answered({ content: text, toolCalls: calls });
             };
             try {
@@ -1394,15 +1459,68 @@ export class ChatCommand extends BaseCommand {
                 }
                 else if (isRetryableError(classifyFallbackError(err))) {
                     // Non-auto: walk the shared fallback chain (retryable errors only).
+                    // Providers the admin policy rules out are collected here so the
+                    // failure can name POLICY as the reason instead of implying the model
+                    // was unreachable.
+                    const policyBlocked = [];
                     try {
                         const fallback = getProviderFallback(this.configManager, this.configManager.getAll().fallback);
                         const chain = fallback.getFallbackChain(session.type);
-                        for (const fbType of chain) {
+                        /**
+                         * Order the chain the way `loop-executor`'s pinned pool does: a
+                         * registry-parked / cooling-down provider goes LAST (never dropped,
+                         * since the whole point of failover is to reach what the primary
+                         * could not). Best-effort — ordering must never cost us the chain.
+                         */
+                        let ordered = chain;
+                        try {
+                            const isExcluded = createFailoverExclusionFilter();
+                            ordered = [
+                                ...chain.filter((t) => !isExcluded(t)),
+                                ...chain.filter((t) => isExcluded(t)),
+                            ];
+                        }
+                        catch {
+                            // Ordering is an optimization only.
+                        }
+                        for (const fbType of ordered) {
                             if (fbType === session.type)
                                 continue;
+                            // ADMIN POLICY: never fall back to a provider the policy rules
+                            // out. This was the leak — a PII task whose pinned (compliant)
+                            // provider failed would silently continue on a provider the
+                            // privacy policy forbids. Recorded so the turn can SAY why the
+                            // walk found nothing instead of blaming the model.
+                            const policy = governanceVerdict(this.configManager, fbType, {
+                                taskText: message,
+                            });
+                            if (!policy.allowed) {
+                                policyBlocked.push({ provider: fbType, reason: policy.reason ?? 'blocked by policy' });
+                                continue;
+                            }
+                            // Only providers the user can actually CALL. An explicit
+                            // `fallback.providers` entry with no key is not filtered out by
+                            // the chain itself, so it used to cost a full connection timeout
+                            // (measured live at ~25s against an unauthenticated endpoint)
+                            // before the next candidate was tried — time the sender spends
+                            // waiting for a reply that is already failing. Same credential
+                            // gate `loop-executor`'s pinned pool applies.
+                            if (!hasCredentials(this.configManager, fbType))
+                                continue;
                             try {
                                 const resolved = resolveProvider(this.configManager, fbType);
-                                return await tryGenerate(resolved.provider, resolved.type, session.model);
+                                // The fallback provider gets ITS OWN model, not the primary's
+                                // id. Reusing `session.model` here sent e.g. gemini's
+                                // `gemini-3.1-flash-lite` to groq, which 404s “model not found”
+                                // — so every fallback candidate failed for a reason unrelated
+                                // to the outage and a pinned-provider turn dead-ended with
+                                // “the language model was unavailable” even though healthy
+                                // providers were available. (The auto branch below has always
+                                // passed `next.model`, which is why only the pinned path -
+                                // the dashboard console and the gateway chat engine - looked
+                                // dead.) Undefined = that provider's configured/adapter
+                                // default, which tryGenerate resolves per attempt.
+                                return await tryGenerate(resolved.provider, resolved.type, resolveEffectiveModel(resolved.type, undefined));
                             }
                             catch {
                                 // Next fallback candidate.
@@ -1412,6 +1530,18 @@ export class ChatCommand extends BaseCommand {
                     catch {
                         // Fall through to rethrow.
                     }
+                    // Every fallback candidate was refused by ADMIN POLICY (and none
+                    // answered): the honest answer is the policy block, not "the language
+                    // model was unavailable". Surfaced through the same
+                    // `Governance policy:` prefix the pre-flight check uses.
+                    if (policyBlocked.length > 0) {
+                        logger.warn(`   ⚠️ Governance policy blocked every fallback provider: ${policyBlocked
+                            .map((b) => `${b.provider} (${b.reason})`)
+                            .join('; ')}`);
+                        throw new Error(`Governance policy: no permitted fallback provider was available — ${policyBlocked
+                            .map((b) => `${b.provider}: ${b.reason}`)
+                            .join('; ')}`);
+                    }
                 }
                 // Answer-quality resilience: every candidate failed (or none was
                 // tried) and the error carries the model's raw confused reply —