@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/workflows/bug-investigation/context.d.ts

@@ -1,7 +0,0 @@
-import { type ContextPack, type WorkspaceInfo } from "../../workspace/index.js";
-import { type WorkspaceFs } from "../../workspace/fs.js";
-import type { BugWorkflowLimits, FailureEvidence } from "./types.js";
-export interface BugContextDeps {
-    readonly fs?: WorkspaceFs | undefined;
-}
-export declare function buildBugContext(workspace: WorkspaceInfo, description: string | undefined, evidence: FailureEvidence, limits: BugWorkflowLimits, deps?: BugContextDeps): ContextPack;

package/dist/workflows/bug-investigation/context.js

@@ -1,119 +0,0 @@
-// Context assembly for the investigation call (ADR-0009 D8). Delegates to #5 buildContextPack so
-// the implicated source, nearby tests, manifests/config, and type definitions are selected, ranked,
-// and excerpted under a byte budget — every excerpt already redacted by #5 at the IO boundary. The
-// failure-frame files and developer-provided targetFiles are folded into the lexical `task` hint so
-// the Wave-1 lexical strategy ranks them up (the #5 ContextRequest is reused unchanged; we do not
-// add a new "seed files" field to #5). Pure except for the WorkspaceFs seam threaded into #5.
-import { buildContextPack, DEFAULT_DISCOVERY_OPTIONS, lexicalRetrievalStrategy, SELECTION_REASON_PRIORITY, } from "../../workspace/index.js";
-import { nodeWorkspaceFs } from "../../workspace/fs.js";
-// The lexical task hint: the bug description (or a generic fallback) plus the implicated file paths
-// so the lexical ranker pulls those files into the pack. Deduped; bounded by the frame cap upstream.
-function taskHint(description, evidence) {
-    const base = description !== undefined && description.trim().length > 0
-        ? description.trim()
-        : "investigate failing test and locate the root cause";
-    const files = Array.from(new Set(evidence.frames.map((frame) => frame.file)));
-    return files.length === 0 ? base : `${base} ${files.join(" ")}`;
-}
-function toPosix(path) {
-    return path.split("\\").join("/");
-}
-function basename(path) {
-    const normalized = toPosix(path);
-    const idx = normalized.lastIndexOf("/");
-    return idx === -1 ? normalized : normalized.slice(idx + 1);
-}
-function stem(path) {
-    const base = basename(path);
-    const idx = base.lastIndexOf(".");
-    return idx <= 0 ? base : base.slice(0, idx);
-}
-function testStem(path) {
-    const parts = stem(path).split(".");
-    const marker = parts.findIndex((part) => part === "test" || part === "spec");
-    return marker === -1 ? parts.join(".") : parts.slice(0, marker).join(".");
-}
-function underDir(path, dir) {
-    const normalized = toPosix(dir);
-    return path === normalized || path.startsWith(`${normalized}/`);
-}
-function toWorkspaceRelative(path, workspace) {
-    const normalized = toPosix(path);
-    const root = toPosix(workspace.root);
-    return normalized.startsWith(`${root}/`) ? normalized.slice(root.length + 1) : normalized;
-}
-function buildEvidenceIndex(evidence, workspace) {
-    const paths = new Set(evidence.frames.map((frame) => toWorkspaceRelative(frame.file, workspace)));
-    return { paths, stems: new Set([...paths].map(stem)) };
-}
-function isEvidenceTarget(path, evidence) {
-    return evidence.paths.has(toPosix(path));
-}
-function isTestCandidate(path, workspace, selectionReason) {
-    return (selectionReason === "test" ||
-        workspace.testDirs.some((testDir) => underDir(path, testDir)) ||
-        stem(path)
-            .split(".")
-            .some((part) => part === "test" || part === "spec"));
-}
-function isNearbyEvidenceTest(path, workspace, evidence, selectionReason) {
-    if (!isTestCandidate(path, workspace, selectionReason)) {
-        return false;
-    }
-    const candidateStem = testStem(path);
-    return evidence.stems.has(candidateStem);
-}
-function priorityIndex(reason) {
-    return SELECTION_REASON_PRIORITY.indexOf(reason);
-}
-function evidencePriority(ranked, workspace, evidence) {
-    const path = toPosix(ranked.file.relativePath);
-    if (isEvidenceTarget(path, evidence)) {
-        return 0;
-    }
-    if (isNearbyEvidenceTest(path, workspace, evidence, ranked.selectionReason)) {
-        return 1;
-    }
-    return 2;
-}
-function isSupportContext(ranked) {
-    return ranked.selectionReason === "manifest" || ranked.selectionReason === "config";
-}
-function focusedContext(ranked, workspace, evidence) {
-    const focused = ranked.filter((item) => evidencePriority(item, workspace, evidence) < 2 || isSupportContext(item));
-    return focused.length === 0 ? ranked : focused;
-}
-function createBugRetrievalStrategy(workspace, evidence) {
-    const index = buildEvidenceIndex(evidence, workspace);
-    return {
-        rank: (files, task) => {
-            const ranked = focusedContext(lexicalRetrievalStrategy.rank(files, task), workspace, index);
-            return [...ranked].sort((a, b) => {
-                const byEvidence = evidencePriority(a, workspace, index) - evidencePriority(b, workspace, index);
-                if (byEvidence !== 0) {
-                    return byEvidence;
-                }
-                const byReason = priorityIndex(a.selectionReason) - priorityIndex(b.selectionReason);
-                if (byReason !== 0) {
-                    return byReason;
-                }
-                return a.file.relativePath.localeCompare(b.file.relativePath);
-            });
-        },
-    };
-}
-export function buildBugContext(workspace, description, evidence, limits, deps = {}) {
-    const request = {
-        task: taskHint(description, evidence),
-        budgetBytes: limits.contextBudgetBytes,
-        maxBytesPerFile: limits.maxBytesPerFile,
-        discovery: DEFAULT_DISCOVERY_OPTIONS,
-    };
-    // buildContextPack defaults to the lexical strategy, but ContextPackDeps requires the field; pass
-    // the #5 barrel default explicitly so we hand a complete deps object without reaching past #5.
-    const packDeps = {
-        fs: deps.fs ?? nodeWorkspaceFs,
-        strategy: createBugRetrievalStrategy(workspace, evidence),
-    };
-    return buildContextPack(workspace, request, packDeps);
-}

