@aiwg/cli 2026.10.3 → 2026.10.5

package/dist/src/decision/heldout/contract.js

@@ -260,26 +260,49 @@ export async function assertHeldoutRequestBounds(corpus, plan, approval) {
             }
         }
 }
-export async function planHeldoutCollection(bundle, digest) {
+/** Prior observations are reusable only within the same study, corpus and preregistration. */
+export function heldoutResumeAttempts(bundle, prior) {
+    const a = bundle.approval;
+    const old = prior.filter(attempt => attempt.study === a.study && attempt.corpusDigest === a.corpusDigest);
+    if (old.some(attempt => attempt.preregistrationDigest !== a.preregistrationDigest))
+        throw new HeldoutError('changed-preregistration');
+    const latest = new Map();
+    for (const attempt of old) {
+        const key = `${attempt.rowId}/${attempt.requestId}`, previous = latest.get(key);
+        if (previous?.result?.disposition !== 'success' && (attempt.result?.disposition === 'success'
+            || attempt.ordinal >= (previous?.ordinal ?? 0)))
+            latest.set(key, attempt);
+    }
+    return { old, latest };
+}
+/** The collector and dry-run reserve only unfinished requests, with their unspent retry allowance. */
+export function heldoutPendingRequests(row, plan, latest) {
+    return row.requests.flatMap(request => {
+        const previous = latest.get(`${row.id}/${request.id}`);
+        const first = (previous?.ordinal ?? 0) + 1, attempts = 2 + plan.providerFailurePolicy.maxRetries - first;
+        return previous?.result?.disposition === 'success' || attempts <= 0 ? [] : [{ request, first, attempts }];
+    });
+}
+export async function planHeldoutCollection(bundle, digest, prior = []) {
     validateHeldoutBundle(bundle, digest);
     await assertHeldoutRequestBounds(bundle.corpus, bundle.preregistration, bundle.approval);
-    let maximumRequestEstimateTokens = 0, tokens = 0, usdMicros = 0;
+    const { latest } = heldoutResumeAttempts(bundle, prior);
+    let maximumRequestEstimateTokens = 0, tokens = 0, usdMicros = 0, maximumAttempts = 0;
     const rows = heldoutRowsInScope(bundle);
     for (const row of rows)
-        for (const request of row.requests) {
+        for (const { request, attempts } of heldoutPendingRequests(row, bundle.preregistration, latest)) {
             const planned = await heldoutRequest(bundle.corpus, bundle.preregistration, bundle.approval, row, request);
             maximumRequestEstimateTokens = Math.max(maximumRequestEstimateTokens, planned.estimatedTokens);
             const reservation = heldoutReservationMicros(bundle.approval, planned.estimatedTokens);
             if (reservation > Math.floor(bundle.approval.budget.usd * 1_000_000))
                 throw new HeldoutError('approval-call-budget');
-            const attempts = 1 + bundle.preregistration.providerFailurePolicy.maxRetries;
+            maximumAttempts += attempts;
             tokens += attempts * heldoutReservationTokens(bundle.preregistration, planned.estimatedTokens);
             usdMicros += attempts * reservation;
         }
-    const attempts = rows.reduce((n, r) => n + r.requests.length, 0) * (1 + bundle.preregistration.providerFailurePolicy.maxRetries);
     const a = bundle.approval;
-    return { calibration: structuredClone(a.calibration), rowsInScope: rows.map(row => row.id), providerCalls: 0, maximumAttempts: attempts, maximumRequestEstimateTokens, reservedTokens: tokens, reservedUsdMicros: usdMicros,
-        fitsBeforeStop: attempts <= Math.floor(a.budget.calls * 0.8) && tokens <= Math.floor(a.budget.tokens * 0.8)
+    return { calibration: structuredClone(a.calibration), rowsInScope: rows.map(row => row.id), providerCalls: 0, maximumAttempts, maximumRequestEstimateTokens, reservedTokens: tokens, reservedUsdMicros: usdMicros,
+        fitsBeforeStop: maximumAttempts <= Math.floor(a.budget.calls * 0.8) && tokens <= Math.floor(a.budget.tokens * 0.8)
             && usdMicros <= Math.floor(Math.min(a.budget.usd, HELDOUT_CAP_USD[a.study] - a.priorStudySpendUsd, HELDOUT_PORTFOLIO_CAP_USD - a.priorPortfolioSpendUsd) * 800_000) };
 }
 /** An intentionally unapproved, unpriced form. Unknown attestations stay null, never fixture approvals. */

package/dist/src/decision/jev-credentials.js

@@ -1,3 +1,4 @@
+import { resolveDecisionEnablement } from '../config/decision-config.js';
 import { constants } from 'node:fs';
 import { access, chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import os from 'node:os';
@@ -64,7 +65,8 @@ export async function lookupJevCredential(options = {}) {
     const forced = environment.AIWG_DECISION_ENABLED;
     const envToken = environment.JEV_API_KEY?.trim() || environment.AIWG_DECISION_JEV_API_KEY?.trim();
     const fileRecord = envToken && (forced === '0' || forced === '1') ? null : await readCredentialFile(options);
-    const enabled = forced === '0' ? false : forced === '1' ? true : fileRecord?.enabled === true;
+    const enablement = resolveDecisionEnablement(options);
+    const enabled = enablement.source === 'default' ? fileRecord?.enabled === true : enablement.enabled;
     if (envToken)
         return {
             source: 'env',
@@ -78,6 +80,18 @@ export async function lookupJevCredential(options = {}) {
         return null;
     return { source: 'file', token: fileRecord.token, region: fileRecord.region, ...(fileRecord.endpoint ? { endpoint: fileRecord.endpoint } : {}), enabled };
 }
+/** Offline metadata-only inspection. Never probes Jev and never returns credential bytes. */
+export async function inspectJevCredential(options = {}) {
+    try {
+        const credential = await lookupJevCredential(options);
+        if (!credential)
+            return { configured: false, enabled: false, source: 'none' };
+        return { configured: true, enabled: credential.enabled, source: credential.source };
+    }
+    catch {
+        return { configured: null, enabled: null, source: 'unknown' };
+    }
+}
 export async function resolveJevCredentialBytes(logicalRef, options = {}) {
     if (logicalRef !== JEV_CREDENTIAL_REF)
         throw new JevCredentialError('configuration');

package/dist/src/decision/ledger.js

@@ -62,14 +62,17 @@ import { projectAiwgPath, projectAiwgWritePath } from '../config/project-artifac
 import { redactText } from '../governance/redaction.js';
 import { CanonicalJsonByteEstimator } from './context-plan.js';
 import { resolveActiveProvider } from '../cli/provider-resolution.js';
-export const DECISION_LEDGER_SCHEMA = 'aiwg-decision-ledger-record/v1';
+import { readAiwgConfig } from '../config/aiwg-config.js';
+import { decisionSavingsWeights, estimateDecisionSavings } from './savings.js';
+export const DECISION_LEDGER_SCHEMA = 'aiwg-decision-ledger-record/v2';
+export const DECISION_LEDGER_SCHEMA_V1 = 'aiwg-decision-ledger-record/v1';
 const DECISION_LEDGER_DIR_NAME = 'decision';
 const DECISION_LEDGER_FILE_NAME = 'ledger.jsonl';
 const DECISION_LEDGER_KINDS = ['yes-no', 'choices', 'scale'];
 const DECISION_LEDGER_STATUSES = ['answered', 'fallback'];
 /**
- * Per-decision-kind reasoning/output token allowance folded into the
- * "tokens avoided" estimate for answered calls. Named and recorded with
+ * Legacy v1 per-kind allowance, retained only for comparison and replay.
+ * Named and recorded with
  * every estimate (not just referenced) so the figure can be recomputed
  * later per the issue's proposal item 3.
  */
@@ -175,7 +178,7 @@ function answerIndexFor(mode, rawAnswer) {
 function contextMessageForEstimate(input) {
     return input.context === undefined || input.context === '' ? input.question : `${input.question}\n\nContext:\n${input.context}`;
 }
-function estimateSavings(input, result) {
+function estimateSavingsV1(input, result) {
     if (result.status === 'answered') {
         const inputTokens = new CanonicalJsonByteEstimator().estimate(contextMessageForEstimate(input)).tokens;
         const allowance = DECISION_SAVINGS_REASONING_ALLOWANCE_TOKENS[input.mode.kind];
@@ -185,22 +188,24 @@ function estimateSavings(input, result) {
     // Avoid signed zero (`-0`): a fallback that never called Jev (e.g. not-configured) costs nothing.
     return { estimatedLlmTokensAvoided: jevCost === 0 ? 0 : -jevCost, estimationMethod: DECISION_SAVINGS_ESTIMATION_METHOD };
 }
-/**
- * `--session`, then `AIWG_SESSION_ID`, else the literal "unknown" (no
- * harness-specific session env helper exists in this repo yet). Either
- * source is rejected down to "unknown" if it does not match the
- * attribution identifier shape — this is the safety net for the
- * environment-derived value, which (unlike `--session`) has no CLI exit
- * code to reject through.
- */
-export function resolveDecisionSessionId(explicitSessionId, env) {
+/** Ordered harness session markers; never substitute provider/process ids. */
+export const DECISION_SESSION_ENV_VARS = [
+    'AIWG_SESSION_ID', 'CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'CODEX_SESSION_ID',
+    'HERMES_SESSION_ID', 'OPENCODE_SESSION_ID', 'MUSE_SESSION_ID', 'GROK_SESSION_ID', 'WARP_SESSION_ID',
+];
+export function resolveDecisionSession(explicitSessionId, env) {
     const explicit = explicitSessionId?.trim();
     if (explicit && ATTRIBUTION_FIELD_PATTERN.test(explicit))
-        return explicit;
-    const fromEnv = env.AIWG_SESSION_ID?.trim();
-    if (fromEnv && ATTRIBUTION_FIELD_PATTERN.test(fromEnv))
-        return fromEnv;
-    return 'unknown';
+        return { sessionId: explicit, sessionSource: '--session' };
+    for (const key of DECISION_SESSION_ENV_VARS) {
+        const value = env[key]?.trim();
+        if (value && ATTRIBUTION_FIELD_PATTERN.test(value))
+            return { sessionId: value, sessionSource: key };
+    }
+    return { sessionId: 'unknown', sessionSource: 'unknown' };
+}
+export function resolveDecisionSessionId(explicitSessionId, env) {
+    return resolveDecisionSession(explicitSessionId, env).sessionId;
 }
 function withinRecordBudget(record) {
     return Buffer.byteLength(JSON.stringify(record), 'utf8') <= MAX_LEDGER_RECORD_BYTES;
@@ -224,7 +229,9 @@ function enforceRecordBudget(record) {
 /** Pure, synchronous and side-effect free: builds the record this call would append, fully sanitized. */
 export function buildDecisionLedgerRecord(input, result, context) {
     const timestamp = new Date((context.now ?? Date.now)()).toISOString();
-    const { estimatedLlmTokensAvoided, estimationMethod } = estimateSavings(input, result);
+    const legacy = estimateSavingsV1(input, result);
+    const inputTokens = new CanonicalJsonByteEstimator().estimate(contextMessageForEstimate(input)).tokens;
+    const savings = estimateDecisionSavings(inputTokens, result.status === 'answered', (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0), context.savingsWeights ?? decisionSavingsWeights());
     const caller = context.caller && ATTRIBUTION_FIELD_PATTERN.test(context.caller) ? context.caller : null;
     const rawAnswer = result.answer;
     const answer = typeof rawAnswer === 'string' ? sanitizeField(rawAnswer) : rawAnswer;
@@ -239,6 +246,7 @@ export function buildDecisionLedgerRecord(input, result, context) {
         transport: context.transport,
         provider: sanitizeField(context.provider) ?? 'unknown',
         sessionId: sanitizeField(context.sessionId) ?? 'unknown',
+        sessionSource: sanitizeField(context.sessionSource) ?? 'unknown',
         projectRoot: sanitizeField(context.projectRoot) ?? '',
         decisionKind: input.mode.kind,
         choiceIds,
@@ -250,13 +258,22 @@ export function buildDecisionLedgerRecord(input, result, context) {
         status: result.status,
         answer,
         confidence: result.confidence,
+        ...(result.answeredBy === undefined ? {} : { answeredBy: result.answeredBy }),
         threshold: input.threshold ?? 0.8,
         fallbackReason: result.status === 'fallback' ? result.reason : null,
         model: typeof result.model === 'string' ? sanitizeField(result.model) : result.model,
         usage: result.usage,
         latencyMs: result.latencyMs,
-        estimatedLlmTokensAvoided,
-        estimationMethod,
+        ...(result.aggregate ? {
+            passesRequested: result.aggregate.passesRequested, escalationPasses: result.aggregate.escalationPasses,
+            passesRun: result.aggregate.passesRun, escalated: result.aggregate.escalated,
+            earlyStop: result.aggregate.earlyStop, agreementRatio: result.aggregate.agreementRatio,
+            minAgreement: result.aggregate.minAgreement, agreementConfidenceFloor: result.aggregate.agreementConfidenceFloor,
+            passConfidenceSummary: result.aggregate.confidenceSummary,
+        } : {}),
+        estimatedLlmTokensAvoided: legacy.estimatedLlmTokensAvoided,
+        estimationMethodV1: legacy.estimationMethod,
+        ...savings,
         caller: sanitizeField(caller, MAX_METADATA_FIELD_BYTES),
     };
     if (context.recordText) {
@@ -480,11 +497,13 @@ async function performRecord(input, result, options, warn, flag) {
         const provider = await resolveProviderSafely(options);
         if (flag.cancelled)
             return null;
-        const sessionId = resolveDecisionSessionId(options.explicitSessionId, options.env ?? process.env);
+        const session = resolveDecisionSession(options.explicitSessionId, options.env ?? process.env);
+        const config = await readAiwgConfig(options.projectRoot);
         const record = buildDecisionLedgerRecord(input, result, {
             transport: options.transport,
             provider,
-            sessionId,
+            ...session,
+            savingsWeights: decisionSavingsWeights(config?.decision?.ask),
             projectRoot: options.projectRoot,
             caller: options.caller,
             recordText: options.recordText,
@@ -588,7 +607,7 @@ function isDecisionLedgerRecord(value) {
     if (!value || typeof value !== 'object')
         return false;
     const record = value;
-    if (record.schema !== DECISION_LEDGER_SCHEMA)
+    if (record.schema !== DECISION_LEDGER_SCHEMA && record.schema !== DECISION_LEDGER_SCHEMA_V1)
         return false;
     if (typeof record.id !== 'string' || record.id.length === 0)
         return false;
@@ -622,6 +641,8 @@ function isDecisionLedgerRecord(value) {
         return false;
     if (!isUnitIntervalOrNull(record.confidence))
         return false;
+    if (record.answeredBy !== undefined && record.answeredBy !== null && record.answeredBy !== 'confidence' && record.answeredBy !== 'agreement')
+        return false;
     if (!isUnitIntervalOrNull(record.threshold) || record.threshold === null)
         return false;
     if (record.fallbackReason !== null && typeof record.fallbackReason !== 'string')
@@ -634,10 +655,54 @@ function isDecisionLedgerRecord(value) {
         return false;
     if (!isFiniteNumber(record.estimatedLlmTokensAvoided))
         return false; // may be negative
-    if (typeof record.estimationMethod !== 'string')
-        return false;
+    if (record.schema === DECISION_LEDGER_SCHEMA_V1) {
+        if (typeof record.estimationMethod !== 'string')
+            return false;
+    }
+    else {
+        const method = record.estimationMethod;
+        if (!method || typeof method !== 'object' || method.version !== 'aiwg-decision-savings/v2')
+            return false;
+        if (!['standard', 'reasoning'].includes(method.caller_model_class))
+            return false;
+        for (const key of ['input_tokens', 'reasoning_tokens', 'output_tokens', 'llm_per_mtok', 'jev_per_mtok']) {
+            if (!isFiniteNumber(method[key]) || method[key] < 0 || method[key] > 1_000_000)
+                return false;
+        }
+        if (typeof record.sessionSource !== 'string')
+            return false;
+        for (const key of ['llm_tokens_avoided', 'jev_tokens']) {
+            if (!isFiniteNumber(record[key]) || record[key] < 0)
+                return false;
+        }
+        if (!isFiniteNumber(record.cost_weighted_net_usd))
+            return false;
+    }
     if (record.caller !== null && typeof record.caller !== 'string')
         return false;
+    for (const key of ['passesRequested', 'escalationPasses', 'passesRun']) {
+        if (record[key] !== undefined && (!Number.isSafeInteger(record[key]) || record[key] < (key === 'passesRun' ? 0 : 1)))
+            return false;
+    }
+    if (record.escalated !== undefined && typeof record.escalated !== 'boolean')
+        return false;
+    if (record.agreementRatio !== undefined && (record.agreementRatio === null || !isUnitIntervalOrNull(record.agreementRatio)))
+        return false;
+    if (record.minAgreement !== undefined && !isUnitIntervalOrNull(record.minAgreement))
+        return false;
+    if (record.agreementConfidenceFloor !== undefined && (record.agreementConfidenceFloor === null || !isUnitIntervalOrNull(record.agreementConfidenceFloor)))
+        return false;
+    if (record.earlyStop !== undefined && record.earlyStop !== null && record.earlyStop !== 'certain-failure' && record.earlyStop !== 'timeout')
+        return false;
+    if (record.passConfidenceSummary !== undefined) {
+        const summary = record.passConfidenceSummary;
+        if (!summary || typeof summary !== 'object' || Array.isArray(summary))
+            return false;
+        if (![summary.count, summary.missing].every(value => Number.isSafeInteger(value) && value >= 0))
+            return false;
+        if (![summary.mean, summary.min, summary.max].every(isUnitIntervalOrNull))
+            return false;
+    }
     return true;
 }
 async function* streamDecisionLedgerLines(path) {
@@ -714,20 +779,47 @@ function groupKeyFor(record, groupBy) {
         return record.sessionId;
     if (groupBy === 'kind')
         return record.decisionKind;
+    if (groupBy === 'passes')
+        return `${record.passesRequested ?? 1}/${record.escalationPasses ?? record.passesRequested ?? 1}`;
+    if (groupBy === 'escalation')
+        return String(record.escalated ?? false);
     return record.caller; // may be null; kept distinct from the literal string "unattributed"
 }
 function newAccumulator() {
     return {
+        llmTokensAvoided: 0, costWeightedNetUsd: 0, legacyReestimatedCalls: 0,
         totalCalls: 0, answered: 0, fallback: 0, fallbackCountByReason: {},
+        agreementCount: 0, agreementSum: 0, escalatedCalls: 0, passesRun: 0,
         confidenceCount: 0, confidenceSum: 0, confidenceMin: null, confidenceMax: null,
         jevInputTokens: 0, jevOutputTokens: 0, answeredJevInputTokens: 0, answeredJevOutputTokens: 0,
         estimatedLlmTokensAvoidedTotal: 0,
     };
 }
-function accumulate(acc, record) {
+function accumulate(acc, record, weights) {
     acc.totalCalls += 1;
+    if (record.agreementRatio !== undefined) {
+        acc.agreementCount += 1;
+        acc.agreementSum += record.agreementRatio;
+    }
+    if (record.escalated)
+        acc.escalatedCalls += 1;
+    acc.passesRun += record.passesRun ?? (record.fallbackReason === 'not-configured' ? 0 : 1);
     const inputTokens = record.usage?.inputTokens ?? 0;
     const outputTokens = record.usage?.outputTokens ?? 0;
+    if (record.schema === DECISION_LEDGER_SCHEMA) {
+        acc.llmTokensAvoided += record.llm_tokens_avoided;
+        acc.costWeightedNetUsd += record.cost_weighted_net_usd;
+    }
+    else {
+        // v1 answered credit contains the original input estimate plus the known
+        // per-kind allowance. Digests alone cannot reconstruct caller text.
+        const recoveredInput = record.status === 'answered'
+            ? Math.max(0, record.estimatedLlmTokensAvoided - DECISION_SAVINGS_REASONING_ALLOWANCE_TOKENS[record.decisionKind]) : 0;
+        const estimate = estimateDecisionSavings(recoveredInput, record.status === 'answered', inputTokens + outputTokens, weights);
+        acc.llmTokensAvoided += estimate.llm_tokens_avoided;
+        acc.costWeightedNetUsd += estimate.cost_weighted_net_usd;
+        acc.legacyReestimatedCalls += 1;
+    }
     if (record.status === 'answered') {
         acc.answered += 1;
         if (record.confidence !== null) {
@@ -755,10 +847,17 @@ function finalizeGroup(key, acc) {
     }
     return {
         key,
+        llm_tokens_avoided: acc.llmTokensAvoided,
+        jev_tokens: acc.jevInputTokens + acc.jevOutputTokens,
+        cost_weighted_net_usd: acc.costWeightedNetUsd,
+        legacyReestimatedCalls: acc.legacyReestimatedCalls,
         totalCalls: acc.totalCalls,
         answered: acc.answered,
         fallback: acc.fallback,
         fallbackRate: acc.totalCalls ? acc.fallback / acc.totalCalls : 0,
+        hitRate: acc.totalCalls ? acc.answered / acc.totalCalls : 0,
+        agreement: { count: acc.agreementCount, mean: acc.agreementCount ? acc.agreementSum / acc.agreementCount : null },
+        escalatedCalls: acc.escalatedCalls, passesRun: acc.passesRun,
         fallbackCountByReason: acc.fallbackCountByReason,
         fallbackRateByReason,
         confidence: {
@@ -768,12 +867,15 @@ function finalizeGroup(key, acc) {
             max: acc.confidenceMax,
         },
         jevUsage: { inputTokens: acc.jevInputTokens, outputTokens: acc.jevOutputTokens },
+        tokensPerAnsweredDecision: acc.answered ? (acc.jevInputTokens + acc.jevOutputTokens) / acc.answered : null,
         estimatedLlmTokensAvoidedTotal: acc.estimatedLlmTokensAvoidedTotal,
         netSavingsTokens: acc.estimatedLlmTokensAvoidedTotal - (acc.answeredJevInputTokens + acc.answeredJevOutputTokens),
     };
 }
 /** Reads, validates, filters and aggregates the ledger offline, streaming line-by-line with incremental min/max; no network, no Jev call. Tolerates a missing ledger file (empty result). */
 export async function decisionLedgerStats(projectRoot, filters = {}) {
+    const config = await readAiwgConfig(projectRoot);
+    const weights = decisionSavingsWeights(config?.decision?.ask);
     const groups = new Map();
     let skipped = 0;
     for await (const record of streamDecisionLedgerRecords(projectRoot)) {
@@ -789,7 +891,7 @@ export async function decisionLedgerStats(projectRoot, filters = {}) {
             acc = newAccumulator();
             groups.set(key, acc);
         }
-        accumulate(acc, record);
+        accumulate(acc, record, weights);
     }
     const sortedKeys = [...groups.keys()].sort((a, b) => (a ?? '').localeCompare(b ?? ''));
     return {
@@ -798,6 +900,7 @@ export async function decisionLedgerStats(projectRoot, filters = {}) {
         skipped,
         groups: sortedKeys.map(key => finalizeGroup(key, groups.get(key))),
         filters: { ...filters },
+        legacyEstimationWeights: weights,
     };
 }
 // ---------------------------------------------------------------------------

package/dist/src/decision/offload-activation.js

@@ -0,0 +1,137 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getConfigPath, readAiwgConfigCandidate } from '../config/aiwg-config.js';
+import { inspectUserRegistry } from '../config/user-registry.js';
+import { resolveDecisionEnablement } from '../config/decision-config.js';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+import * as credentials from './jev-credentials.js';
+export const DECISION_COMPACT_ANCHOR = 'Decision offload: before the first eligible bounded choice, including ordinary triage or worker routing, read `aiwg show rule decision-offload` and use the CLI or MCP ask capability. On fallback decide normally. Answers are advisory and do not authorize actions.';
+function isInstalledEntry(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const entry = value;
+    return typeof entry.version === 'string' && entry.version.trim().length > 0
+        && typeof entry.source === 'string' && entry.source.trim().length > 0
+        // Older registry/config entries can predate installedAt, so its absence is
+        // compatible; a present non-string timestamp is corrupt evidence.
+        && (entry.installedAt === undefined || typeof entry.installedAt === 'string')
+        && Boolean(entry.deployedTo) && typeof entry.deployedTo === 'object' && !Array.isArray(entry.deployedTo);
+}
+async function inspectProjectInstall(cwd) {
+    // A positive marker is sufficient installation evidence even when an
+    // unrelated user-scope registry or config section is unreadable. Negative
+    // evidence still goes through the full candidate validator below.
+    const local = getConfigPath(cwd);
+    const candidates = [local];
+    for (const file of candidates) {
+        try {
+            const parsed = JSON.parse(await readFile(file, 'utf8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                const installed = parsed.installed;
+                if (installed && typeof installed === 'object' && !Array.isArray(installed)
+                    && Object.hasOwn(installed, 'decision-engine')) {
+                    return isInstalledEntry(installed['decision-engine']) ? true : null;
+                }
+            }
+            // A valid local config wins over compatibility/artifact copies.
+            if (file === local)
+                break;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                if (file === local) {
+                    try {
+                        const artifact = projectAiwgPath(cwd, 'aiwg.config');
+                        if (!candidates.includes(artifact))
+                            candidates.push(artifact);
+                    }
+                    catch {
+                        return null;
+                    }
+                }
+                continue;
+            }
+            return null;
+        }
+    }
+    try {
+        // Installation metadata is independent of worker-model defaults. Reading
+        // the validated candidate avoids turning an unrelated missing defaults
+        // bundle into unknown addon-installation evidence.
+        const config = await readAiwgConfigCandidate(cwd);
+        const installed = config?.installed ?? {};
+        return Object.hasOwn(installed, 'decision-engine')
+            ? isInstalledEntry(installed['decision-engine']) ? true : null
+            : false;
+    }
+    catch {
+        return null;
+    }
+}
+async function inspectUserInstall() {
+    const inspected = await inspectUserRegistry();
+    if (Object.hasOwn(inspected.registry.installed, 'decision-engine')) {
+        return isInstalledEntry(inspected.registry.installed['decision-engine']) ? true : null;
+    }
+    return inspected.status === 'unreadable' ? null : false;
+}
+function combineInstallEvidence(project, user) {
+    if (project === true || user === true)
+        return true;
+    if (project === null || user === null)
+        return null;
+    return false;
+}
+async function inspectReadableFile(file) {
+    try {
+        await readFile(file);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? false : null;
+    }
+}
+async function inspectAnchor(file) {
+    try {
+        return (await readFile(file, 'utf8')).includes(DECISION_COMPACT_ANCHOR);
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? false : null;
+    }
+}
+/** Read configuration evidence only; native session loading is not observable here. */
+export async function inspectDecisionOffloadActivation(options) {
+    const [projectInstalled, userInstalled] = await Promise.all([
+        inspectProjectInstall(options.cwd),
+        inspectUserInstall(),
+    ]);
+    const installed = combineInstallEvidence(projectInstalled, userInstalled);
+    let evaluateEnabled = null;
+    try {
+        evaluateEnabled = resolveDecisionEnablement({ cwd: options.cwd, env: options.env }).enabled;
+    }
+    catch { /* invalid settings are unknown */ }
+    // The inspector is supplied by the shared decision runtime. The compatibility
+    // branch preserves older installed runtimes and discards credential material.
+    const runtime = credentials;
+    let askEnabled = installed === null ? null : false;
+    if (installed === true) {
+        try {
+            const ask = runtime.inspectJevCredential
+                ? await runtime.inspectJevCredential({ cwd: options.cwd, env: options.env })
+                : await credentials.lookupJevCredential({ cwd: options.cwd, env: options.env }).then(value => ({ configured: Boolean(value), enabled: value?.enabled ?? false }));
+            askEnabled = ask.configured === null || ask.enabled === null ? null : ask.configured && ask.enabled;
+        }
+        catch {
+            askEnabled = null;
+        }
+    }
+    const rulePath = options.frameworkRoot && path.join(options.frameworkRoot, 'agentic/code/addons/decision-engine/rules/decision-offload.md');
+    const ruleSourcePresent = rulePath ? await inspectReadableFile(rulePath) : null;
+    const startupFile = path.join(options.cwd, 'AIWG.md');
+    const startupAnchorPresent = await inspectAnchor(startupFile);
+    return { installed, askEnabled, evaluateEnabled,
+        shouldAnchor: installed === true && askEnabled === true, ruleSourcePresent, ruleDelivery: 'unknown',
+        startupAnchorPresent, nativeActivation: 'not-claimed' };
+}
+//# sourceMappingURL=offload-activation.js.map