sneakoscope 10.2.0 → 10.3.0

package/dist/core/decisions/evaluation.js

@@ -0,0 +1,62 @@
+export function percentile(values, p) {
+    const sorted = values.filter((value) => Number.isFinite(value)).sort((left, right) => left - right);
+    if (!sorted.length)
+        return null;
+    const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+    return sorted[rank] ?? null;
+}
+export const EVALUATION_SCHEMA = 'sks.jev-evaluation.v1';
+export function buildEvaluationReport(input) {
+    const unavailable = [];
+    const rows = [...input.rows];
+    if (rows.length === 0)
+        unavailable.push('no_labeled_tasks');
+    const success = rows.map((row) => row.success).filter((value) => value !== null);
+    const escaped = rows.map((row) => row.escapedFailure).filter((value) => value !== null);
+    const wall = rows.map((row) => row.wallClockMs).filter((value) => Number.isFinite(value));
+    const overhead = rows.map((row) => row.jevOverheadMs).filter((value) => Number.isFinite(value));
+    const tokenKnown = rows.every((row) => row.tokenEvidence === 'provider_response');
+    if (!tokenKnown)
+        unavailable.push('token_savings_unavailable');
+    const inputTokens = tokenKnown
+        ? sum(rows.map((row) => row.inputTokens))
+        : null;
+    const outputTokens = tokenKnown
+        ? sum(rows.map((row) => row.outputTokens))
+        : null;
+    const cost = rows.some((row) => row.reportedCost === null)
+        ? null
+        : sum(rows.map((row) => row.reportedCost));
+    if (cost === null)
+        unavailable.push('cost_unavailable');
+    const successes = rows.filter((row) => row.success === true).length;
+    const costPerSuccess = cost === null || successes === 0 ? null : cost / successes;
+    const coverage = rows.filter((row) => row.coveragePreserved).length;
+    return {
+        schema: EVALUATION_SCHEMA,
+        evidenceLevel: input.evidenceLevel || 'synthetic',
+        live: input.live === true,
+        arms: [...new Set(rows.map((row) => row.arm))],
+        taskCount: rows.length,
+        metrics: {
+            taskSuccessRate: success.length ? success.filter(Boolean).length / success.length : null,
+            escapedFailureRate: escaped.length ? escaped.filter(Boolean).length / escaped.length : null,
+            wallClockP50Ms: percentile(wall, 50),
+            wallClockP95Ms: percentile(wall, 95),
+            jevOverheadP50Ms: percentile(overhead, 50),
+            llmRejudgeCalls: rows.reduce((sumValue, row) => sumValue + row.llmRejudgeCalls, 0),
+            inputTokens,
+            outputTokens,
+            reportedCost: cost,
+            costPerSuccessfulTask: costPerSuccess,
+            coveragePreservedRate: rows.length ? coverage / rows.length : null
+        },
+        unavailableReasons: [...unavailable],
+        receipts: [...(input.receipts || [])]
+    };
+}
+function sum(values) {
+    if (values.some((value) => value === null || !Number.isFinite(value)))
+        return null;
+    return values.reduce((total, value) => total + (value || 0), 0);
+}

package/dist/core/decisions/integration.js

