agentskeptic 6.0.1 → 6.2.0

package/dist/actionableFailure.d.ts

@@ -3,7 +3,8 @@
  * Pair with JSON Schema enums on workflowTruthReport / cli-error-envelope / run-comparison-report.
  */
 import { type OperationalCode } from "./cliOperationalCodes.js";
-import type { ActionableFailure, ActionableFailureCategory, ActionableFailureSeverity, FailureAnalysisBase, RecommendedActionCode, WorkflowEngineResult } from "./types.js";
+import type { QuickVerifyReport } from "./quickVerify/runQuickVerify.js";
+import type { ActionableFailure, ActionableFailureCategory, ActionableFailureSeverity, FailureAnalysisBase, RecommendedActionCode, RemediationDecision, WorkflowEngineResult, WorkflowResult } from "./types.js";
 export declare const ACTIONABLE_FAILURE_CATEGORIES: readonly ["decision_error", "bad_input", "retrieval_failure", "control_flow_problem", "state_inconsistency", "downstream_execution_failure", "ambiguous", "unclassified"];
 export declare const ACTIONABLE_FAILURE_SEVERITIES: readonly ["high", "medium", "low"];
 type RemediationRow = {
@@ -29,6 +30,12 @@ export declare const OPERATIONAL_CODE_TO_SEVERITY: Record<OperationalCode, Actio
 export declare const OPERATIONAL_CODE_TO_RECOMMENDED_ACTION: Record<OperationalCode, RecommendedActionCode>;
 export declare const OPERATIONAL_CODE_TO_AUTOMATION_SAFE: Record<OperationalCode, boolean>;
 export declare function deriveActionableFailureOperational(code: string): ActionableFailure;
+export declare function deriveQuickRemediationAlignment(reasonCodes: readonly string[]): {
+    recommendedAction: RecommendedActionCode;
+    automationSafe: boolean;
+};
+export declare function deriveRemediationDecisionFromWorkflowResult(result: WorkflowResult): RemediationDecision;
+export declare function deriveRemediationDecisionFromQuickReport(report: QuickVerifyReport, workflowId: string): RemediationDecision;
 export type PerRunActionable = {
     runIndex: number;
     category: string;

package/dist/actionableFailure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actionableFailure.d.ts","sourceRoot":"","sources":["../src/actionableFailure.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAC;AASvF,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EACzB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,6BAA6B,2KASe,CAAC;AAE1D,eAAO,MAAM,6BAA6B,oCAAoF,CAAC;AAE/H,KAAK,cAAc,GAAG;IAAE,iBAAiB,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CAAC;AAyB5F,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAIxE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAG7E,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAS1E,CAAC;AA6NF,4GAA4G;AAC5G,wBAAgB,4CAA4C,CAAC,IAAI,EAAE,MAAM,GAAG,yBAAyB,CAWpG;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAWlF;AA2FD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,mBAAmB,GAAG,yBAAyB,CAqBxG;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,yBAAyB,CAU9F;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,oBAAoB,EAC5B,eAAe,EAAE,mBAAmB,GACnC,iBAAiB,CAQnB;AAwBD,6DAA6D;AAC7D,eAAO,MAAM,uCAAuC,EAAE,MAAM,CAAC,eAAe,EAAE,yBAAyB,CACtF,CAAC;AAElB,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,eAAe,EAAE,yBAAyB,CAAmB,CAAC;AAEhH,eAAO,MAAM,sCAAsC,EAAE,MAAM,CAAC,eAAe,EAAE,qBAAqB,CACxE,CAAC;AAE3B,eAAO,MAAM,mCAAmC,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,CAAyB,CAAC;AAE3G,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAiBlF;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,qBAAqB,CAAC;IACzC,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,mBAAmB,EAAE,MAAM,EAAE,GAAG,MAAM,CAa1E;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,+BAA+B,EAAE,CAoB/G;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAS7G"}
+{"version":3,"file":"actionableFailure.d.ts","sourceRoot":"","sources":["../src/actionableFailure.ts"],"names":[],"mappings":"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"}

package/dist/actionableFailure.js

@@ -5,7 +5,13 @@
 import { CLI_OPERATIONAL_CODES } from "./cliOperationalCodes.js";
 import { REASON_CODE_TO_ORIGIN, RUN_LEVEL_CODE_TO_ORIGIN, STEP_NO_REASON_CODE, TEST_BLOCKING_CODE, } from "./failureOriginCatalog.js";
 import { OPERATIONAL_DISPOSITION } from "./operationalDisposition.js";
+import { buildFailureAnalysis } from "./failureAnalysis.js";
 import { REGISTRY_RESOLVER_CODE, SQL_VERIFICATION_OUTCOME_CODE } from "./wireReasonCodes.js";
+import { quickVerifyReportToSyntheticEngine, syntheticQuickFailureAnalysis, } from "./quickSyntheticWorkflow.js";
+import { redactEvidenceString } from "./redactEvidenceString.js";
+import { classifyWorkflowBlocker, collectWorkflowCodes } from "./workflowFailureSignals.js";
+import { workflowResultToEngineSlice } from "./workflowResultSlice.js";
+import { AUTOMATION_BOUNDARY_CONNECTOR, remediationMessageForRecommendedAction } from "./remediationMessage.js";
 export const ACTIONABLE_FAILURE_CATEGORIES = [
     "decision_error",
     "bad_input",
@@ -155,7 +161,7 @@ const STEP_CODE_TO_REMEDIATION = {
     },
     [SQL_VERIFICATION_OUTCOME_CODE.CONNECTOR_ERROR]: {
         recommendedAction: "improve_read_connectivity",
-        automationSafe: false,
+        automationSafe: true,
     },
     [SQL_VERIFICATION_OUTCOME_CODE.ROW_SHAPE_MISMATCH]: {
         recommendedAction: "improve_read_connectivity",
@@ -467,6 +473,587 @@ export function deriveActionableFailureOperational(code) {
         automationSafe: row.automationSafe,
     };
 }
+function syntheticFailureBaseWorkflow(result) {
+    const codes = [...collectWorkflowCodes(result)].sort((a, b) => a.localeCompare(b)).slice(0, 12);
+    return {
+        summary: "Synthetic failure analysis for evidence completeness fallback.",
+        primaryOrigin: "workflow_flow",
+        confidence: "medium",
+        unknownReasonCodes: [],
+        evidence: codes.length > 0
+            ? [{ scope: "run_level", codes }]
+            : [{ scope: "step", codes: ["UNCLASSIFIED_GAP"], seq: 0, toolId: "" }],
+        alternativeHypotheses: undefined,
+    };
+}
+function nextActionEntry(code) {
+    return {
+        id: code,
+        text: redactEvidenceString(remediationMessageForRecommendedAction(code), 500),
+    };
+}
+const AUTOMATION_LABELS = {
+    read_only_retry: "Safe automatic action: retry read-only verification with the same inputs.",
+    input_regeneration_candidate: "Automation candidate: repair inputs outside the verifier; AgentSkeptic will not mutate external systems.",
+    human_write_required: "Human or external system must change state; AgentSkeptic will not mutate data.",
+    never_auto_mutate: "Manual judgment required; do not automate mutation from this result.",
+};
+const AUTOMATION_BOUNDARY = "AgentSkeptic is a read-only verifier. It does not mutate databases, rewrite inputs, or execute remediation.";
+const RERUN_LABELS = {
+    same_input_verify: "Rerun verify with the same inputs after the read-only prerequisite is restored.",
+    after_input_fix_verify: "Rerun verify after registry, events, tool parameters, or verification inputs are corrected.",
+    after_state_fix_verify: "Rerun verify after downstream state matches the expected state.",
+    after_manual_review_verify: "Rerun verify after a human reviewer chooses and applies the correct fix path.",
+    no_rerun_needed: "No rerun is required for this trusted outcome.",
+};
+function sortUniqueStrings(values) {
+    return [...new Set(values.filter((v) => v.length > 0))].sort((a, b) => a.localeCompare(b));
+}
+function primaryCode(codes) {
+    return codes[0] ?? "";
+}
+function automationClassForAction(row, code) {
+    if (row.automationSafe && row.recommendedAction === "improve_read_connectivity")
+        return "read_only_retry";
+    const action = row.recommendedAction;
+    switch (action) {
+        case "correct_verification_inputs":
+        case "fix_event_ingest_and_steps":
+        case "fix_event_sequence_order":
+        case "fix_run_context_controls":
+        case "fix_cli_usage":
+        case "fix_registry_events_or_compare_files":
+        case "fix_verification_database_connection":
+        case "fix_saved_workflow_json":
+        case "fix_compare_workflow_inputs":
+        case "fix_execution_trace_structure":
+        case "fix_verification_policy_and_hook":
+        case "fix_plan_document_and_patterns":
+        case "fix_plan_transition_cli_and_refs":
+        case "upgrade_git_or_retry_git":
+            return "input_regeneration_candidate";
+        case "reconcile_downstream_state":
+        case "deduplicate":
+            return "human_write_required";
+        case "improve_read_connectivity":
+            return code === SQL_VERIFICATION_OUTCOME_CODE.CONNECTOR_ERROR ? "read_only_retry" : "input_regeneration_candidate";
+        case "manual_review":
+        case "resolve_multi_effect_failures":
+        case "align_tool_observations":
+            return "never_auto_mutate";
+        case "none":
+            return "read_only_retry";
+        default:
+            return "never_auto_mutate";
+    }
+}
+function rerunPathTypeForAction(row, automationClass) {
+    if (row.recommendedAction === "none")
+        return "no_rerun_needed";
+    if (automationClass === "read_only_retry")
+        return "same_input_verify";
+    if (automationClass === "human_write_required")
+        return "after_state_fix_verify";
+    if (automationClass === "never_auto_mutate")
+        return "after_manual_review_verify";
+    return "after_input_fix_verify";
+}
+function rerunPathForType(type) {
+    switch (type) {
+        case "same_input_verify":
+            return {
+                type,
+                sameInputs: true,
+                prerequisite: "Read-only database or witness connectivity is restored.",
+                meaningfulWhen: "The same captured events, registry, workflow, and read target can be checked again.",
+                readinessLabel: RERUN_LABELS[type],
+            };
+        case "after_input_fix_verify":
+            return {
+                type,
+                sameInputs: false,
+                prerequisite: "Registry, events, tool parameters, or verification inputs are corrected.",
+                meaningfulWhen: "The corrected inputs express the expected state the verifier should check.",
+                readinessLabel: RERUN_LABELS[type],
+            };
+        case "after_state_fix_verify":
+            return {
+                type,
+                sameInputs: false,
+                prerequisite: "Downstream state has been reconciled to the expected state.",
+                meaningfulWhen: "The database or external witness state should now satisfy the verification expectation.",
+                readinessLabel: RERUN_LABELS[type],
+            };
+        case "after_manual_review_verify":
+            return {
+                type,
+                sameInputs: false,
+                prerequisite: "A human reviewer chooses and applies the correct fix path.",
+                meaningfulWhen: "The reviewer has resolved which hypothesis is true and updated state or inputs accordingly.",
+                readinessLabel: RERUN_LABELS[type],
+            };
+        case "no_rerun_needed":
+            return {
+                type,
+                sameInputs: true,
+                prerequisite: "Verification is already trusted under the configured rules.",
+                meaningfulWhen: "No failed check blocks trust.",
+                readinessLabel: RERUN_LABELS[type],
+            };
+    }
+}
+function rowForCodes(scope, codes) {
+    const list = [...codes];
+    switch (scope) {
+        case "run_level":
+        case "quick_ingest":
+            return remediationForRunLevelItem(list);
+        case "event_sequence":
+            return remediationForEventSequenceItem(list);
+        case "run_context":
+            return remediationForRunContextItem(list);
+        case "step":
+        case "effect":
+        case "quick_unit":
+            return remediationForStepOrEffectItem(list);
+    }
+}
+export function deriveQuickRemediationAlignment(reasonCodes) {
+    const sorted = sortUniqueStrings(reasonCodes);
+    const c = sorted[0] ?? "";
+    if (c === "CONNECTOR_ERROR")
+        return { recommendedAction: "improve_read_connectivity", automationSafe: false };
+    if (c === "MAPPING_FAILED" || c.startsWith("RESOLVE_") || c.includes("REGISTRY") || c === "UNKNOWN_TOOL") {
+        return { recommendedAction: "correct_verification_inputs", automationSafe: false };
+    }
+    if (c === "ROW_ABSENT" ||
+        c === "VALUE_MISMATCH" ||
+        c === "DUPLICATE_ROWS" ||
+        c === "RELATIONAL_EXPECTATION_MISMATCH" ||
+        c === "RELATIONAL_SCALAR_UNUSABLE" ||
+        c === "ROW_PRESENT_WHEN_FORBIDDEN") {
+        return { recommendedAction: "reconcile_downstream_state", automationSafe: false };
+    }
+    return { recommendedAction: "manual_review", automationSafe: false };
+}
+function itemAutomation(row, code) {
+    const cls = automationClassForAction(row, code);
+    return {
+        class: cls,
+        label: AUTOMATION_LABELS[cls],
+        boundary: cls === "read_only_retry" ? AUTOMATION_BOUNDARY_CONNECTOR : AUTOMATION_BOUNDARY,
+    };
+}
+function reviewForItem(opts) {
+    const required = opts.action === "manual_review";
+    if (!required)
+        return { required: false };
+    const hypotheses = opts.fa?.alternativeHypotheses?.map((h) => `origin=${h.primaryOrigin}: ${h.rationale}`).slice(0, 6) ?? [];
+    return {
+        required: true,
+        decisionPrompt: "Decide which hypothesis explains the mismatch before changing state or inputs.",
+        ...(hypotheses.length ? { hypotheses } : {}),
+        knownFacts: opts.fa !== null && opts.fa !== undefined
+            ? [
+                `primary_origin=${opts.fa.primaryOrigin}`,
+                `confidence=${opts.fa.confidence}`,
+                `summary=${opts.fa.summary}`,
+            ].slice(0, 12)
+            : undefined,
+        evidenceToInspect: opts.evidenceToInspect.slice(0, 8),
+    };
+}
+function makeRemediationItem(opts) {
+    const codes = sortUniqueStrings(opts.reasonCodes).slice(0, 8);
+    const row = opts.forceManualReview ? MANUAL_REMEDIATION : (opts.row ?? rowForCodes(opts.scope, codes));
+    const automation = itemAutomation(row, primaryCode(codes));
+    const rerunPath = rerunPathForType(rerunPathTypeForAction(row, automation.class));
+    const actionText = redactEvidenceString(remediationMessageForRecommendedAction(row.recommendedAction), 500);
+    return {
+        id: redactEvidenceString(opts.id, 128),
+        scope: opts.scope,
+        primary: opts.primary,
+        failedCheck: redactEvidenceString(opts.failedCheck, 256),
+        reasonCodes: codes.map((c) => redactEvidenceString(c, 128)),
+        reason: redactEvidenceString(opts.reason || "Verification check did not pass.", 1024),
+        recommendedAction: row.recommendedAction,
+        actionText,
+        expectedState: {
+            summary: redactEvidenceString(opts.expectedSummary || "Expected state must satisfy the verification contract.", 1024),
+            ...(opts.projectionKind !== undefined ? { projectionKind: opts.projectionKind } : {}),
+        },
+        automation,
+        humanReview: reviewForItem({
+            action: row.recommendedAction,
+            fa: opts.fa,
+            evidenceToInspect: opts.evidenceToInspect,
+        }),
+        rerunPath,
+    };
+}
+function primaryEvidenceKey(fa) {
+    const ev = fa?.evidence[0];
+    if (ev === undefined)
+        return null;
+    if (ev.scope === "step" && ev.seq !== undefined)
+        return `step:${ev.seq}`;
+    if (ev.scope === "effect" && ev.seq !== undefined && ev.effectId !== undefined)
+        return `effect:${ev.seq}:${ev.effectId}`;
+    if (ev.scope === "run_level")
+        return "run_level";
+    if (ev.scope === "event_sequence")
+        return "event_sequence";
+    if (ev.scope === "run_context")
+        return "run_context";
+    return null;
+}
+function effectReasonCodes(effect) {
+    return effect.reasons.map((r) => r.code);
+}
+function stepReasonCodes(step) {
+    return step.reasons.map((r) => r.code);
+}
+function stepExpectedSummary(step) {
+    return `Expected state: ${step.verifyTarget ?? step.intendedEffect.narrative}; observed: ${step.observedStateSummary}`;
+}
+function effectExpectedSummary(step, effectId) {
+    return `Expected effect ${effectId} within ${step.verifyTarget ?? step.intendedEffect.narrative}; observed: ${step.observedStateSummary}`;
+}
+function buildWorkflowRemediationItems(result) {
+    if (result.status === "complete" && result.workflowTruthReport.failureAnalysis === null)
+        return [];
+    const truth = result.workflowTruthReport;
+    const fa = truth.failureAnalysis;
+    const primaryKey = primaryEvidenceKey(fa);
+    const projectionKind = truth.correctnessDefinition?.enforcementKind;
+    const primaryExpected = truth.correctnessDefinition?.mustAlwaysHold;
+    const items = [];
+    if (truth.runLevelIssues.length > 0) {
+        const codes = truth.runLevelIssues.map((r) => r.code);
+        items.push(makeRemediationItem({
+            id: "run_level",
+            scope: "run_level",
+            primary: primaryKey === "run_level",
+            failedCheck: "run-level verification input",
+            reasonCodes: codes,
+            reason: truth.runLevelIssues.map((r) => r.message).join("; "),
+            expectedSummary: primaryKey === "run_level" && primaryExpected !== undefined
+                ? primaryExpected
+                : "Expected a valid captured run with no run-level ingest or planning failures.",
+            projectionKind: primaryKey === "run_level" ? projectionKind : undefined,
+            fa,
+            evidenceToInspect: ["workflowTruthReport.runLevelIssues", "workflowTruthReport.failureAnalysis"],
+        }));
+    }
+    if (truth.eventSequence.kind === "irregular") {
+        const codes = truth.eventSequence.issues.map((r) => r.code);
+        items.push(makeRemediationItem({
+            id: "event_sequence",
+            scope: "event_sequence",
+            primary: primaryKey === "event_sequence",
+            failedCheck: "event sequence",
+            reasonCodes: codes,
+            reason: truth.eventSequence.issues.map((r) => r.message).join("; "),
+            expectedSummary: primaryKey === "event_sequence" && primaryExpected !== undefined
+                ? primaryExpected
+                : "Expected monotonic, coherent event capture for this workflow.",
+            projectionKind: primaryKey === "event_sequence" ? projectionKind : undefined,
+            fa,
+            evidenceToInspect: ["workflowTruthReport.eventSequence", "eventSequenceIntegrity"],
+        }));
+    }
+    for (const ev of fa?.evidence ?? []) {
+        if (ev.scope !== "run_context")
+            continue;
+        const codes = ev.codes ?? [];
+        items.push(makeRemediationItem({
+            id: `run_context:${ev.ingestIndex ?? 0}`,
+            scope: "run_context",
+            primary: primaryKey === "run_context",
+            failedCheck: `run context before ingest ${ev.ingestIndex ?? "unknown"}`,
+            reasonCodes: codes,
+            reason: `Run context failed before the evaluated observation: ${codes.join(",")}`,
+            expectedSummary: primaryKey === "run_context" && primaryExpected !== undefined
+                ? primaryExpected
+                : "Expected retrieval, model, control, and tool context to allow fair verification.",
+            projectionKind: primaryKey === "run_context" ? projectionKind : undefined,
+            fa,
+            evidenceToInspect: ["workflowTruthReport.executionPathFindings", "verificationRunContext"],
+        }));
+    }
+    for (const step of truth.steps) {
+        if (step.outcomeLabel === "VERIFIED")
+            continue;
+        if (step.effects !== undefined && step.effects.length > 0) {
+            for (const effect of step.effects) {
+                if (effect.outcomeLabel === "VERIFIED")
+                    continue;
+                const id = `effect:${step.seq}:${effect.id}`;
+                const codes = effectReasonCodes(effect);
+                items.push(makeRemediationItem({
+                    id,
+                    scope: "effect",
+                    primary: primaryKey === id,
+                    failedCheck: `Failed check: effect ${effect.id} on step ${step.seq}`,
+                    reasonCodes: codes,
+                    reason: effect.reasons[0]?.message ?? effect.outcomeLabel,
+                    expectedSummary: effectExpectedSummary(step, effect.id),
+                    fa: null,
+                    evidenceToInspect: [
+                        `workflowTruthReport.steps[seq=${step.seq}].effects[id=${effect.id}]`,
+                        `workflowTruthReport.steps[seq=${step.seq}].observedStateSummary`,
+                    ],
+                }));
+            }
+            continue;
+        }
+        const id = `step:${step.seq}`;
+        const codes = stepReasonCodes(step);
+        items.push(makeRemediationItem({
+            id,
+            scope: "step",
+            primary: primaryKey === id,
+            failedCheck: `Failed check: step ${step.seq}${step.toolId ? ` (${step.toolId})` : ""}`,
+            reasonCodes: codes,
+            reason: step.reasons[0]?.message ?? step.outcomeLabel,
+            expectedSummary: primaryKey === id && primaryExpected !== undefined ? primaryExpected : stepExpectedSummary(step),
+            projectionKind: primaryKey === id ? projectionKind : undefined,
+            fa: primaryKey === id ? fa : null,
+            evidenceToInspect: [
+                `workflowTruthReport.steps[seq=${step.seq}]`,
+                "workflowTruthReport.failureExplanation",
+                "workflowTruthReport.correctnessDefinition",
+            ],
+            forceManualReview: primaryKey === id &&
+                fa !== null &&
+                fa !== undefined &&
+                fa.actionableFailure.recommendedAction === "manual_review",
+        }));
+    }
+    if (items.length === 0 && fa !== null) {
+        items.push(makeRemediationItem({
+            id: "failure_analysis",
+            scope: "run_level",
+            primary: true,
+            failedCheck: "verification failure analysis",
+            reasonCodes: fa.evidence[0]?.codes ?? ["UNCLASSIFIED_GAP"],
+            reason: fa.summary,
+            expectedSummary: primaryExpected ?? "Expected state must satisfy the verification contract.",
+            projectionKind,
+            fa,
+            evidenceToInspect: ["workflowTruthReport.failureAnalysis"],
+            forceManualReview: true,
+        }));
+    }
+    return items.slice(0, 32);
+}
+function buildQuickRemediationItems(report) {
+    if (report.verdict === "pass")
+        return [];
+    const items = [];
+    if (report.ingest.reasonCodes.length > 0 || report.units.length === 0) {
+        const codes = report.ingest.reasonCodes.length ? report.ingest.reasonCodes : ["INGEST_NO_STRUCTURED_TOOL_ACTIVITY"];
+        const row = deriveQuickRemediationAlignment(codes);
+        items.push(makeRemediationItem({
+            id: "quick_ingest",
+            scope: "quick_ingest",
+            primary: true,
+            failedCheck: "quick verify ingest",
+            reasonCodes: codes,
+            reason: codes.join(","),
+            expectedSummary: "Expected structured tool activity that can be mapped into provisional read-only SQL checks.",
+            row,
+            evidenceToInspect: ["quick.ingest.reasonCodes", "quick.units"],
+        }));
+    }
+    for (const unit of report.units) {
+        if (unit.verdict === "verified")
+            continue;
+        const row = deriveQuickRemediationAlignment(unit.reasonCodes);
+        items.push(makeRemediationItem({
+            id: `quick:${unit.unitId}`,
+            scope: "quick_unit",
+            primary: items.length === 0,
+            failedCheck: `Failed check: quick unit ${unit.unitId}`,
+            reasonCodes: unit.reasonCodes.length ? unit.reasonCodes : [`quick_unit_${unit.verdict}`],
+            reason: unit.reconciliation.verification_verdict,
+            expectedSummary: unit.correctnessDefinition?.mustAlwaysHold ?? unit.reconciliation.expected,
+            projectionKind: unit.correctnessDefinition?.enforcementKind,
+            row,
+            evidenceToInspect: [`quick.units[id=${unit.unitId}]`, "quick.evidenceCompleteness"],
+        }));
+    }
+    return items.slice(0, 32);
+}
+function buildOrderedNextActionsWorkflow(result, primary) {
+    const out = [nextActionEntry(primary)];
+    const seen = new Set([primary]);
+    const C = collectWorkflowCodes(result);
+    if (C.has(SQL_VERIFICATION_OUTCOME_CODE.UNKNOWN_TOOL) && !seen.has("fix_registry_events_or_compare_files")) {
+        seen.add("fix_registry_events_or_compare_files");
+        out.push(nextActionEntry("fix_registry_events_or_compare_files"));
+    }
+    if (!(result.status === "complete" && primary === "none")) {
+        const sec = "fix_registry_events_or_compare_files";
+        if (!seen.has(sec)) {
+            seen.add(sec);
+            out.push(nextActionEntry(sec));
+        }
+    }
+    return out.slice(0, 5);
+}
+function deriveRerunReadinessWorkflow(actionableFailure, blocker, status) {
+    if (status === "complete" && actionableFailure.recommendedAction === "none")
+        return "rerun_ready_same_inputs";
+    if (actionableFailure.automationSafe &&
+        actionableFailure.recommendedAction === "improve_read_connectivity") {
+        return "rerun_ready_same_inputs";
+    }
+    switch (blocker) {
+        case "ingest_empty":
+        case "ingest_unstructured":
+            return "fix_inputs_before_rerun";
+        case "registry_unknown_tool":
+        case "registry_resolution":
+            return "fix_registry_before_rerun";
+        case "state_mismatch":
+        case "database_access":
+            return "reconcile_state_before_rerun";
+        case "verification_incomplete":
+            return "manual_review_before_rerun";
+        default:
+            return "manual_review_before_rerun";
+    }
+}
+function quickSignalFromReport(report) {
+    const ingest = report.ingest;
+    const units = report.units;
+    const verdict = report.verdict;
+    let quickSignal = "sql_ran_uncertain";
+    if (ingest.reasonCodes.includes("INGEST_NO_ACTIONS")) {
+        quickSignal = "no_actions";
+    }
+    else if (ingest.reasonCodes.includes("INGEST_NO_STRUCTURED_TOOL_ACTIVITY")) {
+        quickSignal = "no_structured_activity";
+    }
+    else if (units.length === 0) {
+        quickSignal = "no_sql_candidates";
+    }
+    else {
+        const mappedOk = units.filter((u) => !u.reasonCodes.includes("MAPPING_FAILED")).length > 0;
+        if (!mappedOk) {
+            quickSignal = "no_sql_candidates";
+        }
+        else if (verdict === "pass")
+            quickSignal = "sql_ran_passed";
+        else if (verdict === "fail")
+            quickSignal = "sql_ran_failed";
+        else
+            quickSignal = "sql_ran_uncertain";
+    }
+    return { quickSignal };
+}
+function classifyQuickPreviewBlocker(quickSignal, verdict) {
+    if (quickSignal === "no_actions")
+        return "ingest_empty";
+    if (quickSignal === "no_structured_activity")
+        return "ingest_unstructured";
+    if (quickSignal === "no_sql_candidates")
+        return "registry_resolution";
+    if (quickSignal === "sql_ran_failed")
+        return "state_mismatch";
+    if (verdict === "uncertain")
+        return "verification_incomplete";
+    return "preview_lane";
+}
+function buildOrderedNextActionsQuick(report, primary) {
+    const out = [nextActionEntry(primary)];
+    const seen = new Set([primary]);
+    if (report.verdict !== "pass") {
+        const sec = "fix_registry_events_or_compare_files";
+        if (!seen.has(sec)) {
+            seen.add(sec);
+            out.push(nextActionEntry(sec));
+        }
+    }
+    return out.slice(0, 5);
+}
+function deriveRerunReadinessQuick(blocker, verdict, actionableFailure) {
+    if (verdict === "pass")
+        return "rerun_ready_same_inputs";
+    if (actionableFailure.automationSafe &&
+        actionableFailure.recommendedAction === "improve_read_connectivity") {
+        return "rerun_ready_same_inputs";
+    }
+    switch (blocker) {
+        case "ingest_empty":
+        case "ingest_unstructured":
+            return "fix_inputs_before_rerun";
+        case "registry_resolution":
+            return "fix_registry_before_rerun";
+        case "state_mismatch":
+            return "reconcile_state_before_rerun";
+        case "verification_incomplete":
+            return "manual_review_before_rerun";
+        default:
+            return "manual_review_before_rerun";
+    }
+}
+export function deriveRemediationDecisionFromWorkflowResult(result) {
+    const truth = result.workflowTruthReport;
+    const fa = truth.failureAnalysis;
+    const engineSlice = workflowResultToEngineSlice(result);
+    if (fa === null && result.status === "complete") {
+        const noneFailure = {
+            category: "unclassified",
+            severity: "low",
+            recommendedAction: "none",
+            automationSafe: false,
+        };
+        return {
+            actionableFailure: noneFailure,
+            orderedNextActions: [nextActionEntry("none")],
+            rerunReadiness: "rerun_ready_same_inputs",
+            remediationItems: [],
+            rerunPath: rerunPathForType("no_rerun_needed"),
+        };
+    }
+    let actionableFailure;
+    if (fa !== null) {
+        actionableFailure = fa.actionableFailure;
+    }
+    else {
+        actionableFailure = deriveActionableFailureWorkflow(engineSlice, syntheticFailureBaseWorkflow(result));
+    }
+    const blocker = classifyWorkflowBlocker(result);
+    const orderedNextActions = buildOrderedNextActionsWorkflow(result, actionableFailure.recommendedAction);
+    const rerunReadiness = deriveRerunReadinessWorkflow(actionableFailure, blocker, result.status);
+    const remediationItems = buildWorkflowRemediationItems(result);
+    const rerunPath = remediationItems.find((i) => i.primary)?.rerunPath ?? remediationItems[0]?.rerunPath ?? rerunPathForType("after_manual_review_verify");
+    return { actionableFailure, orderedNextActions, rerunReadiness, remediationItems, rerunPath };
+}
+export function deriveRemediationDecisionFromQuickReport(report, workflowId) {
+    const engine = quickVerifyReportToSyntheticEngine(report, workflowId);
+    const fa = buildFailureAnalysis(engine);
+    let actionableFailure;
+    if (fa !== null) {
+        actionableFailure = deriveActionableFailureWorkflow(engine, fa);
+    }
+    else {
+        actionableFailure = deriveActionableFailureWorkflow(engine, syntheticQuickFailureAnalysis(report));
+    }
+    const { quickSignal } = quickSignalFromReport(report);
+    const blocker = classifyQuickPreviewBlocker(quickSignal, report.verdict);
+    const orderedNextActions = buildOrderedNextActionsQuick(report, actionableFailure.recommendedAction);
+    const rerunReadiness = deriveRerunReadinessQuick(blocker, report.verdict, actionableFailure);
+    const remediationItems = buildQuickRemediationItems(report);
+    const rerunPath = report.verdict === "pass"
+        ? rerunPathForType("no_rerun_needed")
+        : remediationItems.find((i) => i.primary)?.rerunPath ??
+            remediationItems[0]?.rerunPath ??
+            rerunPathForType("after_manual_review_verify");
+    return { actionableFailure, orderedNextActions, rerunReadiness, remediationItems, rerunPath };
+}
 /** Longest run of consecutive integers contained in `sortedUniqueIndices`. */
 export function maxConsecutiveStreak(sortedUniqueIndices) {
     if (sortedUniqueIndices.length === 0)