@oscharko-dev/keiko 0.1.5 → 0.1.7

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

@@ -0,0 +1,220 @@
+// The bounded model/validate/scope-guard retry loop (ADR-0009 D6/D10). Each attempt builds the
+// prompt, calls the injected ModelPort, parses the output, and classifies the result. The KEY
+// behavioural difference from #8: an EMPTY diff with a root-cause hypothesis is a VALID
+// investigation-only outcome (NOT a retry); only a malformed/oversized/out-of-scope NON-empty patch
+// retries. The change budget (D6 bound 1) is enforced by passing a workflow-owned PatchLimits into
+// #6 validatePatch; the sensitive-path guard (D6 bound 2) runs on validation.files[].path. The
+// model call is the one IO boundary here; its failure propagates to the workflow catch boundary.
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { validatePatch } from "@oscharko-dev/keiko-tools";
+import { isTestPath } from "../unit-tests/conventions.js";
+import { isSensitivePath } from "./guard.js";
+import { parseBugModelOutputCandidates } from "./parse.js";
+import { buildBugPrompt } from "./prompt.js";
+import { patchLimitsFrom, } from "./internal.js";
+// The sensitive-path scope guard (D6 bound 2): every changed path must NOT be sensitive. Returns
+// "out-of-scope" when any path is traversal/.github/.husky/lockfile, else undefined. The change
+// budget (bound 1) is enforced by #6 itself via the limits passed to validatePatch.
+function scopeGuard(validation) {
+    const offending = validation.files.some((file) => isSensitivePath(file.path));
+    return offending ? "out-of-scope" : undefined;
+}
+function emitValidation(state, validation, code) {
+    const ok = code === undefined && validation.ok;
+    state.emitter.emit({
+        type: "bug:patch:validated",
+        ok,
+        patchBytes: validation.totalBytes,
+        filesChanged: validation.files.length,
+        ...(ok ? {} : { rejectionCode: code ?? validation.reasons[0]?.code }),
+    });
+}
+function hypothesisOf(parsed) {
+    return {
+        rootCause: parsed.rootCause,
+        regressionTestStrategy: parsed.regressionTestStrategy,
+        uncertainty: parsed.uncertainty,
+        confidence: parsed.confidence,
+    };
+}
+// True when the parsed output carries at least one prose section (any hypothesis content).
+function hasProse(parsed) {
+    return (parsed.rootCause !== undefined ||
+        parsed.regressionTestStrategy !== undefined ||
+        parsed.uncertainty !== undefined ||
+        parsed.confidence !== undefined);
+}
+async function callModel(state, messages, attempt, contextBytes) {
+    state.progress.modelCallCount = Math.max(state.progress.modelCallCount, attempt);
+    state.emitter.emit({ type: "bug:model:call:started", attempt, contextBytes });
+    const response = await state.deps.model.call({ modelId: state.input.modelId, messages }, state.signal);
+    state.emitter.emit({
+        type: "bug:model:call:completed",
+        attempt,
+        finishReason: response.finishReason,
+        promptTokens: response.usage.promptTokens,
+        completionTokens: response.usage.completionTokens,
+        latencyMs: response.usage.latencyMs,
+    });
+    return response.content;
+}
+function classifyEmptyDiff(parsed) {
+    // Empty diff + a hypothesis -> investigation-only (NOT a retry). Empty diff + no prose -> retry.
+    if (hasProse(parsed)) {
+        return {
+            accepted: undefined,
+            investigationOnly: hypothesisOf(parsed),
+            rejectionCode: undefined,
+            rejectionReason: undefined,
+        };
+    }
+    return {
+        accepted: undefined,
+        investigationOnly: undefined,
+        rejectionCode: "empty",
+        rejectionReason: "empty: no diff or root-cause hypothesis was provided",
+    };
+}
+function validationRejectionReason(validation, code) {
+    if (code === undefined) {
+        return undefined;
+    }
+    const message = validation.reasons[0]?.message;
+    if (message !== undefined) {
+        return `${code}: ${message}`;
+    }
+    if (code === "test-only") {
+        return "test-only: a source bug fix must include a minimal non-test source change; tests may be added in the same diff";
+    }
+    const conflict = validation.conflicts[0];
+    if (conflict !== undefined) {
+        return `${code}: ${conflict.path} hunk#${String(conflict.hunkIndex)} ${conflict.reason}`;
+    }
+    return code;
+}
+function sourceBugRequiresSourcePatch(workspace, report, evidence) {
+    const paths = [...(report.targetFiles ?? []), ...evidence.frames.map((frame) => frame.file)];
+    return paths.some((path) => !isTestPath(workspace, path));
+}
+function semanticGuard(workspace, validation, requiresSourcePatch) {
+    if (validation.files.length === 0) {
+        return "malformed";
+    }
+    const scopeCode = scopeGuard(validation);
+    if (scopeCode !== undefined) {
+        return scopeCode;
+    }
+    return requiresSourcePatch && validation.files.every((file) => isTestPath(workspace, file.path))
+        ? "test-only"
+        : undefined;
+}
+function emptyParsedOutput() {
+    return {
+        diff: "",
+        rootCause: undefined,
+        regressionTestStrategy: undefined,
+        uncertainty: undefined,
+        confidence: undefined,
+    };
+}
+function classifyValidated(workspace, parsed, validation, requiresSourcePatch) {
+    const guardCode = validation.ok
+        ? semanticGuard(workspace, validation, requiresSourcePatch)
+        : validation.reasons[0]?.code;
+    if (validation.ok && guardCode === undefined) {
+        const accepted = {
+            diff: parsed.diff,
+            validation,
+            hypothesis: hypothesisOf(parsed),
+        };
+        return {
+            accepted,
+            investigationOnly: undefined,
+            rejectionCode: undefined,
+            rejectionReason: undefined,
+        };
+    }
+    const rejectionCode = guardCode ?? "malformed";
+    return {
+        accepted: undefined,
+        investigationOnly: undefined,
+        rejectionCode,
+        rejectionReason: validationRejectionReason(validation, rejectionCode),
+    };
+}
+function validateCandidate(state, workspace, parsed, requiresSourcePatch) {
+    const validation = validatePatch(workspace, parsed.diff, {
+        fs: state.deps.fs ?? nodeWorkspaceFs,
+        limits: patchLimitsFrom(state.limits),
+    });
+    const result = classifyValidated(workspace, { ...parsed, diff: validation.normalizedDiff ?? parsed.diff }, validation, requiresSourcePatch);
+    return { result, validation };
+}
+function classifyPatchCandidates(state, workspace, report, evidence, candidates) {
+    const patchCandidates = candidates.filter((candidate) => candidate.diff.length > 0);
+    if (patchCandidates.length === 0) {
+        return classifyEmptyDiff(candidates[0] ?? emptyParsedOutput());
+    }
+    const requiresSourcePatch = sourceBugRequiresSourcePatch(workspace, report, evidence);
+    let last;
+    for (const parsed of patchCandidates) {
+        const next = validateCandidate(state, workspace, parsed, requiresSourcePatch);
+        if (next.result.accepted !== undefined) {
+            emitValidation(state, next.validation, next.result.rejectionCode);
+            return next.result;
+        }
+        last = next;
+    }
+    if (last === undefined) {
+        return classifyEmptyDiff(emptyParsedOutput());
+    }
+    emitValidation(state, last.validation, last.result.rejectionCode);
+    return last.result;
+}
+async function attemptOnce(state, workspace, report, evidence, pack, attempt, rejectionReason) {
+    const messages = buildBugPrompt(report, evidence, pack, workspace.testFramework, rejectionReason);
+    const content = await callModel(state, messages, attempt, pack.usedBytes);
+    const candidates = parseBugModelOutputCandidates(content);
+    state.emitter.emit({
+        type: "bug:rootcause:proposed",
+        hasPatch: candidates.some((candidate) => candidate.diff.length > 0),
+        ...(candidates[0]?.confidence === undefined ? {} : { confidence: candidates[0].confidence }),
+    });
+    return classifyPatchCandidates(state, workspace, report, evidence, candidates);
+}
+// True when the attempt produced a terminal outcome (accepted patch or investigation-only); a
+// retryable rejection is the only non-terminal case.
+function isTerminal(result) {
+    return result.accepted !== undefined || result.investigationOnly !== undefined;
+}
+export async function runBugModelLoop(state, workspace, report, evidence, pack) {
+    let modelCallCount = 0;
+    let patchRetryCount = 0;
+    let rejectionReason;
+    let lastRejectionCode;
+    while (modelCallCount < state.limits.maxModelCalls &&
+        patchRetryCount <= state.limits.maxRetries) {
+        modelCallCount += 1;
+        const r = await attemptOnce(state, workspace, report, evidence, pack, modelCallCount, rejectionReason);
+        if (isTerminal(r)) {
+            return {
+                accepted: r.accepted,
+                investigationOnly: r.investigationOnly,
+                modelCallCount,
+                patchRetryCount,
+                lastRejectionCode: undefined,
+            };
+        }
+        patchRetryCount += 1;
+        state.progress.patchRetryCount = patchRetryCount;
+        lastRejectionCode = r.rejectionCode;
+        rejectionReason = r.rejectionReason ?? r.rejectionCode;
+    }
+    return {
+        accepted: undefined,
+        investigationOnly: undefined,
+        modelCallCount,
+        patchRetryCount,
+        lastRejectionCode,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { ParsedBugOutput } from "./types.js";
+export declare function parseBugModelOutput(content: string): ParsedBugOutput;
+export declare function parseBugModelOutputCandidates(content: string): readonly ParsedBugOutput[];
+//# sourceMappingURL=parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/parse.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA+HlD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAUpE;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE,CAYzF"}

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

@@ -0,0 +1,5 @@
+import type { ChatMessage } from "@oscharko-dev/keiko-model-gateway";
+import type { ContextPack } from "@oscharko-dev/keiko-workspace";
+import type { BugReportInput, FailureEvidence } from "./types.js";
+export declare function buildBugPrompt(report: BugReportInput, evidence: FailureEvidence, pack: ContextPack, framework: string, rejectionReason?: string): readonly ChatMessage[];
+//# sourceMappingURL=prompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/prompt.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkHlE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,SAAS,WAAW,EAAE,CAKxB"}

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

@@ -0,0 +1,107 @@
+// Prompt construction (ADR-0009 D9). Builds the system + user ChatMessage array for the single
+// investigation call. PURE: no IO, no clock, no randomness — the same inputs always yield the same
+// messages. The system message specifies the model-output contract (an OPTIONAL fenced ```diff
+// block plus labeled prose sections) that parse.ts consumes, and explicitly tells the model to OMIT
+// the diff when evidence is insufficient (the investigation-only outcome, D10). Context excerpts and
+// failure messages handed in may originate from CLI/UI input, so every free-text report field is
+// redacted and byte-capped before it enters the model prompt.
+import { TextDecoder } from "node:util";
+import { redact } from "@oscharko-dev/keiko-security";
+const MAX_PROMPT_TEXT_BYTES = 16_384;
+const REDACTION_LOOKAHEAD_BYTES = 512;
+const OUTPUT_CONTRACT = "Respond with an OPTIONAL minimal fix as a unified diff inside a single fenced code block opened " +
+    "with ```diff and closed with ```. Touch only what is necessary; you MAY add a regression test " +
+    "in the same diff. For a source-file bug, the diff MUST include at least one non-test source " +
+    "change; a regression test alone is NOT a fix and will be rejected. After the block, add these prose sections: `## Root cause`, " +
+    "`## Regression test`, `## Uncertainty`, `## Confidence` (one of low/medium/high). If the " +
+    "evidence is INSUFFICIENT to propose a safe fix, OMIT the diff entirely and explain in " +
+    "`## Uncertainty` what additional information is needed — do NOT invent a fix. When you include " +
+    "a diff, the first non-empty line inside the fence MUST be `--- a/<path>` or `--- /dev/null`, " +
+    "followed by `+++ b/<path>` and at least one `@@` hunk. Do not output `*** Begin Patch`, file " +
+    "trees, prose, or escaped newline markers like `\\n+`/`\\n-` inside the diff fence; every diff " +
+    "line must be separated by a real newline. If you include a diff, it must be the FIRST fenced " +
+    "code block in the response. Do not include code examples, TypeScript snippets, or alternative " +
+    "patches in any other fence; output exactly one diff fence followed by the required prose sections.";
+const SCOPE_RULE = "The fix must be minimal and must NOT modify CI configuration (.github/), git hooks (.husky/), " +
+    "lockfiles, or unrelated files.";
+function systemContent(framework) {
+    return [
+        "You are a senior engineer performing root-cause analysis on a reported bug.",
+        `Test framework: ${framework}.`,
+        "Ground your hypothesis in the provided evidence; distinguish what the evidence shows from what you infer.",
+        SCOPE_RULE,
+        OUTPUT_CONTRACT,
+    ].join("\n");
+}
+function descriptionBlock(description) {
+    const safe = safePromptText(description);
+    return safe !== undefined
+        ? `Bug description:\n${safe}`
+        : "No free-text description was provided.";
+}
+function clampToBytes(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
+        return { text, truncated: false };
+    }
+    const buffer = Buffer.from(text, "utf8").subarray(0, maxBytes);
+    const decoded = new TextDecoder("utf-8", { fatal: false }).decode(buffer).replace(/�+$/u, "");
+    return { text: `${decoded}\n[TRUNCATED]`, truncated: true };
+}
+function safePromptText(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    const bounded = clampToBytes(trimmed, MAX_PROMPT_TEXT_BYTES + REDACTION_LOOKAHEAD_BYTES).text;
+    return clampToBytes(redact(bounded), MAX_PROMPT_TEXT_BYTES).text;
+}
+function evidenceBlock(report, evidence) {
+    const parts = [];
+    const failingOutput = safePromptText(report.failingOutput);
+    if (failingOutput !== undefined) {
+        parts.push(`Failing output:\n${failingOutput}`);
+    }
+    const stackTrace = safePromptText(report.stackTrace);
+    if (stackTrace !== undefined) {
+        parts.push(`Stack trace:\n${stackTrace}`);
+    }
+    if (evidence.frames.length > 0) {
+        const frames = evidence.frames
+            .map((frame) => frame.line === undefined ? frame.file : `${frame.file}:${String(frame.line)}`)
+            .join(", ");
+        parts.push(`Implicated locations: ${frames}`);
+    }
+    return parts.join("\n\n");
+}
+function contextBlock(pack) {
+    if (pack.selected.length === 0) {
+        return "";
+    }
+    const entries = pack.selected
+        .map((entry) => `--- ${entry.path} ---\n${entry.excerpt}`)
+        .join("\n\n");
+    return `\n\nRepository context:\n${entries}`;
+}
+function retryBlock(rejectionReason) {
+    const safe = safePromptText(rejectionReason);
+    return safe === undefined
+        ? ""
+        : `\n\nThe previous diff was rejected: ${safe}. Produce a corrected, in-scope ` +
+            "minimal diff, or omit the diff if no safe fix is possible.";
+}
+function userContent(report, evidence, pack, rejectionReason) {
+    const evidenceText = evidenceBlock(report, evidence);
+    const evidenceSection = evidenceText.length === 0 ? "" : `\n\n${evidenceText}`;
+    return `${descriptionBlock(report.description)}${evidenceSection}${contextBlock(pack)}${retryBlock(rejectionReason)}`;
+}
+// rejectionReason is appended on a retry (D10) so the model can correct an invalid/out-of-scope
+// diff; it is undefined on the first attempt.
+export function buildBugPrompt(report, evidence, pack, framework, rejectionReason) {
+    return [
+        { role: "system", content: systemContent(framework) },
+        { role: "user", content: userContent(report, evidence, pack, rejectionReason) },
+    ];
+}

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

@@ -0,0 +1,24 @@
+import type { PatchFileChange } from "@oscharko-dev/keiko-tools";
+import type { VerificationAuditSummary } from "../../../../src/verification/index.js";
+import type { BugInvestigationReport, BugWorkflowStatus, FailureFrame, Hypothesis } from "./types.js";
+export interface BugReportParts {
+    readonly status: BugWorkflowStatus;
+    readonly modelId: string;
+    readonly durationMs: number;
+    readonly patchFiles: readonly PatchFileChange[];
+    readonly patchValidates: boolean;
+    readonly patchApplied: boolean;
+    readonly verification: VerificationAuditSummary | undefined;
+    readonly failureFrames: readonly FailureFrame[];
+    readonly hypothesis: Hypothesis;
+    readonly proposedDiff: string | undefined;
+    readonly dryRunPreview: string | undefined;
+    readonly verificationSkipReason: string | undefined;
+    readonly nextActions: readonly string[];
+    readonly failureReason?: string | undefined;
+    readonly modelCallCount: number;
+    readonly patchRetryCount: number;
+}
+export declare function assembleBugReport(parts: BugReportParts): BugInvestigationReport;
+export declare function renderBugMarkdownReport(report: BugInvestigationReport): string;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/report.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAEtF,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EAEjB,YAAY,EACZ,UAAU,EACX,MAAM,YAAY,CAAC;AAuDpB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,sBAAsB,CAuB/E;AAmED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAe9E"}

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

@@ -0,0 +1,151 @@
+// Report assembly and Markdown rendering (ADR-0009 D3). assembleBugReport composes the
+// JSON-serializable BugInvestigationReport from pipeline stage outputs, enforcing the STRUCTURAL
+// verified/hypothesis split: `verified` carries only facts the workflow established (patch validated,
+// patch applied, verification summary, parsed failure frames) and `hypothesis` carries the redacted,
+// explicitly-UNVERIFIED model output. ALL prose, the diff, the dry-run preview, frame paths, changed
+// paths, and nextActions are redacted via redact() here — defence in depth on top of upstream
+// redaction. renderBugMarkdownReport produces the CLI text path. Pure: no IO, no clock; the caller
+// injects durationMs and counters.
+import { redact } from "@oscharko-dev/keiko-security";
+import { isElevatedReviewPath } from "./guard.js";
+const TEST_CASE_PREFIXES = ["test(", "it(", "describe("];
+// Best-effort count of added regression-test cases: added (`+`) lines whose trimmed text begins
+// with a known test-case opener. Not authoritative — informational only.
+function estimateRegressionCount(files) {
+    let count = 0;
+    for (const file of files) {
+        for (const hunk of file.hunks) {
+            for (const line of hunk.lines) {
+                if (!line.startsWith("+")) {
+                    continue;
+                }
+                const trimmed = line.slice(1).trimStart();
+                if (TEST_CASE_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+                    count += 1;
+                }
+            }
+        }
+    }
+    return count;
+}
+function toChangedFiles(files) {
+    return files.map((file) => ({
+        path: redact(file.path),
+        kind: file.kind,
+        addedLines: file.addedLines,
+        removedLines: file.removedLines,
+        elevatedReview: isElevatedReviewPath(file.path),
+    }));
+}
+function redactFrames(frames) {
+    return frames.map((frame) => frame.line === undefined
+        ? { file: redact(frame.file), line: undefined }
+        : { file: redact(frame.file), line: frame.line });
+}
+function redactHypothesis(hypothesis) {
+    return {
+        rootCause: redactOptional(hypothesis.rootCause),
+        regressionTestStrategy: redactOptional(hypothesis.regressionTestStrategy),
+        uncertainty: redactOptional(hypothesis.uncertainty),
+        confidence: hypothesis.confidence,
+    };
+}
+function redactOptional(value) {
+    return value === undefined ? undefined : redact(value);
+}
+export function assembleBugReport(parts) {
+    return {
+        workflowId: "bug-investigation",
+        status: parts.status,
+        modelId: parts.modelId,
+        durationMs: parts.durationMs,
+        verified: {
+            patchValidates: parts.patchValidates,
+            patchApplied: parts.patchApplied,
+            verification: parts.verification,
+            failureFrames: redactFrames(parts.failureFrames),
+        },
+        hypothesis: redactHypothesis(parts.hypothesis),
+        proposedDiff: redactOptional(parts.proposedDiff),
+        dryRunPreview: redactOptional(parts.dryRunPreview),
+        changedFiles: toChangedFiles(parts.patchFiles),
+        regressionCoverage: estimateRegressionCount(parts.patchFiles),
+        verificationSkipReason: redactOptional(parts.verificationSkipReason),
+        nextActions: parts.nextActions.map((action) => redact(action)),
+        failureReason: redactOptional(parts.failureReason),
+        modelCallCount: parts.modelCallCount,
+        patchRetryCount: parts.patchRetryCount,
+    };
+}
+// ─── Markdown rendering ──────────────────────────────────────────────────────────
+function sectionIf(heading, body) {
+    return body === undefined ? [] : [`## ${heading}`, body, ""];
+}
+function frameLines(report) {
+    if (report.verified.failureFrames.length === 0) {
+        return [];
+    }
+    const rows = report.verified.failureFrames.map((f) => f.line === undefined ? `- ${f.file}` : `- ${f.file}:${String(f.line)}`);
+    return ["## Failure locations (verified)", ...rows, ""];
+}
+function changedFileLines(report) {
+    if (report.changedFiles.length === 0) {
+        return [];
+    }
+    const rows = report.changedFiles.map((f) => {
+        const flag = f.elevatedReview ? " [elevated review]" : "";
+        return `- ${f.kind} ${f.path} (+${String(f.addedLines)} -${String(f.removedLines)})${flag}`;
+    });
+    return ["## Changed files (verified)", ...rows, ""];
+}
+function verificationLines(report) {
+    if (report.verified.verification !== undefined) {
+        return [
+            "## Verification (verified)",
+            `Status: ${report.verified.verification.overallStatus}`,
+            "",
+        ];
+    }
+    if (report.verificationSkipReason !== undefined) {
+        return ["## Verification (verified)", report.verificationSkipReason, ""];
+    }
+    return [];
+}
+function hypothesisLines(report) {
+    const h = report.hypothesis;
+    // Suppress the section entirely when the model produced no hypothesis (rejected/failed paths), so
+    // the rendered report does not show a bare "UNVERIFIED" header with no content.
+    const hasContent = h.rootCause !== undefined ||
+        h.regressionTestStrategy !== undefined ||
+        h.uncertainty !== undefined ||
+        h.confidence !== undefined;
+    if (!hasContent) {
+        return [];
+    }
+    return [
+        "## Hypothesis (UNVERIFIED — model output)",
+        ...sectionIf("Root cause", h.rootCause),
+        ...sectionIf("Regression test", h.regressionTestStrategy),
+        ...sectionIf("Uncertainty", h.uncertainty),
+        ...(h.confidence === undefined ? [] : [`Confidence: ${h.confidence}`, ""]),
+    ];
+}
+// A human-readable Markdown report for the CLI text path. Every field is already redacted by
+// assembleBugReport, so rendering is plain string composition. Verified facts and the UNVERIFIED
+// model hypothesis are clearly separated (AC #7).
+export function renderBugMarkdownReport(report) {
+    return [
+        `# Bug investigation: ${report.status}`,
+        `Model: ${report.modelId} · ${String(report.durationMs)}ms · ` +
+            `${String(report.modelCallCount)} model call(s) · ${String(report.patchRetryCount)} retry(ies)`,
+        "",
+        ...frameLines(report),
+        ...changedFileLines(report),
+        ...verificationLines(report),
+        ...hypothesisLines(report),
+        ...sectionIf("Failure", report.failureReason),
+        ...(report.nextActions.length > 0
+            ? ["## Next actions", ...report.nextActions.map((a) => `- ${a}`), ""]
+            : []),
+    ].join("\n");
+}

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

@@ -0,0 +1,14 @@
+import type { WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import { type AcceptedBugPatch, type BugModelLoopResult, type BugRunState } from "./internal.js";
+import type { BugInvestigationReport, FailureEvidence, Hypothesis } from "./types.js";
+export declare function rejectedReport(state: BugRunState, loop: BugModelLoopResult, evidence: FailureEvidence): BugInvestigationReport;
+export declare function insufficientInputReport(state: BugRunState): BugInvestigationReport;
+export declare function investigationOnlyReport(state: BugRunState, loop: BugModelLoopResult, hypothesis: Hypothesis, evidence: FailureEvidence): BugInvestigationReport;
+export declare function dryRunReport(state: BugRunState, loop: BugModelLoopResult, accepted: AcceptedBugPatch, evidence: FailureEvidence): BugInvestigationReport;
+export declare function cancelledReport(state: BugRunState, loop: BugModelLoopResult, accepted: AcceptedBugPatch | undefined, evidence: FailureEvidence, applied?: {
+    readonly changedFiles: readonly string[];
+}): BugInvestigationReport;
+export declare function failedReport(state: BugRunState, error: unknown): BugInvestigationReport;
+export declare function emitCompleted(state: BugRunState, report: BugInvestigationReport): BugInvestigationReport;
+export declare function finishPipeline(state: BugRunState, workspace: WorkspaceInfo, loop: BugModelLoopResult, evidence: FailureEvidence): Promise<BugInvestigationReport>;
+//# sourceMappingURL=stages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stages.d.ts","sourceRoot":"","sources":["../../../../../src/bug-investigation/stages.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAGnE,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAatF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,eAAe,GACxB,sBAAsB,CAqBxB;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,sBAAsB,CAqBlF;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,eAAe,GACxB,sBAAsB,CAmBxB;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,eAAe,GACxB,sBAAsB,CAoBxB;AAKD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACrD,sBAAsB,CA0BxB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAsBvF;AAqED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,sBAAsB,GAC7B,sBAAsB,CAOxB;AAKD,wBAAsB,cAAc,CAClC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,aAAa,EACxB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,sBAAsB,CAAC,CAcjC"}