@@ -0,0 +1,262 @@
+import { sha256 } from '../fsx.js';
+import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
+import { jevEnabled, readDecisionConfig } from './config.js';
+import { requestOpenRouterDecision } from './openrouter.js';
+import { compileDecision } from './policy.js';
+import { buildDecisionBundle, validatePlanCoverage } from './questions.js';
+import { applyRecoveryEffect, listProductionRecoveryCandidates } from './recovery.js';
+import { assembleRoutingSelection, buildRoutingCandidates } from './routing.js';
+import { buildDecisionReceipt } from './receipt.js';
+import { applyOptionalContextSelection, graphFileDigest, hydrateContextCandidates, sourceSnapshotDigest } from './state.js';
+import { DESIGN_DEFAULTS, POLICY_REVISION, UNKNOWN_USAGE } from './types.js';
+let testOverrides = null;
+const appliedEffects = new Set();
+export function setDecisionTestOverrides(overrides) {
+    testOverrides = overrides;
+}
+function activeOverrides() {
+    return process.env.SKS_JEV_DECISION_TEST_OVERRIDES === '1' ? testOverrides : null;
+}
+export async function decideOfficialSubagentPreparation(input) {
+    const started = Date.now();
+    try {
+        return await decideOfficialSubagentPreparationInner(input, started);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AssertionError')
+            throw error;
+        return keep(input, 'transport_error', started);
+    }
+}
+async function decideOfficialSubagentPreparationInner(input, started) {
+    const overrides = activeOverrides();
+    const env = input.env || process.env;
+    const config = overrides?.config ?? await readDecisionConfig(env);
+    const baseline = keep(input, 'off', started);
+    if (!jevEnabled(config)) {
+        overrides?.observe?.({ mode: config.mode, eligible: false, compiled: baseline.compiled, receipt: baseline.receipt });
+        return baseline;
+    }
+    const resolved = await resolveOpenRouterApiKey({ env });
+    if (!resolved.key) {
+        const missing = keep(input, 'missing_key', started);
+        overrides?.observe?.({ mode: config.mode, eligible: false, compiled: missing.compiled, receipt: missing.receipt });
+        return missing;
+    }
+    const contextCandidates = config.capabilities.context.ready
+        ? await hydrateContextCandidates(input.root, input.attention, input.changedPaths || [])
+        : [];
+    const planCandidates = config.capabilities.plan.ready && input.requestedSource === 'automatic'
+        ? buildAutomaticPlanCandidates(input)
+        : [];
+    const routingCandidates = input.requestedSource === 'automatic'
+        ? buildRoutingCandidates({ roles: input.routingRoles || [] })
+        : [];
+    const recoveryCandidates = config.capabilities.recovery.ready
+        ? [...listProductionRecoveryCandidates()]
+        : [];
+    const optionalContext = contextCandidates.filter((row) => !row.pinned && row.excerpt);
+    const eligible = planCandidates.length > 1 || routingCandidates.length > 0 || optionalContext.length > 0 || recoveryCandidates.length > 0;
+    if (!eligible) {
+        const compiled = keep(input, 'no_alternative', started);
+        overrides?.observe?.({ mode: config.mode, eligible: false, compiled: compiled.compiled, receipt: compiled.receipt });
+        return compiled;
+    }
+    const sourceDigest = await sourceSnapshotDigest(input.root);
+    const graphDigest = input.attention?.snapshot_hash || await graphFileDigest(input.root);
+    const bundle = buildDecisionBundle({
+        projectId: sha256(input.root).slice(0, 32),
+        workflowRunId: input.workflowRunId,
+        workflowRevision: input.workflowRevision,
+        sourceDigest,
+        graphDigest,
+        goal: input.goal,
+        planCandidates,
+        contextCandidates,
+        recoveryCandidates,
+        routingCandidates,
+        baselinePlanId: planCandidates[0]?.id ?? null,
+        requiredSliceIds: planCandidates[0]?.sliceIds ?? input.slices.map((slice) => slice.id),
+        requiredVerificationIds: ['review_coverage']
+    });
+    const fetchImpl = input.fetchImpl || overrides?.fetchImpl;
+    const transport = await requestOpenRouterDecision(bundle, {
+        env,
+        deadlineMs: input.deadlineMs ?? DESIGN_DEFAULTS.deadlineMs,
+        ...(fetchImpl ? { fetchImpl } : {}),
+        ...(input.signal ? { signal: input.signal } : {})
+    });
+    const compiled = transport.ok
+        ? compileDecision(bundle, transport.response)
+        : {
+            kind: 'keep_baseline',
+            binding: bundle.binding,
+            reason: transport.reason,
+            usage: transport.usage
+        };
+    const applied = compiled.kind === 'apply'
+        ? applyEffects(input.attention, contextCandidates, planCandidates, compiled)
+        : {
+            attention: input.attention,
+            selectedPlan: null,
+            selectedRouting: null,
+            selectedContextIds: null,
+            consumptionEvidence: null
+        };
+    const receipt = buildDecisionReceipt({
+        binding: bundle.binding,
+        compiled,
+        result: compiled.kind === 'apply' ? 'applied' : 'kept_baseline',
+        reason: compiled.kind === 'apply' ? compiled.effects.map((effect) => effect.kind).join(',') : compiled.reason,
+        elapsedMs: Date.now() - started,
+        cacheHit: transport.ok && transport.cacheHit,
+        resolvedModel: transport.ok ? transport.resolvedModel : null,
+        responseId: transport.ok ? transport.responseId : null,
+        consumptionEvidence: applied.consumptionEvidence,
+        env
+    });
+    const result = {
+        compiled,
+        receipt,
+        attention: applied.attention,
+        selectedPlan: applied.selectedPlan,
+        selectedRouting: applied.selectedRouting,
+        selectedContextIds: applied.selectedContextIds,
+        llmRejudgeCalls: 0,
+        bundle
+    };
+    overrides?.observe?.({ mode: config.mode, eligible: true, compiled, receipt });
+    return result;
+}
+export function effectAlreadyConsumed(identity) {
+    return appliedEffects.has(identity);
+}
+export function markEffectConsumed(identity) {
+    if (appliedEffects.has(identity))
+        return false;
+    if (appliedEffects.size >= 256) {
+        const oldest = appliedEffects.values().next().value;
+        if (oldest !== undefined)
+            appliedEffects.delete(oldest);
+    }
+    appliedEffects.add(identity);
+    return true;
+}
+export async function dispatchBoundRecovery(input) {
+    if (!markEffectConsumed(input.consumptionIdentity)) {
+        return { invoked: false, reason: 'duplicate_delivery', consumptionEvidence: null };
+    }
+    const result = await applyRecoveryEffect(input);
+    if (!result.ok)
+        return { invoked: false, reason: result.reason, consumptionEvidence: null };
+    return { invoked: true, reason: 'applied', consumptionEvidence: result.consumptionEvidence };
+}
+function applyEffects(attention, contextCandidates, planCandidates, compiled) {
+    let nextAttention = attention;
+    let selectedPlan = null;
+    let selectedContextIds = null;
+    const evidence = [];
+    const routingEffects = [];
+    for (const effect of compiled.effects) {
+        if (effect.kind === 'select_optional_context') {
+            nextAttention = applyOptionalContextSelection(attention, contextCandidates, effect.keepIds);
+            selectedContextIds = effect.keepIds;
+            evidence.push(`context:${effect.keepIds.join(',')}`);
+        }
+        if (effect.kind === 'select_plan') {
+            selectedPlan = planCandidates.find((row) => row.id === effect.planId) || null;
+            if (selectedPlan)
+                evidence.push(`plan:${selectedPlan.id}`);
+        }
+        if (effect.kind === 'select_routing') {
+            routingEffects.push({ roleId: effect.roleId, model: effect.model });
+        }
+    }
+    const selectedRouting = assembleRoutingSelection(routingEffects);
+    if (selectedRouting) {
+        evidence.push(...Object.entries(selectedRouting.models).map(([roleId, model]) => `routing:${roleId}=${model}`));
+    }
+    return {
+        attention: nextAttention,
+        selectedPlan,
+        selectedRouting,
+        selectedContextIds,
+        consumptionEvidence: evidence.length ? evidence.join('|') : null
+    };
+}
+function buildAutomaticPlanCandidates(input) {
+    const slices = input.slices.filter((slice) => slice.id);
+    const sliceIds = slices.map((slice) => slice.id);
+    const workerCount = Math.max(1, input.requestedSubagents);
+    if (workerCount < 2)
+        return [];
+    const verification = ['review_coverage'];
+    const covered = sliceIds.length > 0 ? sliceIds : ['parent_owned_decomposition'];
+    const baselineGroups = slices.length > 0
+        ? slices.map((slice, index) => ({
+            id: `G${index + 1}`,
+            sliceIds: [slice.id],
+            role: slice.agent || (slice.kind === 'expert' ? 'expert' : 'worker'),
+            effort: slice.kind === 'expert' ? 'max' : 'low'
+        }))
+        : [{ id: 'G1', sliceIds: covered, role: 'expert', effort: 'max' }];
+    const baseline = {
+        id: 'baseline',
+        summary: sliceIds.length > 0
+            ? `Execute every required slice with ${workerCount} permitted workers.`
+            : `Execute the automatic parent-owned work with ${workerCount} permitted workers. The parent still decomposes slices.`,
+        sliceIds: covered,
+        groups: baselineGroups,
+        workerCount,
+        requiredVerificationIds: verification
+    };
+    const grouped = {
+        id: 'grouped',
+        summary: sliceIds.length > 0
+            ? 'Execute every required slice in one permitted worker group, preserving full coverage.'
+            : 'Execute the automatic parent-owned work in one permitted worker group. The parent still decomposes slices.',
+        sliceIds: covered,
+        groups: [{ id: 'G1', sliceIds: covered, role: 'expert', effort: 'max' }],
+        workerCount: 1,
+        requiredVerificationIds: verification
+    };
+    const candidates = [baseline, grouped].filter((candidate) => validatePlanCoverage(covered, candidate).length === 0);
+    const workerCounts = new Set(candidates.map((candidate) => candidate.workerCount));
+    if (candidates.length < 2 || workerCounts.size < 2)
+        return [];
+    return candidates;
+}
+function keep(input, reason, started) {
+    const compiled = {
+        kind: 'keep_baseline',
+        binding: {
+            projectId: sha256(input.root).slice(0, 32),
+            workflowRunId: input.workflowRunId,
+            workflowRevision: input.workflowRevision,
+            sourceDigest: 'uncomputed',
+            graphDigest: input.attention?.snapshot_hash ?? null,
+            candidateDigest: 'none',
+            questionDigest: 'none',
+            policyRevision: POLICY_REVISION,
+            requestedModel: DESIGN_DEFAULTS.model
+        },
+        reason,
+        usage: { ...UNKNOWN_USAGE }
+    };
+    return {
+        compiled,
+        receipt: buildDecisionReceipt({
+            binding: compiled.binding,
+            compiled,
+            result: 'kept_baseline',
+            reason,
+            elapsedMs: Date.now() - started
+        }),
+        attention: input.attention,
+        selectedPlan: null,
+        selectedRouting: null,
+        selectedContextIds: null,
+        llmRejudgeCalls: 0,
+        bundle: null
+    };
+}