package/dist/workflows/bug-investigation/descriptor.d.ts

@@ -1,3 +0,0 @@
-import { type BugWorkflowLimits } from "./types.js";
-import type { WorkflowDescriptor } from "../descriptor.js";
-export declare const BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR: WorkflowDescriptor<BugWorkflowLimits>;

package/dist/workflows/bug-investigation/emit.d.ts

@@ -1,12 +0,0 @@
-import type { BugReportInput } from "./types.js";
-import type { BugInvestigationEvent, BugWorkflowEventSink } from "./events.js";
-export declare function computeBugFingerprint(report: BugReportInput, modelId: string): string;
-type EnvelopeFields = "schemaVersion" | "runId" | "fingerprint" | "seq" | "ts";
-export type BugEventBody = {
-    [E in BugInvestigationEvent as E["type"]]: Omit<E, EnvelopeFields>;
-}[BugInvestigationEvent["type"]];
-export interface BugEventEmitter {
-    readonly emit: (body: BugEventBody) => void;
-}
-export declare function createBugEventEmitter(sink: BugWorkflowEventSink, runId: string, fingerprint: string, now: () => number): BugEventEmitter;
-export {};

package/dist/workflows/bug-investigation/emit.js

@@ -1,35 +0,0 @@
-// Event emission helper for the bug-investigation workflow (ADR-0009 D5). Owns the monotonic seq
-// counter and stamps every event with the shared envelope ({ schemaVersion, runId, fingerprint,
-// seq, ts }). The fingerprint is SHA-256(workflowId + canonical(report) + modelId) truncated to 16
-// hex chars — the same shape as the harness fingerprinter — reusing `canonicalise` from the harness
-// barrel so two structurally equal reports fingerprint identically regardless of key order.
-// Sensitive fields are redacted by the CALLER before handing the event here.
-import { createHash } from "node:crypto";
-import { canonicalise } from "../../harness/index.js";
-const FINGERPRINT_HEX_CHARS = 16;
-export function computeBugFingerprint(report, modelId) {
-    const canonical = canonicalise({ workflowId: "bug-investigation", report, modelId });
-    return createHash("sha256")
-        .update(canonical, "utf8")
-        .digest("hex")
-        .slice(0, FINGERPRINT_HEX_CHARS);
-}
-export function createBugEventEmitter(sink, runId, fingerprint, now) {
-    let seq = 0;
-    return {
-        emit: (body) => {
-            seq += 1;
-            // The body is a complete discriminated-union member minus the envelope; re-attaching the
-            // envelope yields a valid BugInvestigationEvent. The cast is over the union, not a widening.
-            const event = {
-                schemaVersion: "1",
-                runId,
-                fingerprint,
-                seq,
-                ts: now(),
-                ...body,
-            };
-            sink.emit(event);
-        },
-    };
-}

package/dist/workflows/bug-investigation/events.d.ts

