@oscharko-dev/keiko 0.1.5 → 0.1.7

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/stages.js

@@ -0,0 +1,242 @@
+// Terminal-report stages (ADR-0009 D3/D4/D11). Each function maps a pipeline outcome —
+// fix-proposed (dry-run), fix-applied, investigation-only, rejected, cancelled, or failed — to the
+// redacted BugInvestigationReport via assembleBugReport. applyPatch (apply mode) is the one IO
+// boundary here and is fail-closed in #6 (applyEnabled gates the write); it receives the SAME
+// tighter PatchLimits as validatePatch (D6 bound 1, defence-in-depth re-validation). finishPipeline
+// selects the branch; emitCompleted stamps the terminal event. All redaction is inside assembleBugReport.
+import { redact } from "@oscharko-dev/keiko-security";
+import { applyPatch, CommandCancelledError, renderDryRun, } from "@oscharko-dev/keiko-tools";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { assembleBugReport } from "./report.js";
+import { runBugVerification } from "./verify-stage.js";
+import { investigationNextActions, nextActionsFor, patchLimitsFrom, } from "./internal.js";
+import { isElevatedReviewPath } from "./guard.js";
+const EMPTY_HYPOTHESIS = {
+    rootCause: undefined,
+    regressionTestStrategy: undefined,
+    uncertainty: undefined,
+    confidence: undefined,
+};
+function elevatedPaths(accepted) {
+    return accepted.validation.files.map((f) => f.path).filter((p) => isElevatedReviewPath(p));
+}
+export function rejectedReport(state, loop, evidence) {
+    return assembleBugReport({
+        status: "rejected",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: [],
+        patchValidates: false,
+        patchApplied: false,
+        verification: undefined,
+        failureFrames: evidence.frames,
+        hypothesis: EMPTY_HYPOTHESIS,
+        proposedDiff: undefined,
+        dryRunPreview: undefined,
+        verificationSkipReason: undefined,
+        nextActions: [
+            `The model did not produce an in-scope fix (${loop.lastRejectionCode ?? "insufficient evidence"})`,
+        ],
+        failureReason: undefined,
+        modelCallCount: loop.modelCallCount,
+        patchRetryCount: loop.patchRetryCount,
+    });
+}
+// Insufficient-input rejection: returned by the intake precondition before any model call.
+export function insufficientInputReport(state) {
+    return assembleBugReport({
+        status: "rejected",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: [],
+        patchValidates: false,
+        patchApplied: false,
+        verification: undefined,
+        failureFrames: [],
+        hypothesis: EMPTY_HYPOTHESIS,
+        proposedDiff: undefined,
+        dryRunPreview: undefined,
+        verificationSkipReason: undefined,
+        nextActions: [
+            "Provide at least one of: a description, failing output, a stack trace, or suspected target files",
+        ],
+        failureReason: undefined,
+        modelCallCount: 0,
+        patchRetryCount: 0,
+    });
+}
+export function investigationOnlyReport(state, loop, hypothesis, evidence) {
+    return assembleBugReport({
+        status: "investigation-only",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: [],
+        patchValidates: false,
+        patchApplied: false,
+        verification: undefined,
+        failureFrames: evidence.frames,
+        hypothesis,
+        proposedDiff: undefined,
+        dryRunPreview: undefined,
+        verificationSkipReason: "verification skipped: no patch produced (investigation-only)",
+        nextActions: investigationNextActions(),
+        failureReason: undefined,
+        modelCallCount: loop.modelCallCount,
+        patchRetryCount: loop.patchRetryCount,
+    });
+}
+export function dryRunReport(state, loop, accepted, evidence) {
+    const files = accepted.validation.files.map((f) => f.path);
+    return assembleBugReport({
+        status: "fix-proposed",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: accepted.validation.files,
+        patchValidates: true,
+        patchApplied: false,
+        verification: undefined,
+        failureFrames: evidence.frames,
+        hypothesis: accepted.hypothesis,
+        proposedDiff: accepted.diff,
+        dryRunPreview: renderDryRun(accepted.validation),
+        verificationSkipReason: "verification skipped: dry-run, no files written",
+        nextActions: nextActionsFor(false, files, elevatedPaths(accepted)),
+        failureReason: undefined,
+        modelCallCount: loop.modelCallCount,
+        patchRetryCount: loop.patchRetryCount,
+    });
+}
+// `applied` is set ONLY on a post-apply abort: the patch is already on disk, so the report (and the
+// #10 ledger record) must reflect that (patchApplied: true) rather than hard-coding false. A
+// pre-apply abort passes applied === undefined and stays patchApplied: false.
+export function cancelledReport(state, loop, accepted, evidence, applied) {
+    const nextActions = applied === undefined
+        ? ["The workflow was cancelled before completion"]
+        : [
+            `The fix was applied to ${applied.changedFiles[0] ?? "disk"} but the workflow was cancelled before verification completed`,
+            "Run `keiko verify` to confirm the suite",
+        ];
+    return assembleBugReport({
+        status: "cancelled",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: accepted?.validation.files ?? [],
+        patchValidates: accepted !== undefined,
+        patchApplied: applied !== undefined,
+        verification: undefined,
+        failureFrames: evidence.frames,
+        hypothesis: accepted?.hypothesis ?? EMPTY_HYPOTHESIS,
+        proposedDiff: accepted?.diff,
+        dryRunPreview: accepted === undefined ? undefined : renderDryRun(accepted.validation),
+        verificationSkipReason: "verification skipped: cancelled",
+        nextActions,
+        failureReason: undefined,
+        modelCallCount: loop.modelCallCount,
+        patchRetryCount: loop.patchRetryCount,
+    });
+}
+export function failedReport(state, error) {
+    const message = redact(error instanceof Error ? error.message : "unexpected workflow failure");
+    const errorCode = error instanceof Error ? error.name : "UNKNOWN";
+    state.emitter.emit({ type: "bug:failed", errorCode, message });
+    return assembleBugReport({
+        status: "failed",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: [],
+        patchValidates: false,
+        patchApplied: false,
+        verification: undefined,
+        failureFrames: [],
+        hypothesis: EMPTY_HYPOTHESIS,
+        proposedDiff: undefined,
+        dryRunPreview: undefined,
+        verificationSkipReason: undefined,
+        nextActions: [`Inspect the error and retry: ${message}`],
+        failureReason: message,
+        modelCallCount: state.progress.modelCallCount,
+        patchRetryCount: state.progress.patchRetryCount,
+    });
+}
+function applyBugPatch(state, workspace, accepted) {
+    const fs = state.deps.fs ?? nodeWorkspaceFs;
+    const applyResult = applyPatch(workspace, accepted.diff, {
+        applyEnabled: true,
+        signal: state.signal,
+        fs,
+        limits: patchLimitsFrom(state.limits),
+        ...(state.deps.writer === undefined ? {} : { writer: state.deps.writer }),
+    });
+    return { fs, applyResult };
+}
+async function applyAndVerify(state, workspace, loop, accepted, evidence) {
+    let applyResult;
+    let fs;
+    try {
+        ({ fs, applyResult } = applyBugPatch(state, workspace, accepted));
+    }
+    catch (error) {
+        if (error instanceof CommandCancelledError) {
+            return cancelledReport(state, loop, accepted, evidence);
+        }
+        throw error;
+    }
+    state.emitter.emit({
+        type: "bug:patch:applied",
+        changedFiles: applyResult.changedFiles.length,
+        created: applyResult.created.length,
+        deleted: applyResult.deleted.length,
+    });
+    if (state.signal.aborted) {
+        // Post-apply abort: the patch is already on disk, so the report must reflect patchApplied: true
+        // (M1) — the #10 ledger record must match the real filesystem state.
+        return cancelledReport(state, loop, accepted, evidence, {
+            changedFiles: applyResult.changedFiles,
+        });
+    }
+    const verification = await runBugVerification(state, workspace, accepted.validation.files, fs);
+    return assembleBugReport({
+        status: "fix-applied",
+        modelId: state.input.modelId,
+        durationMs: state.now() - state.startedAt,
+        patchFiles: accepted.validation.files,
+        patchValidates: true,
+        patchApplied: true,
+        verification: verification.summary,
+        failureFrames: evidence.frames,
+        hypothesis: accepted.hypothesis,
+        proposedDiff: accepted.diff,
+        dryRunPreview: renderDryRun(accepted.validation),
+        verificationSkipReason: verification.skipReason,
+        nextActions: nextActionsFor(true, applyResult.changedFiles, elevatedPaths(accepted)),
+        failureReason: undefined,
+        modelCallCount: loop.modelCallCount,
+        patchRetryCount: loop.patchRetryCount,
+    });
+}
+export function emitCompleted(state, report) {
+    state.emitter.emit({
+        type: "bug:completed",
+        status: report.status,
+        durationMs: report.durationMs,
+    });
+    return report;
+}
+// Selects the terminal branch from the model-loop result: investigation-only (hypothesis, no
+// patch), rejected (nothing usable), cancelled (abort before apply), apply+verify (apply mode), or
+// dry-run (default).
+export async function finishPipeline(state, workspace, loop, evidence) {
+    if (loop.accepted === undefined) {
+        if (loop.investigationOnly !== undefined) {
+            return investigationOnlyReport(state, loop, loop.investigationOnly, evidence);
+        }
+        return rejectedReport(state, loop, evidence);
+    }
+    if (state.signal.aborted) {
+        return cancelledReport(state, loop, loop.accepted, evidence);
+    }
+    if (state.input.apply === true) {
+        return applyAndVerify(state, workspace, loop, loop.accepted, evidence);
+    }
+    return dryRunReport(state, loop, loop.accepted, evidence);
+}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/types.d.ts