package/dist/core/decisions/openrouter.js

@@ -0,0 +1,270 @@
+import { officialSubagentLifecycleLockHeld } from '../subagents/official-subagent-lock.js';
+import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
+import { redactOpenRouterSecrets, redactOpenRouterString } from '../security/redact-secrets.js';
+import { decodeUsage, decodeWireResponse } from './policy.js';
+import { DESIGN_DEFAULTS, UNKNOWN_USAGE } from './types.js';
+export const OPENROUTER_DECISIONS_ENDPOINT = DESIGN_DEFAULTS.endpoint;
+export const OPENROUTER_DECISIONS_MODEL = DESIGN_DEFAULTS.model;
+const inflight = { count: 0 };
+const circuit = {
+    failures: 0,
+    openedAt: 0,
+    halfOpen: false
+};
+const memo = new Map();
+export function resetDecisionTransportState() {
+    inflight.count = 0;
+    circuit.failures = 0;
+    circuit.openedAt = 0;
+    circuit.halfOpen = false;
+    memo.clear();
+}
+export async function requestOpenRouterDecision(bundle, options = {}) {
+    if (officialSubagentLifecycleLockHeld()) {
+        return fail('transport_error', 'fetch_while_lifecycle_lock_held', null);
+    }
+    const request = bundle.request;
+    const encoded = encodeRequest(request);
+    if (!encoded.ok)
+        return fail(encoded.reason, encoded.detail, null);
+    if (inflight.count >= DESIGN_DEFAULTS.maxInFlight) {
+        return fail('busy', 'max_in_flight', null);
+    }
+    const now = options.now || Date.now;
+    const circuitState = inspectCircuit(now());
+    if (circuitState === 'open')
+        return fail('circuit_open', 'circuit_open', null);
+    const memoKey = encoded.body;
+    const cached = memo.get(memoKey);
+    if (cached) {
+        const decoded = decodeWireResponse(bundle, cached.response);
+        if (decoded.ok) {
+            return {
+                ok: true,
+                response: decoded.response,
+                usage: {
+                    inputTokens: decoded.response.usage.input_tokens,
+                    outputTokens: decoded.response.usage.output_tokens,
+                    reportedCost: decoded.response.usage.cost === undefined ? null : decoded.response.usage.cost,
+                    evidence: 'provider_response'
+                },
+                resolvedModel: decoded.response.model,
+                responseId: decoded.response.id || null,
+                cacheHit: true,
+                status: 200
+            };
+        }
+    }
+    const resolved = await resolveOpenRouterApiKey({ env: options.env || process.env });
+    if (!resolved.key)
+        return fail('missing_key', resolved.blockers.join(',') || 'missing_openrouter_key', null);
+    const controller = new AbortController();
+    const parent = options.signal;
+    const onAbort = () => controller.abort(parent?.reason);
+    if (parent) {
+        if (parent.aborted)
+            controller.abort(parent.reason);
+        else
+            parent.addEventListener('abort', onAbort, { once: true });
+    }
+    const deadlineMs = options.deadlineMs ?? DESIGN_DEFAULTS.deadlineMs;
+    const timer = setTimeout(() => controller.abort(Object.assign(new Error('deadline'), { name: 'TimeoutError' })), deadlineMs);
+    inflight.count += 1;
+    try {
+        const fetchImpl = options.fetchImpl || globalThis.fetch;
+        const response = await fetchImpl(OPENROUTER_DECISIONS_ENDPOINT, {
+            method: 'POST',
+            redirect: 'error',
+            headers: {
+                Authorization: `Bearer ${resolved.key}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: encoded.body,
+            signal: controller.signal
+        });
+        const status = response.status;
+        const raw = await readBoundedBody(response, DESIGN_DEFAULTS.maxResponseBytes, controller.signal);
+        if (!raw.ok)
+            return recordFailure(status, raw.reason, raw.detail, now());
+        if (status === 401)
+            return recordAuthFailure('unauthorized', status, raw.text);
+        if (status === 402)
+            return recordAuthFailure('payment_required', status, raw.text);
+        if (status === 403)
+            return recordAuthFailure(privacyUnavailable(raw.text) ? 'privacy_unavailable' : 'unauthorized', status, raw.text);
+        if (status === 404)
+            return recordAuthFailure('capability_unavailable', status, raw.text);
+        if (status === 413)
+            return recordAuthFailure('budget_exceeded', status, raw.text);
+        if (status === 429)
+            return recordFailure(status, 'rate_limited', raw.text, now());
+        if (status >= 500)
+            return recordFailure(status, 'transport_error', raw.text, now());
+        if (status !== 200)
+            return recordFailure(status, 'transport_error', raw.text, now());
+        let parsed;
+        try {
+            parsed = JSON.parse(raw.text);
+        }
+        catch {
+            return recordFailure(status, 'invalid_response', 'malformed_json', now());
+        }
+        const decoded = decodeWireResponse(bundle, parsed);
+        if (!decoded.ok)
+            return recordFailure(status, decoded.reason, 'schema_rejected', now());
+        remember(memoKey, decoded.response);
+        circuit.failures = 0;
+        circuit.halfOpen = false;
+        return {
+            ok: true,
+            response: decoded.response,
+            usage: {
+                inputTokens: decoded.response.usage.input_tokens,
+                outputTokens: decoded.response.usage.output_tokens,
+                reportedCost: decoded.response.usage.cost === undefined ? null : decoded.response.usage.cost,
+                evidence: 'provider_response'
+            },
+            resolvedModel: decoded.response.model,
+            responseId: decoded.response.id || null,
+            cacheHit: false,
+            status: 200
+        };
+    }
+    catch (error) {
+        const aborted = controller.signal.aborted || (error instanceof Error && error.name === 'AbortError');
+        const timeout = error instanceof Error && (error.name === 'TimeoutError' || /deadline/i.test(error.message));
+        if (timeout)
+            return recordFailure(null, 'deadline', 'deadline', now(), UNKNOWN_USAGE);
+        if (aborted)
+            return fail('cancelled', 'cancelled', null, UNKNOWN_USAGE);
+        if (isRedirectError(error))
+            return fail('transport_error', 'redirect_refused', null);
+        return recordFailure(null, 'transport_error', error instanceof Error ? error.message : String(error), now());
+    }
+    finally {
+        clearTimeout(timer);
+        if (parent)
+            parent.removeEventListener('abort', onAbort);
+        inflight.count = Math.max(0, inflight.count - 1);
+    }
+}
+export function encodeRequest(request) {
+    if (request.model !== DESIGN_DEFAULTS.model) {
+        return { ok: false, reason: 'unknown_model', detail: request.model };
+    }
+    const questions = Object.keys(request.questions);
+    if (questions.length === 0)
+        return { ok: false, reason: 'invalid_response', detail: 'empty_questions' };
+    if (questions.length > DESIGN_DEFAULTS.maxQuestions) {
+        return { ok: false, reason: 'budget_exceeded', detail: 'max_questions' };
+    }
+    if (request.provider.zdr !== true
+        || request.provider.data_collection !== 'deny'
+        || request.provider.allow_fallbacks !== false) {
+        return { ok: false, reason: 'privacy_unavailable', detail: 'provider_policy' };
+    }
+    const body = JSON.stringify({
+        model: request.model,
+        state: request.state,
+        questions: request.questions,
+        provider: {
+            zdr: true,
+            data_collection: 'deny',
+            allow_fallbacks: false
+        },
+        ...(request.session_id ? { session_id: request.session_id } : {})
+    });
+    if (Buffer.byteLength(body, 'utf8') > DESIGN_DEFAULTS.maxRequestBytes) {
+        return { ok: false, reason: 'budget_exceeded', detail: 'max_request_bytes' };
+    }
+    return { ok: true, body };
+}
+export function redactDecisionValue(value, env = process.env) {
+    return redactOpenRouterSecrets(value, env);
+}
+export function redactDecisionText(value, env = process.env) {
+    return redactOpenRouterString(value, env);
+}
+async function readBoundedBody(response, maxBytes, signal) {
+    if (!response.body) {
+        const text = await response.text();
+        if (Buffer.byteLength(text, 'utf8') > maxBytes) {
+            return { ok: false, reason: 'budget_exceeded', detail: 'max_response_bytes' };
+        }
+        return { ok: true, text };
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            if (signal.aborted)
+                return { ok: false, reason: 'cancelled', detail: 'cancelled' };
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value) {
+                size += value.byteLength;
+                if (size > maxBytes) {
+                    await reader.cancel();
+                    return { ok: false, reason: 'budget_exceeded', detail: 'max_response_bytes' };
+                }
+                chunks.push(value);
+            }
+        }
+    }
+    catch (error) {
+        if (signal.aborted || (error instanceof Error && error.name === 'AbortError')) {
+            return { ok: false, reason: signal.reason instanceof Error && signal.reason.name === 'TimeoutError' ? 'deadline' : 'cancelled', detail: 'body_aborted' };
+        }
+        return { ok: false, reason: 'transport_error', detail: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return { ok: true, text: Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8') };
+}
+function inspectCircuit(now) {
+    if (circuit.failures < DESIGN_DEFAULTS.circuitFailures)
+        return 'closed';
+    if (now - circuit.openedAt < DESIGN_DEFAULTS.circuitOpenMs)
+        return 'open';
+    if (circuit.halfOpen)
+        return 'open';
+    circuit.halfOpen = true;
+    return 'half_open';
+}
+function recordFailure(status, reason, detail, now, usage = UNKNOWN_USAGE) {
+    circuit.failures += 1;
+    if (circuit.failures >= DESIGN_DEFAULTS.circuitFailures && circuit.openedAt === 0) {
+        circuit.openedAt = now;
+    }
+    if (circuit.halfOpen && reason !== 'circuit_open') {
+        circuit.openedAt = now;
+        circuit.halfOpen = false;
+    }
+    return fail(reason, detail, status, usage);
+}
+function recordAuthFailure(reason, status, detail) {
+    return fail(reason, detail, status);
+}
+function fail(reason, detail, status, usage = UNKNOWN_USAGE) {
+    return { ok: false, reason, usage, status, detail, cacheHit: false };
+}
+function remember(key, response) {
+    if (memo.size >= DESIGN_DEFAULTS.memoEntries) {
+        const oldest = memo.keys().next().value;
+        if (oldest !== undefined)
+            memo.delete(oldest);
+    }
+    memo.set(key, { response, storedAt: Date.now() });
+}
+function privacyUnavailable(text) {
+    return /zdr|data_collection|allow_fallbacks|privacy|data collection/i.test(text);
+}
+function isRedirectError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /redirect/i.test(message);
+}
+export { decodeUsage };