@@ -1,81 +0,0 @@
-import type { VerificationStatus } from "../../verification/index.js";
-import type { BugWorkflowLimits, BugWorkflowStatus } from "./types.js";
-interface BaseBugEvent {
-    readonly schemaVersion: "1";
-    readonly runId: string;
-    readonly fingerprint: string;
-    readonly seq: number;
-    readonly ts: number;
-}
-export interface BugInvestigationStartedEvent extends BaseBugEvent {
-    readonly type: "bug:started";
-    readonly workflowId: "bug-investigation";
-    readonly modelId: string;
-    readonly applyEnabled: boolean;
-    readonly limits: BugWorkflowLimits;
-}
-export interface FailureParsedEvent extends BaseBugEvent {
-    readonly type: "bug:failure:parsed";
-    readonly frameCount: number;
-    readonly messageCount: number;
-}
-export interface BugContextSelectedEvent extends BaseBugEvent {
-    readonly type: "bug:context:selected";
-    readonly entryCount: number;
-    readonly usedBytes: number;
-    readonly budgetBytes: number;
-    readonly droppedForBudget: number;
-}
-export interface BugModelCallStartedEvent extends BaseBugEvent {
-    readonly type: "bug:model:call:started";
-    readonly attempt: number;
-    readonly contextBytes: number;
-}
-export interface BugModelCallCompletedEvent extends BaseBugEvent {
-    readonly type: "bug:model:call:completed";
-    readonly attempt: number;
-    readonly finishReason: string;
-    readonly promptTokens: number;
-    readonly completionTokens: number;
-    readonly latencyMs: number;
-}
-export interface RootCauseProposedEvent extends BaseBugEvent {
-    readonly type: "bug:rootcause:proposed";
-    readonly hasPatch: boolean;
-    readonly confidence?: "low" | "medium" | "high" | undefined;
-}
-export interface BugPatchValidatedEvent extends BaseBugEvent {
-    readonly type: "bug:patch:validated";
-    readonly ok: boolean;
-    readonly patchBytes: number;
-    readonly filesChanged: number;
-    readonly rejectionCode?: string | undefined;
-}
-export interface BugPatchAppliedEvent extends BaseBugEvent {
-    readonly type: "bug:patch:applied";
-    readonly changedFiles: number;
-    readonly created: number;
-    readonly deleted: number;
-}
-export interface BugVerificationResultEvent extends BaseBugEvent {
-    readonly type: "bug:verification:result";
-    readonly overallStatus: VerificationStatus;
-    readonly stepCount: number;
-    readonly passedCount: number;
-    readonly durationMs: number;
-}
-export interface BugInvestigationCompletedEvent extends BaseBugEvent {
-    readonly type: "bug:completed";
-    readonly status: BugWorkflowStatus;
-    readonly durationMs: number;
-}
-export interface BugInvestigationFailedEvent extends BaseBugEvent {
-    readonly type: "bug:failed";
-    readonly errorCode: string;
-    readonly message: string;
-}
-export type BugInvestigationEvent = BugInvestigationStartedEvent | FailureParsedEvent | BugContextSelectedEvent | BugModelCallStartedEvent | BugModelCallCompletedEvent | RootCauseProposedEvent | BugPatchValidatedEvent | BugPatchAppliedEvent | BugVerificationResultEvent | BugInvestigationCompletedEvent | BugInvestigationFailedEvent;
-export interface BugWorkflowEventSink {
-    readonly emit: (event: BugInvestigationEvent) => void;
-}
-export {};

package/dist/workflows/bug-investigation/events.js

@@ -1,9 +0,0 @@
-// The BugInvestigationEvent discriminated union and its BugWorkflowEventSink (ADR-0009 D5). The
-// envelope reuses the harness BaseEvent field shape ({ schemaVersion, runId, fingerprint, seq,
-// ts }) by STRUCTURAL convention — NOT a TypeScript import — so the #10 audit ledger and #13 UI can
-// narrow these events with the same envelope logic they apply to HarnessEvent. This union is
-// SEPARATE from both HarnessEvent and the unit-test WorkflowEvent. Every member name is DISTINCT
-// from the unit-test workflow's (ADR-0009 D5) so the package-root re-export does not collide. No
-// runtime logic lives here. Members carry COUNTS/FLAGS only — never prose, diff, or raw paths;
-// the one SENSITIVE field (failure message) is redacted before emit.
-export {};

package/dist/workflows/bug-investigation/failure-parse.d.ts

@@ -1,3 +0,0 @@
-import type { BugReportInput, FailureEvidence } from "./types.js";
-export declare const MAX_FRAMES = 25;
-export declare function parseFailureEvidence(report: BugReportInput): FailureEvidence;

package/dist/workflows/bug-investigation/guard.d.ts

@@ -1,2 +0,0 @@
-export declare function isSensitivePath(relPath: string): boolean;
-export declare function isElevatedReviewPath(relPath: string): boolean;

package/dist/workflows/bug-investigation/index.d.ts