@@ -0,0 +1,84 @@
+import type { ModelPort } from "@oscharko-dev/keiko-harness";
+import type { PatchChangeKind, SpawnFn, WorkspaceWriter } from "@oscharko-dev/keiko-tools";
+import type { WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import type { VerificationAuditSummary } from "../../../../src/verification/index.js";
+import type { BugWorkflowEventSink } from "./events.js";
+import type { BugWorkflowLimits, BugWorkflowStatus } from "@oscharko-dev/keiko-contracts";
+export type { BugWorkflowStatus, BugWorkflowLimits } from "@oscharko-dev/keiko-contracts";
+export { DEFAULT_BUG_WORKFLOW_LIMITS } from "@oscharko-dev/keiko-contracts";
+export interface FailureFrame {
+    readonly file: string;
+    readonly line?: number | undefined;
+}
+export interface FailureEvidence {
+    readonly frames: readonly FailureFrame[];
+    readonly messages: readonly string[];
+}
+export interface BugReportInput {
+    readonly description?: string | undefined;
+    readonly failingOutput?: string | undefined;
+    readonly stackTrace?: string | undefined;
+    readonly targetFiles?: readonly string[] | undefined;
+}
+export interface BugInvestigationInput {
+    readonly workspaceRoot: string;
+    readonly report: BugReportInput;
+    readonly apply?: boolean | undefined;
+    readonly modelId: string;
+    readonly limits?: Partial<BugWorkflowLimits> | undefined;
+}
+export interface BugInvestigationDeps {
+    readonly model: ModelPort;
+    readonly fs?: WorkspaceFs | undefined;
+    readonly writer?: WorkspaceWriter | undefined;
+    readonly spawn?: SpawnFn | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly idSource?: (() => string) | undefined;
+    readonly sink?: BugWorkflowEventSink | undefined;
+    readonly processEnv?: NodeJS.ProcessEnv | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+export interface VerifiedFindings {
+    readonly patchValidates: boolean;
+    readonly patchApplied: boolean;
+    readonly verification?: VerificationAuditSummary | undefined;
+    readonly failureFrames: readonly FailureFrame[];
+}
+export interface Hypothesis {
+    readonly rootCause?: string | undefined;
+    readonly regressionTestStrategy?: string | undefined;
+    readonly uncertainty?: string | undefined;
+    readonly confidence?: "low" | "medium" | "high" | undefined;
+}
+export interface ChangedFile {
+    readonly path: string;
+    readonly kind: PatchChangeKind;
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly elevatedReview: boolean;
+}
+export interface BugInvestigationReport {
+    readonly workflowId: "bug-investigation";
+    readonly status: BugWorkflowStatus;
+    readonly modelId: string;
+    readonly durationMs: number;
+    readonly verified: VerifiedFindings;
+    readonly hypothesis: Hypothesis;
+    readonly proposedDiff?: string | undefined;
+    readonly dryRunPreview?: string | undefined;
+    readonly changedFiles: readonly ChangedFile[];
+    readonly regressionCoverage: number;
+    readonly verificationSkipReason?: string | undefined;
+    readonly nextActions: readonly string[];
+    readonly failureReason?: string | undefined;
+    readonly modelCallCount: number;
+    readonly patchRetryCount: number;
+}
+export interface ParsedBugOutput {
+    readonly diff: string;
+    readonly rootCause: string | undefined;
+    readonly regressionTestStrategy: string | undefined;
+    readonly uncertainty: string | undefined;
+    readonly confidence: "low" | "medium" | "high" | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/types.ts"],"names":[],"mappings":"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"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/types.js

@@ -0,0 +1,6 @@
+// All interfaces, type aliases, and frozen constant tables for the bug-investigation workflow
+// (ADR-0009 D2/D3/D4/D7/D13). No runtime logic beyond the frozen tables. `readonly` everywhere;
+// optional props are `| undefined` because exactOptionalPropertyTypes is on. Every report shape is
+// plain JSON-serializable so the #10 audit ledger can persist it. Names are DISTINCT from the
+// unit-test workflow's (ADR-0009 D5) because both barrels are re-exported from the package root.
+export { DEFAULT_BUG_WORKFLOW_LIMITS } from "@oscharko-dev/keiko-contracts";

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/verify-stage.d.ts

@@ -0,0 +1,11 @@
+import type { PatchFileChange } from "@oscharko-dev/keiko-tools";
+import { type WorkspaceFs, type WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import { type VerificationAuditSummary } from "../../../../src/verification/index.js";
+import type { BugRunState } from "./internal.js";
+export declare const SKIP_UNRESOLVED = "verification skipped: framework unknown or no test files resolved";
+export interface BugVerificationOutcome {
+    readonly summary: VerificationAuditSummary | undefined;
+    readonly skipReason: string | undefined;
+}
+export declare function runBugVerification(state: BugRunState, workspace: WorkspaceInfo, changedFiles: readonly PatchFileChange[], fs: WorkspaceFs): Promise<BugVerificationOutcome>;
+//# sourceMappingURL=verify-stage.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/verify-stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-stage.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/verify-stage.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,EAOL,KAAK,wBAAwB,EAG9B,MAAM,uCAAuC,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,eAAe,sEAAsE,CAAC;AA4EnG,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,SAAS,eAAe,EAAE,EACxC,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,sBAAsB,CAAC,CAsBjC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/verify-stage.js

@@ -0,0 +1,91 @@
+// The verification stage (ADR-0009 D11). Runs ONLY after a successful apply: it resolves a
+// verification plan by deriving the just-fixed/added tests from the changed SOURCE files via #7
+// resolveTargetedTests (so it finds the sibling/mirrored test incl. the just-added regression
+// test), falling back to the full `test` script, and records an explicit skip reason when neither
+// resolves or the framework is unknown. Verification reuses the #7 orchestrator unchanged; this
+// stage only wires the plan and projects an output-text-free audit summary. DEFERRED (D11): a
+// pre-patch reproduction baseline — Wave-1 verifies only the post-apply state.
+import { nodeSpawnFn } from "@oscharko-dev/keiko-tools/internal/exec";
+import {} from "@oscharko-dev/keiko-workspace";
+import { buildVerificationPlan, detectScripts, resolveTargetedTests, runVerification, summarizeForAudit, DEFAULT_VERIFICATION_LIMITS, } from "../../../../src/verification/index.js";
+import { isSensitivePath } from "./guard.js";
+export const SKIP_UNRESOLVED = "verification skipped: framework unknown or no test files resolved";
+// The non-test source files the patch changed — passed to resolveTargetedTests so it can find the
+// associated tests (incl. the just-added regression test). We approximate "source" as any changed
+// path that is not itself a test file (basename marks .test/.spec) and not a sensitive path.
+function changedSourceFiles(files) {
+    return files.map((f) => f.path).filter((path) => !isSensitivePath(path) && !isTestFile(path));
+}
+function changedTestFiles(files) {
+    return files.map((f) => f.path).filter((path) => !isSensitivePath(path) && isTestFile(path));
+}
+function isTestFile(path) {
+    const slash = path.lastIndexOf("/");
+    const base = slash === -1 ? path : path.slice(slash + 1);
+    const segments = base.split(".");
+    return segments.includes("test") || segments.includes("spec");
+}
+function buildPlanFallback(workspace, fs) {
+    const catalog = detectScripts(workspace, fs);
+    return buildVerificationPlan(workspace, catalog, { only: ["test"] }, fs);
+}
+function targetedChangedTests(workspace, testFiles) {
+    if (testFiles.length === 0) {
+        return undefined;
+    }
+    if (workspace.testFramework === "vitest") {
+        return {
+            kind: "targeted-test",
+            scriptName: undefined,
+            command: "npx",
+            args: ["vitest", "run", ...testFiles],
+            limits: DEFAULT_VERIFICATION_LIMITS,
+        };
+    }
+    if (workspace.testFramework === "jest") {
+        return {
+            kind: "targeted-test",
+            scriptName: undefined,
+            command: "npx",
+            args: ["jest", ...testFiles],
+            limits: DEFAULT_VERIFICATION_LIMITS,
+        };
+    }
+    return undefined;
+}
+function resolveVerificationPlan(workspace, changedFiles, fs) {
+    const directTests = targetedChangedTests(workspace, changedTestFiles(changedFiles));
+    if (directTests !== undefined) {
+        return { workspaceRoot: workspace.root, steps: [directTests] };
+    }
+    const targeted = resolveTargetedTests(workspace, changedSourceFiles(changedFiles), fs, DEFAULT_VERIFICATION_LIMITS);
+    if (targeted.length > 0) {
+        return { workspaceRoot: workspace.root, steps: targeted };
+    }
+    const fallback = buildPlanFallback(workspace, fs);
+    const runnable = fallback.steps.filter((step) => step.skipReason === undefined);
+    return runnable.length > 0 ? { workspaceRoot: workspace.root, steps: runnable } : undefined;
+}
+export async function runBugVerification(state, workspace, changedFiles, fs) {
+    const plan = resolveVerificationPlan(workspace, changedFiles, fs);
+    if (plan === undefined) {
+        return { summary: undefined, skipReason: SKIP_UNRESOLVED };
+    }
+    const report = await runVerification(plan, {
+        workspace,
+        signal: state.signal,
+        spawn: state.deps.spawn ?? nodeSpawnFn,
+        processEnv: state.deps.processEnv ?? process.env,
+        now: state.now,
+        fs,
+    });
+    const summary = summarizeForAudit(report);
+    state.emitter.emit({
+        type: "bug:verification:result",
+        overallStatus: summary.overallStatus,
+        stepCount: summary.results.length,
+        passedCount: summary.results.filter((r) => r.status === "passed").length,
+        durationMs: summary.durationMs,
+    });
+    return { summary, skipReason: undefined };
+}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/workflow.d.ts

@@ -0,0 +1,3 @@
+import type { BugInvestigationDeps, BugInvestigationInput, BugInvestigationReport } from "./types.js";
+export declare function investigateBug(input: BugInvestigationInput, deps: BugInvestigationDeps): Promise<BugInvestigationReport>;
+//# sourceMappingURL=workflow.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/workflow.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EAEvB,MAAM,YAAY,CAAC;AAiDpB,wBAAsB,cAAc,CAClC,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAYjC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/bug-investigation/workflow.js

@@ -0,0 +1,74 @@
+// The single public entry: investigateBug (ADR-0009 D2/D6/D10/D11). A deterministic linear pipeline
+// (NOT the harness loop): intake precondition -> parse failure evidence -> build context -> [prompt
+// -> model -> parse -> validate -> scope-guard] (bounded retries) -> [investigation-only |
+// rejected | dry-run | apply -> verify] -> report. It composes #3-#7 UNCHANGED and emits redacted
+// progress events. The model loop, verify stage, and report stages live in sibling files to keep
+// each under the LOC limit; this file owns the stage sequencing, the intake precondition (return
+// `rejected` with no model call when no evidence is present), and the single top-level catch
+// boundary that maps a CancelledError to a "cancelled" report and any other IO failure to a
+// redacted "failed" report.
+import { CancelledError } from "@oscharko-dev/keiko-model-gateway";
+import { detectWorkspace } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { buildBugContext } from "./context.js";
+import { computeBugFingerprint } from "./emit.js";
+import { parseFailureEvidence } from "./failure-parse.js";
+import { runBugModelLoop } from "./model-loop.js";
+import { cancelledReport, emitCompleted, failedReport, finishPipeline, insufficientInputReport, } from "./stages.js";
+import { buildBugRunState, EMPTY_BUG_LOOP } from "./internal.js";
+// Intake precondition (D2): at least one evidence field must be present, else there is nothing to
+// investigate and we reject WITHOUT calling the model.
+function hasEvidence(report) {
+    return (nonEmpty(report.description) ||
+        nonEmpty(report.failingOutput) ||
+        nonEmpty(report.stackTrace) ||
+        (report.targetFiles?.some((file) => nonEmpty(file)) ?? false));
+}
+function nonEmpty(value) {
+    return value !== undefined && value.trim().length > 0;
+}
+async function runPipeline(state) {
+    const report = state.input.report;
+    state.emitter.emit({
+        type: "bug:started",
+        workflowId: "bug-investigation",
+        modelId: state.input.modelId,
+        applyEnabled: state.input.apply === true,
+        limits: state.limits,
+    });
+    if (!hasEvidence(report)) {
+        return insufficientInputReport(state);
+    }
+    const fs = state.deps.fs ?? nodeWorkspaceFs;
+    const workspace = detectWorkspace(state.input.workspaceRoot, fs);
+    const evidence = parseFailureEvidence(report);
+    state.emitter.emit({
+        type: "bug:failure:parsed",
+        frameCount: evidence.frames.length,
+        messageCount: evidence.messages.length,
+    });
+    const pack = buildBugContext(workspace, report.description, evidence, state.limits, { fs });
+    state.emitter.emit({
+        type: "bug:context:selected",
+        entryCount: pack.selected.length,
+        usedBytes: pack.usedBytes,
+        budgetBytes: pack.budgetBytes,
+        droppedForBudget: pack.droppedForBudget,
+    });
+    const loop = await runBugModelLoop(state, workspace, report, evidence, pack);
+    return finishPipeline(state, workspace, loop, evidence);
+}
+export async function investigateBug(input, deps) {
+    const state = buildBugRunState(input, deps, computeBugFingerprint(input.report, input.modelId));
+    let report;
+    try {
+        report = await runPipeline(state);
+    }
+    catch (error) {
+        report =
+            error instanceof CancelledError
+                ? cancelledReport(state, EMPTY_BUG_LOOP, undefined, { frames: [], messages: [] })
+                : failedReport(state, error);
+    }
+    return emitCompleted(state, report);
+}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/descriptor.d.ts

@@ -0,0 +1,2 @@
+export type { WorkflowDescriptor, WorkflowInputSpec } from "@oscharko-dev/keiko-contracts";
+//# sourceMappingURL=descriptor.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../../src/descriptor.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/descriptor.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/index.d.ts

@@ -0,0 +1,4 @@
+export type { WorkflowDescriptor, WorkflowInputSpec } from "./descriptor.js";
+export * from "./unit-tests/index.js";
+export * from "./bug-investigation/index.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAUA,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE7E,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/index.js

@@ -0,0 +1,2 @@
+export * from "./unit-tests/index.js";
+export * from "./bug-investigation/index.js";

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/context.d.ts

@@ -0,0 +1,7 @@
+import { type ContextPack, type WorkspaceFs, type WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import type { UnitTestWorkflowInput, WorkflowLimits } from "./types.js";
+export interface TestGenContextDeps {
+    readonly fs?: WorkspaceFs | undefined;
+}
+export declare function buildTestGenContext(workspace: WorkspaceInfo, input: UnitTestWorkflowInput, limits: WorkflowLimits, deps?: TestGenContextDeps): ContextPack;
+//# sourceMappingURL=context.d.ts.map

package/node_modules/@oscharko-dev/keiko-workflows/dist/packages/keiko-workflows/src/unit-tests/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../src/unit-tests/context.ts"],"names":[],"mappings":"AAOA,OAAO,EAKL,KAAK,WAAW,EAOhB,KAAK,WAAW,EAChB,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAkB,qBAAqB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACvC;AAsJD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,qBAAqB,EAC5B,MAAM,EAAE,cAAc,EACtB,IAAI,GAAE,kBAAuB,GAC5B,WAAW,CAcb"}