@duckcodeailabs/dql-agent 1.14.3-rc.1 → 1.14.5

package/dist/ask-observability/portable.js

@@ -312,6 +312,10 @@ function redactRunReceipt(value, trace, profile, salt) {
         ?? (source.cascade && typeof source.cascade === 'object'
             ? source.cascade.terminalGap
             : undefined), profile, salt);
+    const runtimeReceiptV5 = portableRuntimeReceiptV5(record.diagnosticReceiptV5, profile, salt);
+    const runtimeReceiptV6 = portableRuntimeReceiptV6(record.diagnosticReceiptV6, profile, salt);
+    const runtimeReceiptV7 = portableRuntimeReceiptV7(record.diagnosticReceiptV7, profile, salt);
+    const runtimeReceiptV8 = portableRuntimeReceiptV8(record.diagnosticReceiptV8, profile, salt);
     return {
         version: 1,
         traceReference: {
@@ -326,6 +330,10 @@ function redactRunReceipt(value, trace, profile, salt) {
         planFrozen: source.planFrozen === true,
         finalStopReason: typeof source.finalStopReason === 'string' ? source.finalStopReason : undefined,
         ...(terminalGap ? { terminalGap } : {}),
+        ...(runtimeReceiptV5 ? { runtimeReceiptV5 } : {}),
+        ...(runtimeReceiptV6 ? { runtimeReceiptV6 } : {}),
+        ...(runtimeReceiptV7 ? { runtimeReceiptV7 } : {}),
+        ...(runtimeReceiptV8 ? { runtimeReceiptV8 } : {}),
         telemetry: sanitizeTelemetry(record.telemetry),
         fingerprints: {
             plan: map(findFingerprint(record, 'planFingerprint'), 'plan'),
@@ -334,6 +342,560 @@ function redactRunReceipt(value, trace, profile, salt) {
         },
     };
 }
+/**
+ * V8 is the bounded Ask-tool-runtime story. Strict exports retain its
+ * allowlisted enums, counts, timings, and pseudonymous identifiers only. In
+ * particular, this deliberately does not make generated DQL/SQL exportable:
+ * the local trace contract never retains query text, result rows, prompts,
+ * provider responses, credentials, or chain-of-thought.
+ */
+function portableRuntimeReceiptV8(value, profile, salt) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const receipt = value;
+    if (receipt.version !== 8)
+        return undefined;
+    const record = (candidate) => candidate && typeof candidate === 'object' && !Array.isArray(candidate) ? candidate : undefined;
+    const count = (candidate, maximum = 10_000) => typeof candidate === 'number' && Number.isFinite(candidate)
+        ? Math.max(0, Math.min(maximum, Math.floor(candidate)))
+        : undefined;
+    const identifier = (candidate, kind) => typeof candidate === 'string' && candidate.length > 0 && candidate.length <= 256
+        ? (profile === 'strict' ? pseudo(candidate, salt, kind) : candidate)
+        : undefined;
+    const safeCode = (candidate) => typeof candidate === 'string' && /^[A-Z][A-Z0-9_:-]{1,95}$/.test(candidate)
+        ? candidate
+        : 'UNRECOGNIZED_REASON';
+    const modes = new Set(['legacy_v1', 'shadow_v2', 'authoritative_v2']);
+    const turns = new Set(['analytics', 'definition', 'business_context', 'prior_result', 'general', 'clarification_response', 'research']);
+    const sources = new Set(['certified', 'semantic', 'governed_relational', 'dbt_manifest', 'runtime_schema', 'vector', 'conversation', 'business']);
+    const sourceStates = new Set(['available', 'empty', 'stale', 'unavailable', 'errored', 'skipped']);
+    const tools = new Set(['inspect_ask_context', 'inspect_conversation_result', 'inspect_business_context', 'inspect_certified_candidates', 'run_certified', 'inspect_semantic_candidates', 'compile_and_run_semantic', 'inspect_relational_context', 'compile_and_run_dql', 'validate_and_run_sql', 'search_values', 'request_clarification', 'finish_answer']);
+    const outcomes = new Set(['eligible', 'executed', 'ineligible', 'unavailable', 'ambiguous', 'needs_input', 'denied', 'error']);
+    const tiers = new Set(['certified', 'semantic', 'governed_relational', 'exploratory_sql']);
+    const origins = new Set(['retrieval', 'agent_control', 'tool', 'validation', 'freeze', 'execution', 'provider', 'narration']);
+    const terminalKinds = new Set(['finish_answer', 'clarification', 'gap', 'provider_failure', 'execution_failure', 'denied', 'budget_exhausted']);
+    const semanticEngines = new Set(['native', 'metricflow-cli', 'dbt-cloud']);
+    const providerPhases = new Set(['preflight', 'classification', 'meaning_resolution', 'planning', 'generation', 'repair', 'narration', 'agent_control', 'tool_followup', 'unknown']);
+    const providerCauses = new Set(['authentication', 'model_not_found', 'rate_limited', 'gateway', 'network', 'provider_timeout', 'run_deadline', 'admission_denied', 'dispatch_budget', 'cancelled', 'unknown']);
+    const narrations = new Set(['fact_bound', 'deterministic_fallback', 'not_retained', 'not_applicable']);
+    if (typeof receipt.mode !== 'string' || !modes.has(receipt.mode)
+        || typeof receipt.turnClass !== 'string' || !turns.has(receipt.turnClass))
+        return undefined;
+    const contextCoverage = Array.isArray(receipt.contextCoverage)
+        ? receipt.contextCoverage.flatMap((entry) => {
+            const item = record(entry);
+            if (!item || typeof item.source !== 'string' || !sources.has(item.source)
+                || typeof item.status !== 'string' || !sourceStates.has(item.status))
+                return [];
+            return [{
+                    source: item.source,
+                    status: item.status,
+                    ...(count(item.admittedCandidateCount) !== undefined ? { admittedCandidateCount: count(item.admittedCandidateCount) } : {}),
+                    ...(count(item.excludedCandidateCount) !== undefined ? { excludedCandidateCount: count(item.excludedCandidateCount) } : {}),
+                    reasonCodes: Array.isArray(item.reasonCodes) ? item.reasonCodes.slice(0, 8).map(safeCode) : [],
+                }];
+        })
+        : [];
+    const observations = Array.isArray(receipt.observations)
+        ? receipt.observations.slice(0, 24).flatMap((entry) => {
+            const item = record(entry);
+            if (!item || typeof item.tool !== 'string' || !tools.has(item.tool)
+                || typeof item.outcome !== 'string' || !outcomes.has(item.outcome))
+                return [];
+            const provider = record(item.provider);
+            const safeProvider = provider && typeof provider.phase === 'string' && providerPhases.has(provider.phase)
+                && typeof provider.cause === 'string' && providerCauses.has(provider.cause)
+                && typeof provider.retryable === 'boolean'
+                ? { phase: provider.phase, cause: provider.cause, retryable: provider.retryable, safeAction: safeCode(provider.safeAction) }
+                : undefined;
+            return [{
+                    tool: item.tool,
+                    outcome: item.outcome,
+                    ...(typeof item.tier === 'string' && tiers.has(item.tier) ? { tier: item.tier } : {}),
+                    reasonCode: safeCode(item.reasonCode),
+                    candidateIds: Array.isArray(item.candidateIds)
+                        ? item.candidateIds.slice(0, 48).flatMap((id) => identifier(id, 'candidate') ? [identifier(id, 'candidate')] : [])
+                        : [],
+                    ...(identifier(item.planId, 'plan') ? { planId: identifier(item.planId, 'plan') } : {}),
+                    ...(typeof item.frozen === 'boolean' ? { frozen: item.frozen } : {}),
+                    ...(typeof item.retryable === 'boolean' ? { retryable: item.retryable } : {}),
+                    ...(typeof item.safeAction === 'string' ? { safeAction: safeCode(item.safeAction) } : {}),
+                    ...(count(item.durationMs, 86_400_000) !== undefined ? { durationMs: count(item.durationMs, 86_400_000) } : {}),
+                    ...(identifier(item.inputFingerprint, 'input') ? { inputFingerprint: identifier(item.inputFingerprint, 'input') } : {}),
+                    ...(identifier(item.outputFingerprint, 'output') ? { outputFingerprint: identifier(item.outputFingerprint, 'output') } : {}),
+                    ...(typeof item.origin === 'string' && origins.has(item.origin) ? { origin: item.origin } : {}),
+                    ...(safeProvider ? { provider: safeProvider } : {}),
+                }];
+        })
+        : [];
+    const tierAttempts = Array.isArray(receipt.tierAttempts)
+        ? receipt.tierAttempts.slice(0, 8).flatMap((entry) => {
+            const item = record(entry);
+            if (!item || typeof item.tier !== 'string' || !tiers.has(item.tier)
+                || typeof item.outcome !== 'string' || !outcomes.has(item.outcome)
+                || typeof item.frozen !== 'boolean')
+                return [];
+            return [{
+                    tier: item.tier,
+                    outcome: item.outcome,
+                    reasonCode: safeCode(item.reasonCode),
+                    frozen: item.frozen,
+                    candidateIds: Array.isArray(item.candidateIds)
+                        ? item.candidateIds.slice(0, 48).flatMap((id) => identifier(id, 'candidate') ? [identifier(id, 'candidate')] : [])
+                        : [],
+                    ...(count(item.durationMs, 86_400_000) !== undefined ? { durationMs: count(item.durationMs, 86_400_000) } : {}),
+                }];
+        })
+        : [];
+    const terminal = record(receipt.terminalOutcome);
+    const safeTerminal = terminal && typeof terminal.kind === 'string' && terminalKinds.has(terminal.kind)
+        && typeof terminal.origin === 'string' && origins.has(terminal.origin)
+        ? {
+            kind: terminal.kind,
+            origin: terminal.origin,
+            reasonCode: safeCode(terminal.reasonCode),
+            ...(typeof terminal.safeAction === 'string' ? { safeAction: safeCode(terminal.safeAction) } : {}),
+        }
+        : undefined;
+    const outcome = record(receipt.outcome);
+    const safeOutcome = outcome && typeof outcome.connectionAttempted === 'boolean'
+        && typeof outcome.narration === 'string' && narrations.has(outcome.narration)
+        ? {
+            connectionAttempted: outcome.connectionAttempted,
+            executionAttempts: count(outcome.executionAttempts) ?? 0,
+            factCount: count(outcome.factCount) ?? 0,
+            narration: outcome.narration,
+        }
+        : { connectionAttempted: false, executionAttempts: 0, factCount: 0, narration: 'not_retained' };
+    const semanticRuntime = record(receipt.semanticRuntime);
+    const safeSemanticRuntime = semanticRuntime
+        && semanticRuntime.version === 1
+        && typeof semanticRuntime.preference === 'string'
+        && (semanticRuntime.preference === 'auto' || semanticEngines.has(semanticRuntime.preference))
+        && typeof semanticRuntime.readiness === 'string'
+        && (semanticRuntime.readiness === 'ready' || semanticRuntime.readiness === 'unavailable')
+        && (semanticRuntime.selectedEngine === undefined
+            || (typeof semanticRuntime.selectedEngine === 'string' && semanticEngines.has(semanticRuntime.selectedEngine)))
+        ? {
+            version: 1,
+            preference: semanticRuntime.preference,
+            ...(typeof semanticRuntime.selectedEngine === 'string' ? { selectedEngine: semanticRuntime.selectedEngine } : {}),
+            readiness: semanticRuntime.readiness,
+        }
+        : undefined;
+    return {
+        version: 8,
+        mode: receipt.mode,
+        turnClass: receipt.turnClass,
+        ...(identifier(receipt.snapshotId, 'snapshot') ? { snapshotId: identifier(receipt.snapshotId, 'snapshot') } : {}),
+        retainedCandidateCount: count(receipt.retainedCandidateCount) ?? 0,
+        initialCandidateCount: count(receipt.initialCandidateCount) ?? 0,
+        expansionCount: count(receipt.expansionCount) ?? 0,
+        objective: typeof receipt.objective === 'string' && turns.has(receipt.objective) ? receipt.objective : receipt.turnClass,
+        contextCoverage,
+        excludedCandidateCount: count(receipt.excludedCandidateCount) ?? 0,
+        exclusionReasonCodes: Array.isArray(receipt.exclusionReasonCodes) ? receipt.exclusionReasonCodes.slice(0, 8).map(safeCode) : [],
+        observations,
+        tierAttempts,
+        ...(typeof receipt.controllerTier === 'string' && tiers.has(receipt.controllerTier)
+            ? { controllerTier: receipt.controllerTier }
+            : {}),
+        ...(safeSemanticRuntime ? { semanticRuntime: safeSemanticRuntime } : {}),
+        planFrozen: receipt.planFrozen === true,
+        ...(safeTerminal ? { terminalOutcome: safeTerminal } : {}),
+        outcome: safeOutcome,
+        toolDurationMs: count(receipt.toolDurationMs, 86_400_000) ?? 0,
+        finalStopReason: safeCode(receipt.finalStopReason),
+    };
+}
+/**
+ * V6 adds the short reader-facing decision path to V5.  Keep the portable
+ * shape deliberately narrower than the persisted receipt: a support bundle
+ * needs counts, enum outcomes, and pseudonymous identity fingerprints, never
+ * raw requirements, member values, candidate lifecycle prose, or answer text.
+ */
+function portableRuntimeReceiptV6(value, profile, salt) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const receipt = value;
+    if (receipt.version !== 6 || typeof receipt.runId !== 'string')
+        return undefined;
+    const record = (candidate) => candidate && typeof candidate === 'object' && !Array.isArray(candidate) ? candidate : undefined;
+    // The V5 projection is an explicit allowlist for all inherited fields. Do
+    // not copy V6 state/workspace wholesale merely because it extends V5.
+    const base = portableRuntimeReceiptV5({ ...receipt, version: 5 }, profile, salt);
+    if (!base)
+        return undefined;
+    const planning = record(receipt.planning);
+    const allowedModes = new Set(['exact_fast_path', 'initial_planner', 'targeted_revision', 'deterministic_binding']);
+    const allowedVerification = new Set(['valid', 'needs_targeted_context', 'ambiguous', 'denied', 'invalid']);
+    const allowedStages = new Set(['retrieval', 'role_coverage', 'planner', 'verification', 'targeted_recovery', 'cascade', 'freeze', 'connection', 'execution', 'facts']);
+    const allowedStatuses = new Set(['completed', 'skipped', 'blocked', 'unavailable']);
+    const allowedRoles = new Set(['metric', 'entity_key', 'entity_label', 'categorical_dimension', 'time_dimension', 'member', 'relationship', 'context']);
+    const allowedTiers = new Set(['certified', 'semantic', 'governed_relational', 'exploratory_sql', 'clarify_or_gap']);
+    const allowedTierOutcomes = new Set(['executable', 'ineligible', 'unavailable', 'ambiguous', 'denied']);
+    const allowedBoundaries = new Set(['plan.compile', 'semantic.compile', 'sql.authorize', 'sql.execute', 'provider', 'cascade', 'run']);
+    const allowedOrigins = new Set(['internal_invariant', 'governance_gate', 'semantic_compiler', 'plan_compiler', 'provider', 'warehouse', 'unknown']);
+    const allowedImpacts = new Set(['execution_not_attempted', 'execution_failed', 'answer_not_produced', 'run_cancelled']);
+    const allowedActions = new Set(['export_redacted_trace', 'configure_connection', 'change_authorized_connection', 'inspect_failure', 'retry_same_plan', 'refresh_snapshot', 'edit_dql', 'open_sql_notebook', 'request_access', 'reapply_semantic_runtime', 'review_analytical_failure', 'inspect_research_failures', 'none']);
+    const finiteCount = (candidate) => typeof candidate === 'number' && Number.isFinite(candidate)
+        ? Math.max(0, Math.min(10_000, Math.floor(candidate)))
+        : undefined;
+    const pseudonym = (candidate, kind) => typeof candidate === 'string'
+        ? (profile === 'strict' ? pseudo(candidate, salt, kind) : candidate)
+        : undefined;
+    const verificationRecord = planning ? record(planning.verification) : undefined;
+    const safePlanning = planning
+        && planning.version === 1
+        && typeof planning.mode === 'string'
+        && allowedModes.has(planning.mode)
+        && verificationRecord
+        && verificationRecord.version === 1
+        && typeof verificationRecord.status === 'string'
+        && allowedVerification.has(verificationRecord.status)
+        ? {
+            version: 1,
+            mode: planning.mode,
+            ...(finiteCount(planning.plannerCalls) !== undefined ? { plannerCalls: finiteCount(planning.plannerCalls) } : {}),
+            ...(finiteCount(planning.revisionCalls) !== undefined ? { revisionCalls: finiteCount(planning.revisionCalls) } : {}),
+            verification: {
+                version: 1,
+                status: verificationRecord.status,
+                missingRoleCount: Array.isArray(verificationRecord.missingRoles)
+                    ? verificationRecord.missingRoles.filter((role) => typeof role === 'string').slice(0, 8).length
+                    : 0,
+                candidateIds: Array.isArray(verificationRecord.candidateIds)
+                    ? verificationRecord.candidateIds
+                        .filter((id) => typeof id === 'string')
+                        .slice(0, 32)
+                        .map((id) => pseudonym(id, 'candidate'))
+                    : [],
+                reasonCode: typeof verificationRecord.reasonCode === 'string'
+                    && /^[a-z0-9_:-]{1,96}$/.test(verificationRecord.reasonCode)
+                    ? verificationRecord.reasonCode
+                    : 'unrecognized_reason',
+            },
+        }
+        : undefined;
+    const story = Array.isArray(receipt.story)
+        ? receipt.story.flatMap((step) => {
+            const item = record(step);
+            if (!item || typeof item.stage !== 'string' || !allowedStages.has(item.stage)
+                || typeof item.status !== 'string' || !allowedStatuses.has(item.status))
+                return [];
+            return [{
+                    stage: item.stage,
+                    status: item.status,
+                    reasonCode: typeof item.reasonCode === 'string' && /^[a-z0-9_:-]{1,96}$/.test(item.reasonCode)
+                        ? item.reasonCode
+                        : 'unrecognized_reason',
+                }];
+        })
+        : [];
+    const roleCoverage = Array.isArray(receipt.roleCoverage)
+        ? receipt.roleCoverage.flatMap((entry) => {
+            const item = record(entry);
+            if (!item || typeof item.role !== 'string' || !allowedRoles.has(item.role))
+                return [];
+            const candidateCount = finiteCount(item.candidateCount);
+            return candidateCount === undefined ? [] : [{
+                    role: item.role,
+                    candidateCount,
+                    ...(item.state === 'alternatives' || item.state === 'proven' ? { state: item.state } : {}),
+                }];
+        })
+        : [];
+    const cascade = record(receipt.cascade);
+    const safeCascade = cascade && typeof cascade.planFrozen === 'boolean'
+        ? {
+            attempts: Array.isArray(cascade.attempts)
+                ? cascade.attempts.flatMap((entry) => {
+                    const item = record(entry);
+                    if (!item || typeof item.tier !== 'string' || !allowedTiers.has(item.tier)
+                        || typeof item.outcome !== 'string' || !allowedTierOutcomes.has(item.outcome)
+                        || typeof item.planFrozen !== 'boolean')
+                        return [];
+                    return [{ tier: item.tier, outcome: item.outcome, planFrozen: item.planFrozen }];
+                })
+                : [],
+            ...(typeof cascade.selectedTier === 'string' && allowedTiers.has(cascade.selectedTier) ? { selectedTier: cascade.selectedTier } : {}),
+            ...(typeof cascade.stopReason === 'string' && /^[a-z0-9_:-]{1,96}$/.test(cascade.stopReason) ? { stopReason: cascade.stopReason } : {}),
+            planFrozen: cascade.planFrozen,
+        }
+        : undefined;
+    const origin = record(receipt.origin);
+    const safeOrigin = origin
+        && typeof origin.boundary === 'string' && allowedBoundaries.has(origin.boundary)
+        && typeof origin.origin === 'string' && allowedOrigins.has(origin.origin)
+        && typeof origin.impact === 'string' && allowedImpacts.has(origin.impact)
+        ? { boundary: origin.boundary, origin: origin.origin, impact: origin.impact }
+        : undefined;
+    const connection = record(receipt.connection);
+    const execution = record(receipt.execution);
+    const facts = record(receipt.facts);
+    const safeConnection = connection && typeof connection.attempted === 'boolean'
+        ? { attempted: connection.attempted }
+        : undefined;
+    const executionAttempts = execution ? finiteCount(execution.attempts) : undefined;
+    const safeFacts = facts ? {
+        ...(finiteCount(facts.factCount) !== undefined ? { factCount: finiteCount(facts.factCount) } : {}),
+        ...(typeof facts.resultFingerprint === 'string' ? { resultFingerprint: pseudonym(facts.resultFingerprint, 'result') } : {}),
+    } : undefined;
+    const safeTelemetry = sanitizeTelemetry(receipt.telemetry);
+    return {
+        ...base,
+        version: 6,
+        ...(safePlanning ? { planning: safePlanning } : {}),
+        roleCoverage,
+        ...(safeCascade ? { cascade: safeCascade } : {}),
+        ...(safeOrigin ? { origin: safeOrigin } : {}),
+        ...(safeConnection ? { connection: safeConnection } : {}),
+        ...(executionAttempts !== undefined ? { execution: { attempts: executionAttempts } } : {}),
+        ...(safeTelemetry ? { telemetry: safeTelemetry } : {}),
+        ...(safeFacts ? { facts: safeFacts } : {}),
+        ...(typeof receipt.safeNextAction === 'string' && allowedActions.has(receipt.safeNextAction) ? { safeNextAction: receipt.safeNextAction } : {}),
+        story,
+    };
+}
+/**
+ * V7 is a count/enum-only first-read projection. Reuse the explicit V6
+ * allowlist for inherited fields, then independently allowlist the small
+ * inspector rather than copying its object wholesale into a support bundle.
+ */
+function portableRuntimeReceiptV7(value, profile, salt) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const receipt = value;
+    if (receipt.version !== 7 || typeof receipt.runId !== 'string')
+        return undefined;
+    const base = portableRuntimeReceiptV6({ ...receipt, version: 6 }, profile, salt);
+    if (!base)
+        return undefined;
+    const inspector = receipt.inspector && typeof receipt.inspector === 'object' && !Array.isArray(receipt.inspector)
+        ? receipt.inspector
+        : undefined;
+    const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    const count = (value) => typeof value === 'number' && Number.isFinite(value)
+        ? Math.max(0, Math.min(10_000, Math.floor(value)))
+        : undefined;
+    const understood = record(inspector?.understood);
+    const evidence = record(inspector?.evidence);
+    const planning = record(inspector?.planning);
+    const route = record(inspector?.route);
+    const outcome = record(inspector?.outcome);
+    const allowedKinds = new Set(['conversation', 'definition', 'lookup', 'ranking', 'breakdown', 'comparison', 'drilldown', 'diagnosis', 'research', 'compound', 'clarification', 'aggregation']);
+    const allowedBindings = new Set(['none', 'structured_clarification', 'prior_result', 'task_dependency']);
+    const allowedModes = new Set(['exact_fast_path', 'initial_planner', 'targeted_revision', 'deterministic_binding']);
+    const allowedVerification = new Set(['valid', 'needs_targeted_context', 'ambiguous', 'denied', 'invalid']);
+    const allowedTiers = new Set(['certified', 'semantic', 'governed_relational', 'exploratory_sql', 'clarify_or_gap']);
+    const allowedNarration = new Set(['fact_bound', 'result_without_facts', 'not_applicable']);
+    const safeInspector = understood && evidence && planning && route && outcome
+        && typeof understood.questionKind === 'string' && allowedKinds.has(understood.questionKind)
+        && typeof understood.conversationBinding === 'string' && allowedBindings.has(understood.conversationBinding)
+        && typeof understood.entityRequested === 'boolean' && typeof understood.hasBoundFilter === 'boolean'
+        && typeof evidence.recoveryAttempted === 'boolean'
+        && typeof planning.mode === 'string' && allowedModes.has(planning.mode)
+        && typeof planning.verification === 'string' && allowedVerification.has(planning.verification)
+        && typeof route.planFrozen === 'boolean' && typeof route.reviewRequired === 'boolean'
+        && typeof outcome.connectionAttempted === 'boolean'
+        && typeof outcome.narration === 'string' && allowedNarration.has(outcome.narration)
+        ? {
+            understood: {
+                questionKind: understood.questionKind,
+                conversationBinding: understood.conversationBinding,
+                ...(count(understood.measureCount) !== undefined ? { measureCount: count(understood.measureCount) } : {}),
+                ...(count(understood.dimensionCount) !== undefined ? { dimensionCount: count(understood.dimensionCount) } : {}),
+                entityRequested: understood.entityRequested,
+                hasBoundFilter: understood.hasBoundFilter,
+            },
+            evidence: {
+                ...(count(evidence.admittedCandidateCount) !== undefined ? { admittedCandidateCount: count(evidence.admittedCandidateCount) } : {}),
+                ...(count(evidence.roleCount) !== undefined ? { roleCount: count(evidence.roleCount) } : {}),
+                recoveryAttempted: evidence.recoveryAttempted,
+            },
+            planning: {
+                mode: planning.mode,
+                ...(count(planning.plannerCalls) !== undefined ? { plannerCalls: count(planning.plannerCalls) } : {}),
+                verification: planning.verification,
+            },
+            route: {
+                ...(typeof route.selectedTier === 'string' && allowedTiers.has(route.selectedTier) ? { selectedTier: route.selectedTier } : {}),
+                ...(count(route.tierAttemptCount) !== undefined ? { tierAttemptCount: count(route.tierAttemptCount) } : {}),
+                planFrozen: route.planFrozen,
+                reviewRequired: route.reviewRequired,
+            },
+            outcome: {
+                connectionAttempted: outcome.connectionAttempted,
+                ...(count(outcome.executionAttempts) !== undefined ? { executionAttempts: count(outcome.executionAttempts) } : {}),
+                ...(count(outcome.factCount) !== undefined ? { factCount: count(outcome.factCount) } : {}),
+                narration: outcome.narration,
+            },
+        }
+        : undefined;
+    return {
+        ...base,
+        version: 7,
+        ...(safeInspector ? { inspector: safeInspector } : {}),
+    };
+}
+/**
+ * Keep portable V5 parity with the full local trace without exporting raw Ask
+ * state.  The V5 receipt is already content-free; strict export additionally
+ * pseudonymizes fact/result/question identities while retaining its summary
+ * fingerprint so a support bundle can be matched to the on-device trace.
+ */
+function portableRuntimeReceiptV5(value, profile, salt) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const receipt = value;
+    if (receipt.version !== 5 || typeof receipt.runId !== 'string')
+        return undefined;
+    const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    const summary = record(receipt.summary);
+    const state = record(receipt.state);
+    const businessAnswer = record(receipt.businessAnswer);
+    const provider = record(receipt.provider);
+    const pseudonym = (value, kind) => typeof value === 'string'
+        ? (profile === 'strict' ? pseudo(value, salt, kind) : value)
+        : undefined;
+    const safeSummary = summary ? {
+        version: summary.version,
+        summaryFingerprint: summary.summaryFingerprint,
+        runtimeMode: summary.runtimeMode,
+        selectedCompiler: summary.selectedCompiler,
+        programTaskCount: summary.programTaskCount,
+        admittedCandidateCount: summary.admittedCandidateCount,
+        toolCallCount: summary.toolCallCount,
+        executionAttempts: summary.executionAttempts,
+    } : undefined;
+    const safeState = state ? {
+        version: state.version,
+        mode: state.mode,
+        phase: state.phase,
+        questionFingerprint: pseudonym(state.questionFingerprint, 'question'),
+        kind: state.kind,
+        requirementCounts: state.requirementCounts,
+        mission: state.mission,
+        workspace: portableRuntimeWorkspaceV5(state.workspace, profile, salt),
+        program: (() => {
+            const program = record(state.program);
+            return program ? {
+                id: pseudonym(program.id, 'program'),
+                taskCount: program.taskCount,
+                candidateCount: program.candidateCount,
+                requiredRoles: program.requiredRoles,
+                outputAssertionCount: program.outputAssertionCount,
+            } : undefined;
+        })(),
+        resolvedPlan: (() => {
+            const plan = record(state.resolvedPlan);
+            return plan ? {
+                version: plan.version,
+                programId: pseudonym(plan.programId, 'program'),
+                compiler: plan.compiler,
+                selectedTier: plan.selectedTier,
+                planFrozen: plan.planFrozen,
+                reviewRequired: plan.reviewRequired,
+                planFingerprint: pseudonym(plan.planFingerprint, 'plan'),
+            } : undefined;
+        })(),
+        counters: state.counters,
+    } : undefined;
+    const safeBusinessAnswer = businessAnswer ? {
+        version: businessAnswer.version,
+        mode: businessAnswer.mode,
+        trustState: businessAnswer.trustState,
+        factIds: Array.isArray(businessAnswer.factIds)
+            ? businessAnswer.factIds.filter((id) => typeof id === 'string').map((id) => pseudonym(id, 'fact'))
+            : [],
+        resultFingerprint: pseudonym(businessAnswer.resultFingerprint, 'result'),
+        limitationCount: businessAnswer.limitationCount,
+    } : undefined;
+    const safeProvider = provider ? {
+        version: provider.version,
+        cause: provider.cause,
+        phase: provider.phase,
+        retryable: provider.retryable,
+        safeAction: provider.safeAction,
+        httpStatusClass: provider.httpStatusClass,
+        providerFingerprint: pseudonym(provider.providerFingerprint, 'provider'),
+        modelFingerprint: pseudonym(provider.modelFingerprint, 'model'),
+        baseOriginFingerprint: pseudonym(provider.baseOriginFingerprint, 'origin'),
+    } : undefined;
+    return {
+        version: 5,
+        runId: pseudonym(receipt.runId, 'run'),
+        ...(safeState ? { state: safeState } : {}),
+        ...(safeSummary ? { summary: safeSummary } : {}),
+        ...(safeBusinessAnswer ? { businessAnswer: safeBusinessAnswer } : {}),
+        ...(safeProvider ? { provider: safeProvider } : {}),
+        finalStopReason: receipt.finalStopReason,
+    };
+}
+function portableRuntimeWorkspaceV5(value, profile, salt) {
+    const workspace = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+    if (!workspace)
+        return undefined;
+    const pseudoIdentifier = (value, kind) => typeof value === 'string'
+        ? (profile === 'strict' ? pseudo(value, salt, kind) : value)
+        : undefined;
+    const sourceValues = new Set([
+        'certified', 'semantic', 'governed_relational', 'exploratory', 'dbt_manifest', 'runtime_schema', 'vector', 'conversation', 'business_context',
+    ]);
+    const statuses = new Set(['available', 'empty', 'stale', 'unavailable', 'errored', 'skipped']);
+    const toolKinds = new Set(['retrieve_snapshot', 'candidate_extension', 'compiler_broker', 'provider_meaning', 'execute', 'repair']);
+    const toolStatuses = new Set(['completed', 'skipped', 'failed']);
+    const reasonCodes = new Set([
+        'snapshot_acquired', 'broker_retrieval_required', 'snapshot_retrieval_failed', 'shadow_preserves_legacy_decision',
+        'meaning_resolution_completed', 'canonical_or_structured_binding', 'meaning_resolution_failed', 'meaning_resolution_unavailable',
+        'execution_completed', 'execution_failed', 'repair_completed', 'repair_exhausted', 'no_compiler_selected',
+    ]);
+    const finiteCount = (value) => typeof value === 'number' && Number.isFinite(value)
+        ? Math.max(0, Math.min(10_000, Math.floor(value)))
+        : undefined;
+    const sourceCoverage = Array.isArray(workspace.sourceCoverage)
+        ? workspace.sourceCoverage.flatMap((coverage) => {
+            if (!coverage || typeof coverage !== 'object' || Array.isArray(coverage))
+                return [];
+            const record = coverage;
+            if (typeof record.source !== 'string' || !sourceValues.has(record.source)
+                || typeof record.status !== 'string' || !statuses.has(record.status))
+                return [];
+            const candidateCount = finiteCount(record.candidateCount);
+            return [{ source: record.source, status: record.status, ...(candidateCount !== undefined ? { candidateCount } : {}) }];
+        })
+        : [];
+    const tools = Array.isArray(workspace.tools)
+        ? workspace.tools.flatMap((tool) => {
+            if (!tool || typeof tool !== 'object' || Array.isArray(tool))
+                return [];
+            const record = tool;
+            if (typeof record.id !== 'string' || typeof record.kind !== 'string' || !toolKinds.has(record.kind)
+                || typeof record.status !== 'string' || !toolStatuses.has(record.status))
+                return [];
+            return [{
+                    id: pseudoIdentifier(record.id, 'tool'),
+                    kind: record.kind,
+                    status: record.status,
+                    reasonCode: typeof record.reasonCode === 'string' && reasonCodes.has(record.reasonCode)
+                        ? record.reasonCode
+                        : 'unrecognized_reason',
+                }];
+        })
+        : [];
+    const admittedCandidateCount = finiteCount(workspace.admittedCandidateCount);
+    const excludedCandidateCount = finiteCount(workspace.excludedCandidateCount);
+    return {
+        ...(typeof workspace.snapshotId === 'string' ? { snapshotId: pseudoIdentifier(workspace.snapshotId, 'snapshot') } : {}),
+        ...(typeof workspace.sourceFingerprint === 'string' ? { sourceFingerprint: pseudoIdentifier(workspace.sourceFingerprint, 'source') } : {}),
+        ...(admittedCandidateCount !== undefined ? { admittedCandidateCount } : {}),
+        ...(excludedCandidateCount !== undefined ? { excludedCandidateCount } : {}),
+        sourceCoverage,
+        tools,
+    };
+}
 /**
  * Receipt export is intentionally stricter than its source type: only the
  * one enumerated relationship proof requirement is portable.  This prevents a