@@ -1,7 +0,0 @@
-export { investigateBug } from "./workflow.js";
-export { assembleBugReport, renderBugMarkdownReport, type BugReportParts } from "./report.js";
-export { BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR } from "./descriptor.js";
-export { isSensitivePath, isElevatedReviewPath } from "./guard.js";
-export { parseFailureEvidence, MAX_FRAMES } from "./failure-parse.js";
-export { DEFAULT_BUG_WORKFLOW_LIMITS, type BugInvestigationInput, type BugInvestigationDeps, type BugInvestigationReport, type BugReportInput, type BugWorkflowLimits, type BugWorkflowStatus, type ChangedFile, type FailureEvidence, type FailureFrame, type Hypothesis, type ParsedBugOutput, type VerifiedFindings, } from "./types.js";
-export type { BugContextSelectedEvent, BugInvestigationCompletedEvent, BugInvestigationEvent, BugInvestigationFailedEvent, BugInvestigationStartedEvent, BugModelCallCompletedEvent, BugModelCallStartedEvent, BugPatchAppliedEvent, BugPatchValidatedEvent, BugVerificationResultEvent, BugWorkflowEventSink, FailureParsedEvent, RootCauseProposedEvent, } from "./events.js";

package/dist/workflows/bug-investigation/internal.d.ts

@@ -1,37 +0,0 @@
-import type { PatchLimits, PatchValidation } from "../../tools/index.js";
-import { type BugEventEmitter } from "./emit.js";
-import { type BugInvestigationDeps, type BugInvestigationInput, type BugWorkflowLimits, type Hypothesis } from "./types.js";
-import type { BugWorkflowEventSink } from "./events.js";
-export declare const NO_OP_SINK: BugWorkflowEventSink;
-export interface BugWorkflowProgress {
-    modelCallCount: number;
-    patchRetryCount: number;
-}
-export interface BugRunState {
-    readonly input: BugInvestigationInput;
-    readonly deps: BugInvestigationDeps;
-    readonly limits: BugWorkflowLimits;
-    readonly signal: AbortSignal;
-    readonly now: () => number;
-    readonly emitter: BugEventEmitter;
-    readonly startedAt: number;
-    readonly progress: BugWorkflowProgress;
-}
-export interface AcceptedBugPatch {
-    readonly diff: string;
-    readonly validation: PatchValidation;
-    readonly hypothesis: Hypothesis;
-}
-export interface BugModelLoopResult {
-    readonly accepted: AcceptedBugPatch | undefined;
-    readonly investigationOnly: Hypothesis | undefined;
-    readonly modelCallCount: number;
-    readonly patchRetryCount: number;
-    readonly lastRejectionCode: string | undefined;
-}
-export declare const EMPTY_BUG_LOOP: BugModelLoopResult;
-export declare function resolveBugLimits(input: BugInvestigationInput): BugWorkflowLimits;
-export declare function patchLimitsFrom(limits: BugWorkflowLimits): PatchLimits;
-export declare function buildBugRunState(input: BugInvestigationInput, deps: BugInvestigationDeps, fingerprint: string): BugRunState;
-export declare function nextActionsFor(applied: boolean, files: readonly string[], elevated: readonly string[]): readonly string[];
-export declare function investigationNextActions(): readonly string[];

package/dist/workflows/bug-investigation/model-loop.d.ts

@@ -1,4 +0,0 @@
-import type { ContextPack, WorkspaceInfo } from "../../workspace/index.js";
-import { type BugModelLoopResult, type BugRunState } from "./internal.js";
-import type { BugReportInput, FailureEvidence } from "./types.js";
-export declare function runBugModelLoop(state: BugRunState, workspace: WorkspaceInfo, report: BugReportInput, evidence: FailureEvidence, pack: ContextPack): Promise<BugModelLoopResult>;

package/dist/workflows/bug-investigation/model-loop.js

@@ -1,220 +0,0 @@
-// 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 "../../workspace/fs.js";
-import { validatePatch } from "../../tools/index.js";
-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/dist/workflows/bug-investigation/parse.d.ts

@@ -1,3 +0,0 @@
-import type { ParsedBugOutput } from "./types.js";
-export declare function parseBugModelOutput(content: string): ParsedBugOutput;
-export declare function parseBugModelOutputCandidates(content: string): readonly ParsedBugOutput[];

package/dist/workflows/bug-investigation/prompt.d.ts

@@ -1,4 +0,0 @@
-import type { ChatMessage } from "../../gateway/types.js";
-import type { ContextPack } from "../../workspace/index.js";
-import type { BugReportInput, FailureEvidence } from "./types.js";
-export declare function buildBugPrompt(report: BugReportInput, evidence: FailureEvidence, pack: ContextPack, framework: string, rejectionReason?: string): readonly ChatMessage[];