agent-nuvira 3.1.3 → 3.2.0

package/dist/learning/autonomy-policy.js

@@ -0,0 +1,500 @@
+/**
+ * Autonomy policy — may the agent decide for itself, or must it ask?
+ * (enterprise-grade hardening, G11.)
+ *
+ * WHY THIS EXISTS (the WhatsApp story audit + the "manual cadence" complaint):
+ * Two failure modes sit on opposite sides of the same missing rule.
+ *
+ *   1. STALLING ON AN ANSWERABLE QUESTION. The story session asked/implied
+ *      decisions it could have made itself ("should I keep going?", "which
+ *      file?"), and every one of those turned into a turn that ended without
+ *      delivered work. An agent that consults on a choice it can make is not
+ *      careful — it is a bottleneck, and it is how 32 minutes produced zero
+ *      words.
+ *   2. DECIDING SOMETHING THAT WAS NEVER ITS CALL. The opposite failure, where
+ *      an agent silently picks a direction the user cared about (which
+ *      provider to bill, whether to overwrite existing work, what to delete).
+ *
+ * The enterprise behaviour is a POLICY, not a mood: decide by default, consult
+ * only when the decision is (a) genuinely the user's, (b) not implied by the
+ * ask, (c) irreversible or expensive to get wrong, and (d) has no sensible
+ * default. Everything else is the agent's job.
+ *
+ * This module is deterministic and LLM-free on purpose: it is the guard rail
+ * around a model's own "should I ask?" instinct, which skews towards asking.
+ */
+/**
+ * Rework above this many minutes makes a defaulted choice expensive enough to
+ * be worth a round trip even when the choice is reversible.
+ */
+export const REWORK_CONSULT_THRESHOLD_MINUTES = 45;
+/**
+ * Decide whether the agent proceeds on its own or asks the user.
+ *
+ * Order matters. The cheap, obviously-ours cases are settled first so that a
+ * later rule can never turn an easy call into a consultation:
+ *
+ *  1. NOT BLOCKING, NOT HIGH-IMPACT -> proceed. Nothing is waiting on an
+ *     answer, and the user can redirect at any time. Asking is pure latency.
+ *  2. THE ASK ALREADY SAID SO -> proceed with the implied choice. Re-asking a
+ *     question the user answered in their own request is the "cheap shortcut"
+ *     in reverse: it looks like diligence and delivers nothing.
+ *  3. A BLOCKING, HIGH-IMPACT, IRREVERSIBLE DECISION WITH NO DEFAULT -> this is
+ *     the user's call. Consult — with a defaulted recommendation, so the reply
+ *     is a one-word confirmation rather than an essay.
+ *  4. OTHERWISE -> proceed with the default, unless the rework a wrong pick
+ *     would cost is large enough to justify asking (rule 5).
+ *  5. EXPENSIVE + NO DEFAULT -> consult.
+ *
+ * A blocking decision with a sensible default proceeds. That is the whole
+ * point of the policy: "which file should I write to" has a default (the one
+ * named in the ask, or a predictable one), so it must never stop a run.
+ */
+export function decideAutonomously(request) {
+    const impact = request.impact ?? 'medium';
+    const blocking = request.blocking === true;
+    const choice = request.defaultChoice ?? request.options?.[0];
+    if (!blocking && impact !== 'high') {
+        return {
+            action: 'proceed',
+            choice,
+            reason: 'non-blocking and not high-impact — proceeding and leaving the user free to redirect',
+        };
+    }
+    if (request.impliedByAsk) {
+        return {
+            action: 'proceed',
+            choice,
+            reason: 'the request itself already specifies this — re-asking would be a round trip with no new information',
+        };
+    }
+    const irreversible = request.reversible === false;
+    const rework = request.reworkMinutes ?? 0;
+    const hasDefault = typeof choice === 'string' && choice.length > 0;
+    if (blocking && impact === 'high' && irreversible && !hasDefault) {
+        return {
+            action: 'consult',
+            reason: 'blocking, high-impact, irreversible, and no sensible default — this is genuinely the user’s decision',
+        };
+    }
+    if (hasDefault && !(irreversible && impact === 'high')) {
+        return {
+            action: 'proceed',
+            choice,
+            reason: 'a sensible default exists and the choice is recoverable — deciding it is the agent’s job',
+        };
+    }
+    if (rework > REWORK_CONSULT_THRESHOLD_MINUTES && !hasDefault) {
+        return {
+            action: 'consult',
+            reason: `a wrong pick would cost roughly ${rework} minutes and there is no default to fall back on`,
+        };
+    }
+    if (!hasDefault && request.blocking) {
+        return {
+            action: 'consult',
+            reason: 'blocking, with no default the agent is willing to stand behind',
+        };
+    }
+    return {
+        action: 'proceed',
+        choice,
+        reason: irreversible && impact === 'high'
+            ? 'proceeding with the stated default; the choice is high-impact but the user’s own preference is already known'
+            : 'no reason to wait on an answer — proceeding',
+    };
+}
+// ── Write authorization: did the REQUEST already authorize this? ────────────
+/**
+ * Verbs that mean "produce the artifact", not "tell me about it".
+ * Deliberately includes the edit verbs: "add a chapter", "update the README".
+ */
+const CREATE_VERB_RE = /\b(?:create|build|write|make|generate|develop|implement|scaffold|set\s+up|setup|add|produce|draft|code|rewrite|refactor|fix|update|change|edit|modify|migrate|upgrade|convert|render|export|deploy|install|save|store|persist)\b/i;
+/** Nouns that name a FILE-SHAPED deliverable (the thing that lands on disk). */
+const DELIVERABLE_NOUN_RE = /\b(?:file|files|folder|directory|project|repo|repository|app|application|website|site|webpage|web\s?page|page|pages|component|module|class|function|script|program|tool|cli|server|api|endpoint|test|tests|suite|config|document|doc|docs|report|readme|story|book|novel|chapter|chapters|poem|essay|article|post|plan|spec|schema|migration|template|templates|style|styles|asset|assets|manuscript|draft)\b/i;
+/** A path is the strongest signal of all: the user named the destination. */
+const PATH_RE = /(?:^|[\s"'`(])(?:~|\/|\.{1,2}\/)[\w./-]+/;
+/**
+ * Directive verbs that ask for a CHANGE to something that already exists.
+ *
+ * Kept separate from {@link CREATE_VERB_RE} because the evidence is different:
+ * these need no file-shaped noun ("fix the calculator") — the verb applied to an
+ * object already says the work is to change what is there. Still vetoed by an
+ * analysis opener, so "why is the build failing?" remains a question.
+ */
+const MAINTENANCE_VERB_RE = /\b(?:fix|repair|refactor|update|change|edit|modify|migrate|upgrade|improve|optimize|optimise|clean\s*up|rewrite|rename|remove|delete|correct|debug|patch|tweak)\b/i;
+/**
+ * An analysis/interrogative opener means the user is asking ABOUT something,
+ * not asking for it to be produced: "what files should I create for X?" is a
+ * question, "create the files for X" is a request.
+ *
+ * `can|could|would|do` are deliberately NOT here — "Can you create the
+ * project?" is a polite REQUEST, and treating it as analysis would leave the
+ * most common phrasing unauthorized.
+ */
+const ANALYSIS_OPENER_RE = /^\s*(?:how|why|what|when|which|who|whom|whose|explain|describe|summari[sz]e|compare|tell\s+me|walk\s+me|help\s+me\s+understand)\b/i;
+/** "yes", "go ahead", "do it" — a confirmation of work already proposed. */
+const SHORT_AFFIRMATIVE_RE = /^\s*(?:yes|yep|yeah|ok(?:ay)?|sure|please\s+do|go\s+ahead|proceed|continue|carry\s+on|do\s+it|go\s+for\s+it|make\s+it\s+so)\b/i;
+/** Continuing in-flight work needs no new authorization — the ask was it. */
+const CONTINUATION_RE = /\b(?:continue|carry\s+on|keep\s+going|go\s+ahead|proceed|finish|complete\s+(?:it|the|this|the\s+remaining)|do\s+the\s+remaining|resume)\b/i;
+/**
+ * Does this request authorize the agent to CREATE files?
+ *
+ * This is the input the write gate was missing. The gate was binary — "confirm
+ * or refuse" — with no notion of a request that had ALREADY authorized the
+ * work, so an unattended run whose ask was literally "write a 12 page story"
+ * stopped to ask "Do you want me to create the files?". That is not caution;
+ * it is the manual cadence, and over a chat surface it is a round trip that
+ * produces nothing.
+ *
+ * Evidence order: an explicit confirmation of proposed work, then a
+ * continuation, then a named destination path, then a creation verb applied to
+ * a file-shaped deliverable. An analysis/interrogative opener vetoes the last
+ * two, so "explain how to write a story to a file" stays a question.
+ *
+ * Deliberately conservative: anything it does not recognise is NOT authorized,
+ * which keeps today's confirm-or-refuse gate exactly as strict as it was.
+ */
+export function requestAuthorizesWrites(request) {
+    const text = (request || '').trim();
+    if (!text)
+        return { authorized: false, reason: 'no request text to judge' };
+    if (text.length <= 40 && SHORT_AFFIRMATIVE_RE.test(text)) {
+        return { authorized: true, reason: 'the user confirmed the work already proposed' };
+    }
+    if (CONTINUATION_RE.test(text)) {
+        return { authorized: true, reason: 'the request continues work that was already authorized' };
+    }
+    const analyzing = ANALYSIS_OPENER_RE.test(text);
+    if (PATH_RE.test(text) && CREATE_VERB_RE.test(text) && !analyzing) {
+        return { authorized: true, reason: 'the request names a destination path for the work' };
+    }
+    if (analyzing) {
+        return { authorized: false, reason: 'the request asks ABOUT the work rather than for it to be produced' };
+    }
+    if (CREATE_VERB_RE.test(text) && DELIVERABLE_NOUN_RE.test(text)) {
+        return { authorized: true, reason: 'the request asks for a file-shaped deliverable' };
+    }
+    // The noun list names ARTIFACT TYPES (file, app, story, script…), so it misses
+    // the most common dev ask there is: "fix the calculator" names no artifact at
+    // all, and this verdict came back NOT authorized — which meant the edit gate
+    // would still stop to ask for permission to fix the thing the user asked to
+    // have fixed. A directive verb is its own evidence: it asks for a change to
+    // work that already exists.
+    if (MAINTENANCE_VERB_RE.test(text)) {
+        return { authorized: true, reason: 'the request directs a change to work that already exists' };
+    }
+    return { authorized: false, reason: 'the request does not ask for files to be created' };
+}
+/**
+ * A request that asks for the work to be recorded in git history.
+ *
+ * `git commit` was gated behind `confirm:true` "after the user approved via
+ * ask_user" — but when the user's ask IS "commit these changes", they have
+ * already approved and the gate is a round trip in the most common dev flow.
+ * Like every other rule here, the evidence has to come from the request text.
+ *
+ * A NEGATED commit ("don't commit yet") is explicitly not a request for one,
+ * and an analysis opener ("how do I commit?") is asking ABOUT it.
+ */
+export function requestRequestsCommit(request) {
+    const text = (request || '').trim();
+    if (!text)
+        return false;
+    if (ANALYSIS_OPENER_RE.test(text))
+        return false;
+    if (/\b(?:don'?t|do\s+not|never|no|without)\s+(?:\w+\s+){0,2}commit\b/i.test(text))
+        return false;
+    return /\b(?:commit|check[\s-]?in)\b/i.test(text);
+}
+/** Escape a literal for use inside a RegExp. */
+function escapeRegexLiteral(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Does the request name THIS file?
+ *
+ * The evidence an edit gate needs: "fix calc.ts" names the file, "update the
+ * README" names it. Compared on the BASENAME too, because a request says
+ * `calc.ts` for `src/lib/calc.ts` — that is how people actually write, and
+ * requiring the full path would make the rule dead on arrival.
+ *
+ * Deliberately literal (the basename or the path, as a whole word): a fuzzy
+ * match would let "write a story" claim `story.md` and turn a create into an
+ * unreviewed overwrite.
+ */
+export function requestNamesPath(request, path) {
+    const text = (request || '').trim();
+    if (!text)
+        return false;
+    const base = path.split(/[\\/]/).pop() ?? '';
+    const candidates = [base, path].filter((c) => c.length >= 3);
+    return candidates.some((c) => new RegExp(`(?:^|[^\\w.\\/-])${escapeRegexLiteral(c)}(?:$|[^\\w.\\/-])`, 'i').test(text));
+}
+/**
+ * Above this share of a file being rewritten, an edit is a REPLACEMENT rather
+ * than a surgical change — and replacing most of what exists is the user's call,
+ * for the same reason write_file's overwrite case is.
+ */
+export const EDIT_SURGICAL_MAX_FRACTION = 0.5;
+/**
+ * Is this edit surgical — does it preserve most of the file it touches?
+ *
+ * The measurable line between "a fix inside a file" and "a rewrite of the
+ * file". A surgical edit is the iteration the verify loop is built around
+ * (run → read the failure → edit → re-run); a rewrite is a judgment call.
+ */
+export function isSurgicalEdit(fileChars, oldChars, newChars) {
+    if (!Number.isFinite(fileChars) || fileChars <= 0)
+        return false;
+    const touched = Math.max(oldChars, newChars);
+    return touched / fileChars <= EDIT_SURGICAL_MAX_FRACTION;
+}
+// ── Permission-seeking detection ────────────────────────────────────────────
+/** Direct permission requests: "do you want me to …", "shall I …". */
+const PERMISSION_ASK_RE = /\b(?:do\s+you\s+want\s+(?:me|for\s+me)\s+to|would\s+you\s+like\s+(?:me|for\s+me)\s+to|want\s+me\s+to|like\s+me\s+to|shall\s+i|should\s+i|may\s+i|am\s+i\s+allowed\s+to|is\s+it\s+ok(?:ay)?\s+(?:if|to)|do\s+you\s+want\s+me\s+to|ready\s+to\s+proceed|ok(?:ay)?\s+to\s+proceed)\b/i;
+/** Awaiting-a-human phrasings: "awaiting your confirmation", "let me know if…". */
+const PERMISSION_AWAIT_RE = /\b(?:awaiting|waiting\s+for|need)\s+(?:your|the\s+user'?s?)\s+(?:approval|confirmation|go-?ahead|permission|sign-?off|consent|green\s*light)\b|\b(?:your|the\s+user'?s?)\s+(?:approval|confirmation|go-?ahead|permission|sign-?off)\b|\b(?:if|once|when)\s+you\s+(?:approve|confirm|give\s+me\s+the\s+(?:go-?ahead|green\s*light|ok))\b|\blet\s+me\s+know\s+(?:if|whether)\s+you(?:'d|\s+would)?\s+(?:like|want)\b|\bplease\s+(?:confirm|approve)\b/i;
+/**
+ * A question that PROPOSES doing the work rather than asking about it —
+ * "Create the Mahagatha interactive-book project with 20 chapter pages…?"
+ * (the exact shape that ended a live unattended turn).
+ */
+const PROPOSAL_QUESTION_RE = /\?\s*$/;
+/** Sentence split that keeps the shape of the original text for callers that
+ * need to CUT rather than merely match. */
+function splitSentences(text) {
+    return text
+        .split(/(?<=[.!?。！？])\s+|\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/** Is this ONE sentence a request for permission / a proposal to do the work? */
+export function isPermissionSeekingSentence(sentence) {
+    const s = (sentence || '').trim();
+    if (!s)
+        return false;
+    if (PERMISSION_ASK_RE.test(s) || PERMISSION_AWAIT_RE.test(s))
+        return true;
+    // A question that proposes CREATE_VERB + DELIVERABLE is asking WHETHER to do
+    // the work, not asking about it (the "Create the Mahagatha project…?" shape).
+    return PROPOSAL_QUESTION_RE.test(s) && CREATE_VERB_RE.test(s) && DELIVERABLE_NOUN_RE.test(s);
+}
+/**
+ * True when the answer CLOSES by asking permission to do work, rather than
+ * delivering it.
+ *
+ * The distinction that matters: "should I proceed?" is a stall, while "which
+ * title do you prefer?" is a genuine question. This detector only claims the
+ * permission-seeking half — callers AND it with an authorization verdict, so a
+ * question about work that was never authorized is untouched.
+ *
+ * Only the closing sentences are judged: a question mid-answer followed by the
+ * actual deliverable is narration, not a stall.
+ */
+export function detectPermissionSeeking(content) {
+    const text = (content || '').trim();
+    if (!text)
+        return false;
+    return splitSentences(text).slice(-2).some(isPermissionSeekingSentence);
+}
+/**
+ * Remove the trailing permission-seeking sentences from an answer, keeping
+ * everything before them VERBATIM (deliverables are prose — re-joining split
+ * sentences would reformat the work itself).
+ *
+ * Used when a turn is nudged to proceed: the real work in that step must stay
+ * a candidate answer, but the question around it must not be what the user is
+ * handed — otherwise a longer "…Do you want me to…?" outranks a shorter, real
+ * follow-up answer under the loop's longest-substantive rule.
+ */
+export function stripTrailingPermissionSeek(content) {
+    let out = (content || '').trim();
+    // Two sentences is the detection window — never cut deeper than it can see.
+    for (let i = 0; i < 2; i += 1) {
+        const sentences = splitSentences(out);
+        const last = sentences[sentences.length - 1];
+        if (!last || !isPermissionSeekingSentence(last))
+            break;
+        const at = out.lastIndexOf(last);
+        if (at <= 0)
+            return '';
+        out = out.slice(0, at).trim();
+    }
+    return out;
+}
+/**
+ * Actions that cannot be undone by re-running the agent. A question that names
+ * one of these is NEVER treated as reflexive permission-seeking, because the
+ * user genuinely has to own it.
+ */
+export const IRREVERSIBLE_ACTION_RE = /\b(?:delete|remove|erase|overwrite|replace\s+(?:the\s+)?existing|publish|deploy|push|force|reset|drop|truncate|uninstall|wipe|send|email|charge|pay|bill|refund|order|purchase)\b/i;
+/** Decide whether a state-changing write proceeds or asks the user. */
+export function decideWriteConfirmation(request) {
+    if (!request.authorizedByRequest) {
+        return {
+            action: 'ask',
+            reason: 'the request did not ask for files to be created, so this write is not the user’s stated intent',
+        };
+    }
+    if (request.exists) {
+        return {
+            action: 'ask',
+            reason: `'${request.path}' already exists — replacing existing content cannot be undone by re-running, so it is the user’s call`,
+        };
+    }
+    return {
+        action: 'proceed',
+        reason: 'the request asked for this file and nothing exists at that path yet — creating it destroys nothing and is undone by deleting it, so a round trip would be the manual cadence',
+    };
+}
+/**
+ * Decide whether a state-changing action proceeds or asks the user.
+ *
+ * Order matters, and the two never-autonomous classes are settled first so no
+ * later rule can turn them into an autonomous action:
+ *
+ *   1. DESTRUCTIVE -> ask. Permanent, so it stays the user's call even when
+ *      they named it: one round trip is cheap, being wrong is not.
+ *   2. EXTERNAL -> ask. Someone else sees it, or it is billed.
+ *   3. NEITHER AUTHORIZED NOR NAMED -> ask. This is the original strictness
+ *      (and the no-loop-context default) untouched.
+ *   4. NAMED BY THE REQUEST -> proceed. The user's own words are the
+ *      authorization; re-asking is a round trip with no new information.
+ *   5. AUTHORIZED + RECOVERABLE -> proceed. The work was ordered and the change
+ *      cannot strand the user.
+ *   6. OTHERWISE -> ask. Authorized but neither named nor measurably
+ *      recoverable is exactly the case where a surprise is possible.
+ */
+export function decideStateChange(request) {
+    if (request.changeClass === 'destructive') {
+        return {
+            action: 'ask',
+            reason: `${request.action} removes or irrecoverably replaces content that already exists — that is permanent, so it stays the user’s call`,
+        };
+    }
+    if (request.changeClass === 'external') {
+        return {
+            action: 'ask',
+            reason: `${request.action} has an effect outside this machine (visible to others, billed, or unrecoverable) — the user owns that decision`,
+        };
+    }
+    const named = request.namedByRequest === true;
+    if (request.authorizedByRequest !== true && !named) {
+        return {
+            action: 'ask',
+            reason: 'the request did not ask for this work, so carrying it out would be a surprise',
+        };
+    }
+    if (named) {
+        return {
+            action: 'proceed',
+            reason: 'the request itself names this action — asking again would be a round trip with no new information',
+        };
+    }
+    if (request.recoverable === true) {
+        return {
+            action: 'proceed',
+            reason: 'the request asked for this work and the change is recoverable, so deciding it is the agent’s job',
+        };
+    }
+    return {
+        action: 'ask',
+        reason: `${request.action} replaces too much of what already exists to assume it — a re-run cannot recover it, so it is the user’s call`,
+    };
+}
+// ── run_cli: which gated intents may be decided autonomously ───────────────
+/**
+ * Confirmation-gated CLI intents that cannot be undone by re-running the
+ * agent: irreversible data loss, or an effect outside this machine.
+ *
+ * These keep their gate even when the request names them. One round trip is a
+ * small price for a decision that cannot be taken back.
+ */
+export const IRREVERSIBLE_CLI_INTENTS = new Set([
+    'history.clear',
+    'memory.prune',
+    'stats.cost.clear',
+    'publish',
+]);
+/**
+ * Confirmation-gated CLI intents that ARE recoverable: a service that can be
+ * started again, config that can be re-added, a cache that rebuilds, a skill
+ * that reinstalls.
+ *
+ * These proceed when the user's own request resolves to the exact command. The
+ * manifest flag exists because the ACTION is stateful, not because the user
+ * needs to approve what they just asked for.
+ */
+export const RECOVERABLE_CLI_INTENTS = new Set([
+    'dashboard.stop',
+    'gateway.stop',
+    'health.selfheal',
+    'memory.optimize',
+    'cache.clear',
+    'skills.uninstall',
+    'contacts.remove',
+    'permissions.disallow',
+    'platform.remove',
+    'cron.remove',
+]);
+/**
+ * Decide a confirmation-gated CLI intent.
+ *
+ * Note what this does NOT consult: {@link requestAuthorizesWrites}. That verdict
+ * answers "did the request ask for files to be created" — the wrong lens for a
+ * system ask like "stop the dashboard", which would read as unauthorized and
+ * defeat the whole rule. The evidence that matters here is whether the USER'S
+ * OWN WORDS resolve to this exact command (the caller resolves them with the
+ * same router, so the tool's ask and the user's ask are compared like for like).
+ */
+export function decideCliIntentConfirmation(request) {
+    if (IRREVERSIBLE_CLI_INTENTS.has(request.intent)) {
+        return {
+            action: 'ask',
+            reason: `'${request.intent}' cannot be undone by re-running — one round trip is cheap, and being wrong is not`,
+        };
+    }
+    if (RECOVERABLE_CLI_INTENTS.has(request.intent)) {
+        return request.namedByRequest
+            ? {
+                action: 'proceed',
+                reason: `the user's own request resolves to '${request.intent}' — asking them to confirm what they just asked for is the manual cadence`,
+            }
+            : {
+                action: 'ask',
+                reason: `'${request.intent}' was not what the user asked for — it is the agent's own initiative, so it is their call`,
+            };
+    }
+    return {
+        action: 'ask',
+        reason: `'${request.intent}' is confirmation-gated and not classified as recoverable — asking`,
+    };
+}
+/**
+ * The line shown when the agent decides something on the user's behalf.
+ *
+ * Reported, never silent: the user must be able to see and reverse a judgment
+ * call. A decision that is invisible is indistinguishable from a bug.
+ */
+export function autonomouslyDecidedLine(question, choice, reason) {
+    return `🤖 Decided without asking — ${question} → **${choice}** (${reason}). Say the word and I'll change it.`;
+}
+/**
+ * The line shown when the agent genuinely cannot decide for the user.
+ *
+ * Deliberately shaped for a one-word reply: the recommendation and the
+ * fallback are both named, so the user is confirming rather than composing.
+ */
+export function consultLine(request, verdict) {
+    const options = (request.options ?? []).slice(0, 4);
+    const parts = [`❓ I need your call on this: ${request.question}`, `_${verdict.reason}_`];
+    if (options.length > 1) {
+        parts.push('', 'Options:', ...options.map((o, i) => `${i + 1}. ${o}`));
+    }
+    if (request.defaultChoice) {
+        parts.push('', `My recommendation: **${request.defaultChoice}** — say "go" and I'll take it.`);
+    }
+    return parts.join('\n');
+}
+//# sourceMappingURL=autonomy-policy.js.map

package/dist/learning/autonomy-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-policy.js","sourceRoot":"","sources":["../../src/learning/autonomy-policy.ts"],"names":[],"mappings":"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"}

package/dist/learning/credential-fingerprint.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Credential Fingerprint — notice when the user's keys change, and re-probe.
+ *
+ * WHY THIS EXISTS. The routing pool can only contain models a probe has
+ * VERIFIED, and a probe only ever ran on a cold start or a maintenance command.
+ * So a purchase made mid-session — the exact case where a user expects the new
+ * models to appear — changed nothing: the credential was fine, the catalog was
+ * stale, and the next run would have picked the models up only if it happened to
+ * cold-start. There is no per-model entitlement API to ask ("may I buy
+ * `meta-llama/...`?" is not a question OpenRouter answers); the only honest
+ * signal is *"we sent one token with this key and it answered"*. But it is
+ * genuinely cheap to notice that the KEY SET changed and force that probe
+ * instead of waiting for an accident.
+ *
+ * WHAT IS STORED: a SHA-256 digest of the credential SHAPE — which providers are
+ * configured, a digest of each key, each base URL, each env-var presence. Never
+ * a key, not even truncated, and the digest is one-way, so the file is safe to
+ * read, copy or commit by accident. Its only job is equality.
+ */
+import type { ConfigManager } from '../config/manager.js';
+/** Sidecar file (under the memory dir) holding the last-seen credential shape. */
+export declare const CREDENTIAL_FINGERPRINT_FILENAME = "credential-fingerprint.json";
+/** Path of the fingerprint sidecar (exported so tests can redirect it). */
+export declare function credentialFingerprintPath(): string;
+/**
+ * The credential SHAPE, as a list of comparable lines.
+ *
+ * Exported (and separate from the hashing) so a test — or a support call — can
+ * see exactly which inputs are considered without needing to reverse a digest.
+ * The lines carry digests, never keys.
+ */
+export declare function credentialShapeInputs(configManager: ConfigManager): string[];
+/** SHA-256 digest of the credential shape. Safe to log. */
+export declare function credentialFingerprint(configManager: ConfigManager): string;
+export interface CredentialChange {
+    /** True when the shape differs from the last one recorded. */
+    changed: boolean;
+    /** True when nothing had been recorded yet (no comparison was possible). */
+    firstRun: boolean;
+    /** The shape as of this call — already recorded by the time this returns. */
+    fingerprint: string;
+    /** The previously recorded shape, when there was one. */
+    previous?: string;
+}
+/**
+ * Compare the current credential shape against the last one recorded and RECORD
+ * the new one.
+ *
+ * Recording on every call is what makes this fire once per change rather than
+ * once per cycle: the caller sees `changed: true` a single time and can force a
+ * probe, and every later call in the same process is a no-op. `firstRun` is
+ * reported separately because "no previous record" is not evidence of a change —
+ * a fresh machine must not be treated as though a purchase just landed.
+ */
+export declare function detectCredentialChange(configManager: ConfigManager, options?: {
+    path?: string;
+}): CredentialChange;
+//# sourceMappingURL=credential-fingerprint.d.ts.map

package/dist/learning/credential-fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-fingerprint.d.ts","sourceRoot":"","sources":["../../src/learning/credential-fingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,kFAAkF;AAClF,eAAO,MAAM,+BAA+B,gCAAgC,CAAC;AAQ7E,2EAA2E;AAC3E,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAOD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,EAAE,CAmC5E;AAED,2DAA2D;AAC3D,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,CAE1E;AAED,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,EAC5B,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9B,gBAAgB,CA4BlB"}