martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/surface-signals.d.ts

@@ -0,0 +1,21 @@
+import type { LoopAttempt } from "../contracts/index.js";
+export interface SurfaceSignalInput {
+    objective?: string;
+    verificationPlan?: string[];
+    summary?: string;
+    failureMessage?: string;
+    diff?: string;
+    changedFiles?: string[];
+    previousAttempts?: Array<Pick<LoopAttempt, "summary">>;
+}
+export interface SurfaceSignals {
+    dependencyTouchedFileCount: number;
+    migrationTouchedFileCount: number;
+    mergeConflictSignalCount: number;
+    ambiguitySignalCount: number;
+    observabilityNoiseSignalCount: number;
+    workspaceGraphRiskScore: number;
+    crossBoundaryRiskScore: number;
+}
+export declare function analyzeLoopSurface(input: SurfaceSignalInput): SurfaceSignals;
+export declare function buildSurfaceGuidance(input: SurfaceSignalInput): string[];

package/dist/vendor/core/surface-signals.js

@@ -0,0 +1,139 @@
+export function analyzeLoopSurface(input) {
+    const changedFiles = (input.changedFiles ?? []).map(normalizePath);
+    const narrative = [
+        input.objective,
+        input.summary,
+        input.failureMessage,
+        input.diff,
+        ...(input.verificationPlan ?? []),
+        ...(input.previousAttempts?.map((attempt) => attempt.summary) ?? [])
+    ]
+        .filter(Boolean)
+        .join("\n")
+        .toLowerCase();
+    const dependencyTouchedFileCount = changedFiles.filter(isDependencySurface).length;
+    const migrationTouchedFileCount = changedFiles.filter(isMigrationSurface).length;
+    const mergeConflictSignalCount = countPhraseMatches(narrative, [
+        "merge conflict",
+        "conflict marker",
+        "conflict markers",
+        "rebase",
+        "cherry-pick",
+        "<<<<<<<",
+        ">>>>>>>"
+    ]) + (input.diff?.match(/^(<{7}|={7}|>{7})/gmu)?.length ?? 0);
+    const workspaceGraphSignals = countPhraseMatches(narrative, [
+        "monorepo",
+        "workspace graph",
+        "dependency graph",
+        "graph-wide",
+        "cross-package",
+        "package boundaries",
+        "downstream packages",
+        "transitive dependency",
+        "transitive toolchain",
+        "pnpm -r",
+        "workspace:",
+        "package manager",
+        "lockfile"
+    ]) + dependencyTouchedFileCount;
+    const crossBoundarySignals = countPhraseMatches(narrative, [
+        "cross-system",
+        "cross-package",
+        "cross-service",
+        "service boundary",
+        "producer-consumer",
+        "contract boundary",
+        "data contract",
+        "schema drift",
+        "external dependency",
+        "package boundaries"
+    ]) + migrationTouchedFileCount;
+    const ambiguitySignalCount = countPhraseMatches(narrative, [
+        "ambiguous",
+        "acceptance target",
+        "moving target",
+        "moving expectation",
+        "underspecified",
+        "seed-data divergence",
+        "oauth callback",
+        "callback loop",
+        "unclear ground truth",
+        "requirement boundary"
+    ]);
+    const observabilityNoiseSignalCount = countPhraseMatches(narrative, [
+        "alert-threshold",
+        "alert threshold",
+        "threshold-driven",
+        "flapping alert",
+        "flapping alerts",
+        "alert storm",
+        "signal-to-noise",
+        "noisy alert",
+        "noise"
+    ]);
+    return {
+        dependencyTouchedFileCount,
+        migrationTouchedFileCount,
+        mergeConflictSignalCount,
+        ambiguitySignalCount,
+        observabilityNoiseSignalCount,
+        workspaceGraphRiskScore: roundScore(Math.min(1, workspaceGraphSignals / 4)),
+        crossBoundaryRiskScore: roundScore(Math.min(1, crossBoundarySignals / 4))
+    };
+}
+export function buildSurfaceGuidance(input) {
+    const signals = analyzeLoopSurface(input);
+    const guidance = [];
+    if (signals.dependencyTouchedFileCount > 0 || signals.workspaceGraphRiskScore >= 0.5) {
+        guidance.push("Treat this as a dependency or workspace-graph boundary issue. Prefer one package or contract seam at a time, verify install/typecheck before broad build fan-out, and avoid graph-wide surgery unless the verifier proves the boundary is local.");
+    }
+    if (signals.migrationTouchedFileCount > 0 || signals.crossBoundaryRiskScore >= 0.5) {
+        guidance.push("Treat migration and data-contract edits as boundary work. Change one producer/consumer or migration seam at a time and verify the contract boundary before broad cleanup.");
+    }
+    if (signals.mergeConflictSignalCount > 0) {
+        guidance.push("Resolve the conflict surface first. Do not stack new edits on top of unresolved conflict markers; refresh the base, resolve the minimal conflicting files, then rerun verification.");
+    }
+    if (signals.ambiguitySignalCount > 0) {
+        guidance.push("Treat this as an acceptance-boundary issue. Freeze one explicit expected behavior, verify the smallest canonical case, and escalate once the target keeps moving.");
+    }
+    if (signals.observabilityNoiseSignalCount > 0) {
+        guidance.push("Treat this as an alert-noise issue. Adjust the smallest threshold seam or noise filter first, then re-verify signal quality before widening the observability patch.");
+    }
+    return guidance;
+}
+function normalizePath(file) {
+    return file.replace(/\\/gu, "/").toLowerCase();
+}
+function isDependencySurface(file) {
+    return (file === "package.json" ||
+        file.endsWith("/package.json") ||
+        file.endsWith("/pnpm-lock.yaml") ||
+        file === "pnpm-lock.yaml" ||
+        file.endsWith("/package-lock.json") ||
+        file === "package-lock.json" ||
+        file.endsWith("/yarn.lock") ||
+        file === "yarn.lock" ||
+        file.endsWith("/turbo.json") ||
+        file === "turbo.json");
+}
+function isMigrationSurface(file) {
+    return (file.includes("/migrations/") ||
+        file.startsWith("migrations/") ||
+        file.includes("prisma/migrations/") ||
+        file.endsWith("/schema.prisma") ||
+        file.endsWith("/supabase/config.toml"));
+}
+function countPhraseMatches(haystack, phrases) {
+    return phrases.reduce((count, phrase) => {
+        const matches = haystack.match(new RegExp(escapeRegExp(phrase), "gu"));
+        return count + (matches?.length ?? 0);
+    }, 0);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function roundScore(value) {
+    return Math.round(value * 100) / 100;
+}
+//# sourceMappingURL=surface-signals.js.map

package/dist/vendor/core/truth/truth-wall.d.ts

@@ -0,0 +1,51 @@
+export interface SettledFact {
+    factId: string;
+    content: string;
+    settledAt: string;
+}
+export interface TruthWall {
+    readonly runId: string;
+    readonly builtAt: string;
+    readonly facts: readonly SettledFact[];
+}
+export interface Hypothesis {
+    hypothesisId: string;
+    runId: string;
+    rootCause: string;
+    recordedAt: string;
+    testResult: "validated" | "invalidated" | "pending";
+    confidenceDelta: number;
+}
+export interface HypothesisLedger {
+    hypotheses: Hypothesis[];
+}
+export interface TruthWallInput {
+    runId: string;
+    facts: SettledFact[];
+    runDir: string;
+}
+/**
+ * Builds an immutable TruthWall from settled ledger facts at run start.
+ * Writes truth-wall.json to the run directory and freezes the returned object.
+ */
+export declare function buildTruthWall(input: TruthWallInput): Promise<TruthWall>;
+/**
+ * Creates an ephemeral mutable Map for scratch-space state during a run.
+ * Writes do NOT propagate to the truth wall.
+ */
+export declare function createWorkingMemory(): Map<string, unknown>;
+/**
+ * Loads an existing hypothesis ledger from the run directory, or returns an empty one.
+ */
+export declare function loadHypothesisLedger(runDir: string): Promise<HypothesisLedger>;
+/**
+ * Records a hypothesis in the ledger and persists hypothesis-ledger.json.
+ */
+export declare function recordHypothesis(ledger: HypothesisLedger, input: Omit<Hypothesis, "recordedAt">, runDir: string): Promise<Hypothesis>;
+/**
+ * Emits all three required run artifacts:
+ * - truth-wall.json (immutable settled facts)
+ * - hypothesis-ledger.json (per-attempt hypotheses)
+ * - working-memory.json (mutable scratch, never promoted to truth wall)
+ */
+export declare function emitRunArtifacts(runDir: string, wall: TruthWall, ledger: HypothesisLedger, workingMemory: Map<string, unknown>): Promise<void>;

package/dist/vendor/core/truth/truth-wall.js

@@ -0,0 +1,69 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+// ─── Truth Wall ───────────────────────────────────────────────────────────────
+/**
+ * Builds an immutable TruthWall from settled ledger facts at run start.
+ * Writes truth-wall.json to the run directory and freezes the returned object.
+ */
+export async function buildTruthWall(input) {
+    const wall = Object.freeze({
+        runId: input.runId,
+        builtAt: new Date().toISOString(),
+        facts: Object.freeze([...input.facts.map(f => Object.freeze({ ...f }))])
+    });
+    await writeFile(join(input.runDir, "truth-wall.json"), JSON.stringify(wall, null, 2), "utf8");
+    return wall;
+}
+// ─── Working Memory ───────────────────────────────────────────────────────────
+/**
+ * Creates an ephemeral mutable Map for scratch-space state during a run.
+ * Writes do NOT propagate to the truth wall.
+ */
+export function createWorkingMemory() {
+    return new Map();
+}
+// ─── Hypothesis Ledger ────────────────────────────────────────────────────────
+/**
+ * Loads an existing hypothesis ledger from the run directory, or returns an empty one.
+ */
+export async function loadHypothesisLedger(runDir) {
+    const ledgerPath = join(runDir, "hypothesis-ledger.json");
+    if (existsSync(ledgerPath)) {
+        const raw = await readFile(ledgerPath, "utf8");
+        return JSON.parse(raw);
+    }
+    return { hypotheses: [] };
+}
+/**
+ * Records a hypothesis in the ledger and persists hypothesis-ledger.json.
+ */
+export async function recordHypothesis(ledger, input, runDir) {
+    const hypothesis = {
+        ...input,
+        recordedAt: new Date().toISOString()
+    };
+    ledger.hypotheses.push(hypothesis);
+    await writeFile(join(runDir, "hypothesis-ledger.json"), JSON.stringify(ledger, null, 2), "utf8");
+    return hypothesis;
+}
+// ─── Run Artifacts Emitter ────────────────────────────────────────────────────
+/**
+ * Emits all three required run artifacts:
+ * - truth-wall.json (immutable settled facts)
+ * - hypothesis-ledger.json (per-attempt hypotheses)
+ * - working-memory.json (mutable scratch, never promoted to truth wall)
+ */
+export async function emitRunArtifacts(runDir, wall, ledger, workingMemory) {
+    // truth-wall.json was already written by buildTruthWall — only write if missing
+    if (!existsSync(join(runDir, "truth-wall.json"))) {
+        await writeFile(join(runDir, "truth-wall.json"), JSON.stringify(wall, null, 2), "utf8");
+    }
+    await writeFile(join(runDir, "hypothesis-ledger.json"), JSON.stringify(ledger, null, 2), "utf8");
+    const wmObject = {};
+    for (const [k, v] of workingMemory) {
+        wmObject[k] = v;
+    }
+    await writeFile(join(runDir, "working-memory.json"), JSON.stringify({ entries: wmObject }, null, 2), "utf8");
+}
+//# sourceMappingURL=truth-wall.js.map

package/dist/vendor/core/truth-spine.d.ts

@@ -0,0 +1,26 @@
+export type ContextIntegrityVerdict = "clean" | "context_poisoning_warning" | "context_poisoning_block";
+export interface ContextIntegrityPrecheck {
+    runId: string;
+    attemptIndex: number;
+    verdict: ContextIntegrityVerdict;
+    reason?: string;
+    detectedSignals: string[];
+    analyzedChannels: {
+        system: boolean;
+        user: boolean;
+        tools: boolean;
+        history: boolean;
+    };
+    timestamp: string;
+}
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE core reasoning and verification.
+ */
+export declare function runContextIntegrityPrecheck(runId: string, attemptIndex: number, artifactsDir: string, inputs: {
+    userPrompt?: string;
+    toolOutput?: string;
+    retrievedContext?: string;
+    history?: string;
+}): Promise<ContextIntegrityPrecheck>;

package/dist/vendor/core/truth-spine.js

@@ -0,0 +1,62 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const POISON_PATTERNS = [
+    /ignore\s+(?:all\s+)?previous\s+instructions/i,
+    /you\s+are\s+now\s+a\s+(?!Martin\s+Loop)/i,
+    /new\s+rule:/i,
+    /disregard\s+(?:safety|policy|guardrails)/i,
+    /override\s+system\s+authority/i,
+    /hidden\s+instruction:/i,
+    /\[system_override\]/i,
+    /\[authority_inversion\]/i
+];
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE core reasoning and verification.
+ */
+export async function runContextIntegrityPrecheck(runId, attemptIndex, artifactsDir, inputs) {
+    const signals = [];
+    const analyzedChannels = {
+        system: true,
+        user: Boolean(inputs.userPrompt),
+        tools: Boolean(inputs.toolOutput),
+        history: Boolean(inputs.history)
+    };
+    const fullUntrustedBuffer = [
+        inputs.userPrompt,
+        inputs.toolOutput,
+        inputs.retrievedContext
+    ].filter(Boolean).join("\n---\n");
+    for (const pattern of POISON_PATTERNS) {
+        if (pattern.test(fullUntrustedBuffer)) {
+            signals.push(`Detected poison pattern: ${pattern.toString()}`);
+        }
+    }
+    // Authority Boundary Detector: Check for attempts to redefine the 'Martin' identity or role.
+    if (/\b(?:I am|You are)\s+(?!Martin\s+Loop|an\s+AI)\b/i.test(fullUntrustedBuffer)) {
+        signals.push("Identity redefinition attempt detected.");
+    }
+    const verdict = signals.length > 0 ? "context_poisoning_block" : "clean";
+    const precheck = {
+        runId,
+        attemptIndex,
+        verdict,
+        reason: signals.length > 0 ? `Detected ${signals.length} poisoning signals.` : undefined,
+        detectedSignals: signals,
+        analyzedChannels,
+        timestamp: new Date().toISOString()
+    };
+    // Persist artifact: context-integrity-precheck.json
+    const artifactPath = join(artifactsDir, "context-integrity-precheck.json");
+    try {
+        const { mkdir } = await import("node:fs/promises");
+        await mkdir(artifactsDir, { recursive: true });
+        await writeFile(artifactPath, JSON.stringify(precheck, null, 2), "utf8");
+    }
+    catch (err) {
+        console.error(`Failed to persist context-integrity-precheck: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return precheck;
+}
+//# sourceMappingURL=truth-spine.js.map

package/dist/vendor/core/types.d.ts

@@ -0,0 +1,115 @@
+import type { FailureClass, InterventionType, LoopArtifact, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopRecord, LoopTask } from "../contracts/index.js";
+export type AdapterExecutionStatus = "completed" | "failed" | "stalled";
+export interface DistillContextOptions {
+    maxRecentAttempts?: number;
+}
+export interface DistilledAttempt {
+    attemptId: string;
+    index: number;
+    summary: string;
+    failureClass?: FailureClass;
+    intervention?: InterventionType;
+}
+export interface DistilledContext {
+    taskTitle: string;
+    objective: string;
+    repoRoot?: string;
+    verificationPlan: string[];
+    recentAttempts: DistilledAttempt[];
+    constraints: {
+        remainingBudgetUsd: number;
+        remainingIterations: number;
+        remainingTokens: number;
+    };
+    focus: string;
+}
+export interface CostGovernorInput {
+    budget: LoopBudget;
+    cost: LoopCost;
+    attemptsUsed: number;
+    projectedUsage?: Partial<Pick<LoopCost, "actualUsd" | "tokensIn" | "tokensOut">>;
+}
+export interface CostGovernorState {
+    pressure: "healthy" | "soft_limit" | "hard_limit";
+    shouldStop: boolean;
+    remainingBudgetUsd: number;
+    remainingIterations: number;
+    remainingTokens: number;
+    recommendedIntervention?: InterventionType;
+}
+export interface MartinAdapterRequest {
+    loopId: string;
+    workspaceId: string;
+    projectId: string;
+    teamId?: string;
+    attemptIndex: number;
+    task: LoopTask;
+    context: DistilledContext;
+    budget: LoopBudget;
+    costState: CostGovernorState;
+}
+export interface MartinAdapterUsage {
+    actualUsd: number;
+    avoidedUsd?: number;
+    tokensIn: number;
+    tokensOut: number;
+}
+export interface MartinAdapterVerification {
+    passed: boolean;
+    summary: string;
+}
+export interface MartinAdapterFailure {
+    message: string;
+    classHint?: FailureClass;
+}
+export interface MartinAdapterResult {
+    status: AdapterExecutionStatus;
+    summary: string;
+    usage: MartinAdapterUsage;
+    verification: MartinAdapterVerification;
+    failure?: MartinAdapterFailure;
+    artifacts?: LoopArtifact[];
+}
+export interface MartinAdapter {
+    adapterId: string;
+    kind: string;
+    label: string;
+    metadata: Record<string, string>;
+    execute(request: MartinAdapterRequest): Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export interface FailureClassificationInput {
+    attempts: LoopAttempt[];
+    result: MartinAdapterResult;
+}
+export interface FailureAssessment {
+    failureClass: FailureClass;
+    rationale: string;
+    retryable: boolean;
+    recommendedIntervention: InterventionType;
+}
+export interface ExitIntelligenceInput {
+    loop: Pick<LoopRecord, "budget" | "cost" | "attempts">;
+    lastResult?: MartinAdapterResult;
+    lastFailure?: FailureAssessment;
+    costState: CostGovernorState;
+}
+export interface ExitDecision {
+    shouldExit: boolean;
+    lifecycleState: LoopLifecycleState;
+    reason: string;
+}
+export interface RunMartinOptions {
+    workspaceId: string;
+    projectId: string;
+    teamId?: string;
+    task: LoopTask;
+    budget?: Partial<LoopBudget>;
+    adapter: MartinAdapter;
+    now?: () => string;
+    idFactory?: (prefix: string) => string;
+}
+export interface RunMartinResult {
+    loop: LoopRecord;
+    decision: ExitDecision;
+    finalContext: DistilledContext;
+}

package/dist/vendor/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vendor/core/verification/tiered-verify.d.ts

@@ -0,0 +1,17 @@
+export interface RiskTierVerificationInput {
+    scenarioId: string;
+    riskTier: "low" | "medium" | "high" | "critical";
+    blastRadiusScore: number;
+    claimSurfaceTouched: boolean;
+    privilegedAction: boolean;
+    securitySensitive: boolean;
+}
+export interface RiskTierVerificationPlan {
+    scenarioId: string;
+    tier: "standard" | "independent" | "consensus";
+    requiredVerifiers: string[];
+    mustPassAll: boolean;
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function buildRiskTierVerificationPlan(input: RiskTierVerificationInput): RiskTierVerificationPlan;

package/dist/vendor/core/verification/tiered-verify.js

@@ -0,0 +1,29 @@
+export function buildRiskTierVerificationPlan(input) {
+    const tier = input.riskTier === "critical" || input.privilegedAction || (input.claimSurfaceTouched && input.riskTier !== "low")
+        ? "consensus"
+        : input.riskTier === "high" || input.securitySensitive || input.claimSurfaceTouched
+            ? "independent"
+            : "standard";
+    const requiredVerifiers = ["targeted_verifier"];
+    if (tier !== "standard") {
+        requiredVerifiers.push("independent_reviewer");
+    }
+    if (input.securitySensitive) {
+        requiredVerifiers.push("security_review");
+    }
+    if (input.claimSurfaceTouched) {
+        requiredVerifiers.push("claim_boundary_audit");
+    }
+    if (input.privilegedAction) {
+        requiredVerifiers.push("human_owner");
+    }
+    return {
+        scenarioId: input.scenarioId,
+        tier,
+        requiredVerifiers: [...new Set(requiredVerifiers)],
+        mustPassAll: tier !== "standard",
+        allowedClaimWording: "risk-tiered cross-verification adds independent review only where blast radius, privileges, or claim boundaries justify it.",
+        nonClaims: ["universal multi-model consensus", "consensus on every low-risk run"]
+    };
+}
+//# sourceMappingURL=tiered-verify.js.map

package/dist/vendor/core/verifier-pyramid.d.ts

@@ -0,0 +1,32 @@
+import { type PatchDecisionReasonCode } from "../contracts/index.js";
+export interface StreamScanResult {
+    isTrap: boolean;
+    reasonCode?: PatchDecisionReasonCode;
+    detail?: string;
+    severity: "fatal" | "warning" | "info";
+    corroborated: boolean;
+}
+/**
+ * Trap 9: Severity-Tiered, Corroboration-Aware Stream Scanner
+ *
+ * Mandated by CTO:
+ * - Fatal by default: Triggers trap immediately.
+ * - Warning by default: Logged as evidence but not fatal unless corroborated.
+ * - Corroboration: exitCode !== 0, or verifier failure, or critical denylist matches.
+ */
+export declare function scanStreamsForTraps(stdout: string, stderr: string, options: {
+    exitCode: number;
+    verifierPassed: boolean;
+}): StreamScanResult;
+export interface HallucinatedTestOutputResult {
+    trapId: "T05";
+    detail: string;
+}
+/**
+ * Detects when stdout claims tests passed but the process exit code indicates
+ * failure — a hallucinated or fabricated test result.
+ */
+export declare function detectHallucinatedTestOutput(input: {
+    stdout: string;
+    exitCode: number;
+}): HallucinatedTestOutputResult | null;

package/dist/vendor/core/verifier-pyramid.js

@@ -0,0 +1,111 @@
+const FATAL_PATTERNS = [
+    /\bERROR\b/i,
+    /\bEXCEPTION\b/i,
+    /\bFATAL\b/i,
+    /\bTraceback\b/i,
+    /\bUnhandled\b/i,
+    /\bpanic\b/i,
+    /\bSegmentation fault\b/i,
+    /\bAssertion failed\b/i
+];
+const WARNING_PATTERNS = [
+    /\bWarning:\b/i,
+    /\bDeprecated\b/i,
+    /\bNotice\b/i,
+    /generic lint warning/i
+];
+const CRITICAL_DENYLIST = [
+    /module not found/i,
+    /cannot resolve/i,
+    /failed to compile/i,
+    /permission denied/i,
+    /budget exceeded/i,
+    /authentication failed/i
+];
+/**
+ * Trap 9: Severity-Tiered, Corroboration-Aware Stream Scanner
+ *
+ * Mandated by CTO:
+ * - Fatal by default: Triggers trap immediately.
+ * - Warning by default: Logged as evidence but not fatal unless corroborated.
+ * - Corroboration: exitCode !== 0, or verifier failure, or critical denylist matches.
+ */
+export function scanStreamsForTraps(stdout, stderr, options) {
+    const combined = `${stdout}\n${stderr}`;
+    // 1. Check Fatal Patterns (Fast Track)
+    for (const pattern of FATAL_PATTERNS) {
+        if (pattern.test(combined)) {
+            return {
+                isTrap: true,
+                reasonCode: "severity_stream_trap",
+                detail: `Fatal pattern detected in stream: ${pattern.toString()}`,
+                severity: "fatal",
+                corroborated: true
+            };
+        }
+    }
+    // 2. Check Critical Denylist (Escalated regardless of severity)
+    for (const pattern of CRITICAL_DENYLIST) {
+        if (pattern.test(combined)) {
+            return {
+                isTrap: true,
+                reasonCode: "severity_stream_trap",
+                detail: `Critical failure matched in stream: ${pattern.toString()}`,
+                severity: "fatal",
+                corroborated: true
+            };
+        }
+    }
+    // 3. Check Warning Patterns
+    let hasWarning = false;
+    let matchingWarning = "";
+    for (const pattern of WARNING_PATTERNS) {
+        if (pattern.test(combined)) {
+            hasWarning = true;
+            matchingWarning = pattern.toString();
+            break;
+        }
+    }
+    if (hasWarning) {
+        const corroborated = options.exitCode !== 0 || !options.verifierPassed;
+        return {
+            isTrap: corroborated,
+            ...(corroborated ? { reasonCode: "severity_stream_trap" } : {}),
+            detail: corroborated
+                ? `Warning corroborated as failure: ${matchingWarning} (Exit Code: ${options.exitCode})`
+                : `Non-blocking warning detected: ${matchingWarning}`,
+            severity: "warning",
+            corroborated
+        };
+    }
+    return {
+        isTrap: false,
+        severity: "info",
+        corroborated: false
+    };
+}
+const SUCCESS_CLAIM_PATTERNS = [
+    /all tests? passed/i,
+    /\d+\/\d+ passing/i,
+    /\d+ tests? passed/i,
+    /test suite passed/i,
+    /ok \d+ passed/i
+];
+/**
+ * Detects when stdout claims tests passed but the process exit code indicates
+ * failure — a hallucinated or fabricated test result.
+ */
+export function detectHallucinatedTestOutput(input) {
+    if (input.exitCode === 0)
+        return null;
+    for (const pattern of SUCCESS_CLAIM_PATTERNS) {
+        if (pattern.test(input.stdout)) {
+            return {
+                trapId: "T05",
+                detail: `stdout claims success ("${input.stdout.trim().slice(0, 120)}") but exitCode=${input.exitCode}`
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=verifier-pyramid.js.map