@oscharko-dev/keiko 0.1.0-beta.0

package/dist/harness/types.d.ts

@@ -0,0 +1,270 @@
+export type HarnessStateName = "intake" | "planning" | "context-selection" | "model-call" | "tool-call" | "patch-proposal" | "verification" | "reporting" | "completed" | "cancelled" | "failed" | "limit-exceeded";
+export type TerminalState = "completed" | "cancelled" | "failed" | "limit-exceeded";
+export declare const TERMINAL_STATES: ReadonlySet<HarnessStateName>;
+export interface StateTransition {
+    readonly from: HarnessStateName;
+    readonly to: HarnessStateName;
+    readonly reason: string;
+}
+export interface HarnessLimits {
+    readonly maxIterations: number;
+    readonly maxModelCalls: number;
+    readonly maxToolCalls: number;
+    readonly maxCommandExecutions: number;
+    readonly maxContextBytes: number;
+    readonly maxPatchBytes: number;
+    readonly maxWallTimeMs: number;
+    readonly maxFailureAttempts: number;
+}
+export declare const DEFAULT_LIMITS: HarnessLimits;
+export type TaskType = "generate-unit-tests" | "investigate-bug" | "explain-plan" | "verify";
+export interface GenerateUnitTestsInput {
+    readonly filePath: string;
+    readonly targetFunction?: string | undefined;
+    readonly context?: string | undefined;
+}
+export interface InvestigateBugInput {
+    readonly description: string;
+    readonly filePaths?: readonly string[] | undefined;
+    readonly context?: string | undefined;
+}
+export interface ExplainPlanInput {
+    readonly filePath: string;
+    readonly question?: string | undefined;
+    readonly context?: string | undefined;
+}
+export interface VerifyInput {
+    readonly workspaceRoot: string;
+    readonly targetFiles?: readonly string[] | undefined;
+}
+export type TaskInput = {
+    readonly taskType: "generate-unit-tests";
+    readonly input: GenerateUnitTestsInput;
+} | {
+    readonly taskType: "investigate-bug";
+    readonly input: InvestigateBugInput;
+} | {
+    readonly taskType: "explain-plan";
+    readonly input: ExplainPlanInput;
+} | {
+    readonly taskType: "verify";
+    readonly input: VerifyInput;
+};
+export interface RunCounters {
+    iterations: number;
+    modelCalls: number;
+    toolCalls: number;
+    commandExecutions: number;
+    failureAttempts: number;
+    browserNavigations: number;
+}
+export type RunOutcome = "completed" | "cancelled" | "failed" | "limit-exceeded";
+export interface RunResult {
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly outcome: RunOutcome;
+    readonly taskType: TaskType;
+    readonly report?: string | undefined;
+    readonly patchDiff?: string | undefined;
+    readonly failure?: HarnessFailure | undefined;
+    readonly startedAt: number;
+    readonly finishedAt: number;
+    readonly events: readonly HarnessEvent[];
+}
+export interface RunManifest {
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly harnessVersion: string;
+    readonly taskType: TaskType;
+    readonly taskInput: TaskInput;
+    readonly limits: HarnessLimits;
+    readonly modelId: string;
+    readonly workingDirectory: string;
+    readonly dryRun: boolean;
+    readonly startedAt: string;
+    readonly events: readonly HarnessEvent[];
+}
+export declare const HARNESS_CODES: {
+    readonly LIMIT_ITERATIONS: "HARNESS_LIMIT_ITERATIONS";
+    readonly LIMIT_MODEL_CALLS: "HARNESS_LIMIT_MODEL_CALLS";
+    readonly LIMIT_TOOL_CALLS: "HARNESS_LIMIT_TOOL_CALLS";
+    readonly LIMIT_COMMAND_EXEC: "HARNESS_LIMIT_COMMAND_EXECUTIONS";
+    readonly LIMIT_CONTEXT_SIZE: "HARNESS_LIMIT_CONTEXT_SIZE";
+    readonly LIMIT_PATCH_SIZE: "HARNESS_LIMIT_PATCH_SIZE";
+    readonly LIMIT_WALL_TIME: "HARNESS_LIMIT_WALL_TIME";
+    readonly LIMIT_FAILURE_ATTEMPTS: "HARNESS_LIMIT_FAILURE_ATTEMPTS";
+    readonly MODEL_ERROR: "HARNESS_MODEL_ERROR";
+    readonly TOOL_ERROR: "HARNESS_TOOL_ERROR";
+    readonly INTERNAL: "HARNESS_INTERNAL";
+};
+export type HarnessCode = (typeof HARNESS_CODES)[keyof typeof HARNESS_CODES];
+export interface HarnessFailure {
+    readonly category: HarnessCode;
+    readonly message: string;
+    readonly detail?: string | undefined;
+}
+interface BaseEvent {
+    readonly schemaVersion: "1";
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly seq: number;
+    readonly ts: number;
+}
+export interface RunStartedEvent extends BaseEvent {
+    readonly type: "run:started";
+    readonly taskType: TaskType;
+    readonly modelId: string;
+    readonly limits: HarnessLimits;
+}
+export interface StateTransitionEvent extends BaseEvent {
+    readonly type: "state:transition";
+    readonly from: HarnessStateName;
+    readonly to: HarnessStateName;
+    readonly reason: string;
+}
+export interface ModelCallStartedEvent extends BaseEvent {
+    readonly type: "model:call:started";
+    readonly modelId: string;
+    readonly messageCount: number;
+    readonly contextBytes: number;
+}
+export interface ModelCallCompletedEvent extends BaseEvent {
+    readonly type: "model:call:completed";
+    readonly modelId: string;
+    readonly finishReason: string;
+    readonly toolCallCount: number;
+    readonly usage: {
+        readonly requestId: string;
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+        readonly latencyMs: number;
+    };
+}
+export interface ModelCallFailedEvent extends BaseEvent {
+    readonly type: "model:call:failed";
+    readonly modelId: string;
+    readonly errorCode: string;
+    readonly message: string;
+}
+export interface ToolCallStartedEvent extends BaseEvent {
+    readonly type: "tool:call:started";
+    readonly toolName: string;
+    readonly toolCallId: string;
+}
+export interface ToolCallCompletedEvent extends BaseEvent {
+    readonly type: "tool:call:completed";
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly durationMs: number;
+}
+export interface ToolCallFailedEvent extends BaseEvent {
+    readonly type: "tool:call:failed";
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly errorCode: string;
+    readonly message: string;
+}
+export interface CommandExecutedEvent extends BaseEvent {
+    readonly type: "command:executed";
+    readonly executable: string;
+    readonly argCount: number;
+    readonly exitCode: number | null;
+    readonly timedOut: boolean;
+    readonly durationMs: number;
+}
+export interface SandboxConfiguredEvent extends BaseEvent {
+    readonly type: "sandbox:configured";
+    readonly envAllowlist: readonly string[];
+    readonly network: "inherit" | "none";
+    readonly maxOutputBytes: number;
+    readonly timeoutMs: number;
+    readonly terminationGraceMs: number;
+    readonly cwdRequested: boolean;
+}
+export interface PatchAppliedEvent extends BaseEvent {
+    readonly type: "patch:applied";
+    readonly changedFiles: number;
+    readonly created: number;
+    readonly deleted: number;
+}
+export interface ReasoningTraceEvent extends BaseEvent {
+    readonly type: "reasoning:trace";
+    readonly phase: HarnessStateName;
+    readonly rationale: string;
+    readonly modelResponse?: string | undefined;
+}
+export interface PatchProposedEvent extends BaseEvent {
+    readonly type: "patch:proposed";
+    readonly targetFile: string;
+    readonly patchBytes: number;
+    readonly diff: string;
+}
+export interface VerificationResultEvent extends BaseEvent {
+    readonly type: "verification:result";
+    readonly passed: boolean;
+    readonly detail: string;
+}
+export interface RunCompletedEvent extends BaseEvent {
+    readonly type: "run:completed";
+    readonly report: string;
+    readonly patchDiff?: string | undefined;
+}
+export interface RunCancelledEvent extends BaseEvent {
+    readonly type: "run:cancelled";
+    readonly reason?: string | undefined;
+    readonly atState: HarnessStateName;
+}
+export interface RunFailedEvent extends BaseEvent {
+    readonly type: "run:failed";
+    readonly failure: HarnessFailure;
+    readonly atState: HarnessStateName;
+}
+export type BrowserSessionCloseReason = "explicit" | "process-exit" | "chrome-disconnected" | "idle-timeout";
+export interface BrowserSessionOpenedEvent extends BaseEvent {
+    readonly type: "browser:session-opened";
+    readonly sessionId: string;
+    readonly cdpPort: number;
+    readonly targetId: string;
+}
+export interface BrowserNavigatedEvent extends BaseEvent {
+    readonly type: "browser:navigated";
+    readonly sessionId: string;
+    readonly originOnly: string;
+    readonly httpStatus: number | null;
+}
+export interface BrowserScreenshotCapturedEvent extends BaseEvent {
+    readonly type: "browser:screenshot-captured";
+    readonly sessionId: string;
+    readonly captureSeq: number;
+    readonly persisted: boolean;
+    readonly viewportPx: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly path?: string | undefined;
+}
+export interface BrowserPageContentCapturedEvent extends BaseEvent {
+    readonly type: "browser:page-content-captured";
+    readonly sessionId: string;
+    readonly captureSeq: number;
+    readonly byteLength: number;
+}
+export interface BrowserSessionClosedEvent extends BaseEvent {
+    readonly type: "browser:session-closed";
+    readonly sessionId: string;
+    readonly reason: BrowserSessionCloseReason;
+}
+export interface BrowserTrustWarningEvent extends BaseEvent {
+    readonly type: "browser:trust-warning";
+    readonly sessionId: string;
+    readonly warning: string;
+}
+export interface BrowserErrorEvent extends BaseEvent {
+    readonly type: "browser:error";
+    readonly sessionId: string;
+    readonly code: string;
+    readonly message: string;
+}
+export type BrowserEvent = BrowserSessionOpenedEvent | BrowserNavigatedEvent | BrowserScreenshotCapturedEvent | BrowserPageContentCapturedEvent | BrowserSessionClosedEvent | BrowserTrustWarningEvent | BrowserErrorEvent;
+export type HarnessEvent = RunStartedEvent | StateTransitionEvent | ModelCallStartedEvent | ModelCallCompletedEvent | ModelCallFailedEvent | ToolCallStartedEvent | ToolCallCompletedEvent | ToolCallFailedEvent | CommandExecutedEvent | SandboxConfiguredEvent | PatchAppliedEvent | ReasoningTraceEvent | PatchProposedEvent | VerificationResultEvent | RunCompletedEvent | RunCancelledEvent | RunFailedEvent | BrowserEvent;
+export {};

package/dist/harness/types.js

@@ -0,0 +1,33 @@
+// All harness interfaces, states, events, limits, and task types. No runtime code
+// other than the frozen constant tables (DEFAULT_LIMITS, HARNESS_CODES, TERMINAL_STATES)
+// that the type layer needs to expose as values. Mirrors the ADR-0003 types.ts precedent.
+export const TERMINAL_STATES = new Set([
+    "completed",
+    "cancelled",
+    "failed",
+    "limit-exceeded",
+]);
+export const DEFAULT_LIMITS = {
+    maxIterations: 10,
+    maxModelCalls: 20,
+    maxToolCalls: 30,
+    maxCommandExecutions: 10,
+    maxContextBytes: 512_000,
+    maxPatchBytes: 65_536,
+    maxWallTimeMs: 300_000,
+    maxFailureAttempts: 3,
+};
+// ─── Failure taxonomy ─────────────────────────────────────────────────────────
+export const HARNESS_CODES = {
+    LIMIT_ITERATIONS: "HARNESS_LIMIT_ITERATIONS",
+    LIMIT_MODEL_CALLS: "HARNESS_LIMIT_MODEL_CALLS",
+    LIMIT_TOOL_CALLS: "HARNESS_LIMIT_TOOL_CALLS",
+    LIMIT_COMMAND_EXEC: "HARNESS_LIMIT_COMMAND_EXECUTIONS",
+    LIMIT_CONTEXT_SIZE: "HARNESS_LIMIT_CONTEXT_SIZE",
+    LIMIT_PATCH_SIZE: "HARNESS_LIMIT_PATCH_SIZE",
+    LIMIT_WALL_TIME: "HARNESS_LIMIT_WALL_TIME",
+    LIMIT_FAILURE_ATTEMPTS: "HARNESS_LIMIT_FAILURE_ATTEMPTS",
+    MODEL_ERROR: "HARNESS_MODEL_ERROR",
+    TOOL_ERROR: "HARNESS_TOOL_ERROR",
+    INTERNAL: "HARNESS_INTERNAL",
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { SDK_VERSION, runAgent, type SdkAgentConfig, type SdkEvidenceOptions, } from "./sdk/index.js";
+export * from "./harness/index.js";
+export * from "./gateway/index.js";
+export * from "./workspace/index.js";
+export * from "./verification/index.js";
+export { summarizeForAudit } from "./workspace/index.js";
+export { summarizeForAudit as summarizeVerificationForAudit } from "./verification/index.js";
+export { generateUnitTests, renderMarkdownReport as renderUnitTestReport, UNIT_TEST_WORKFLOW_DESCRIPTOR, DEFAULT_WORKFLOW_LIMITS, detectConventions, isTestPath, type AddedTestFile, type FileNamingStyle, type TestConventions, type UnitTestTarget, type UnitTestWorkflowDeps, type UnitTestWorkflowInput, type UnitTestWorkflowReport, type WorkflowDescriptor, type WorkflowEvent, type WorkflowEventSink, type WorkflowInputSpec, type WorkflowLimits, type WorkflowStatus, } from "./workflows/index.js";
+export { investigateBug, renderBugMarkdownReport as renderBugInvestigationReport, BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR, DEFAULT_BUG_WORKFLOW_LIMITS, isSensitivePath, isElevatedReviewPath, parseFailureEvidence, type BugInvestigationDeps, type BugInvestigationEvent, type BugInvestigationInput, type BugInvestigationReport, type BugReportInput, type BugWorkflowEventSink, type BugWorkflowLimits, type BugWorkflowStatus, type ChangedFile, type FailureEvidence, type FailureFrame, type Hypothesis, type VerifiedFindings, } from "./workflows/index.js";
+export { buildEvidenceManifest, persistEvidence, createAuditRedactor, createNodeEvidenceStore, createInMemoryEvidenceStore, aggregateUsage, resolveCostClass, listEvidence, loadEvidence, applyRetention, buildEvidenceReport, renderEvidenceReport, assertValidRunId, EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, type AuditRedactionConfig, type EvidenceBuildInput, type EvidenceCommandExecution, type EvidenceDeps, type EvidenceListEntry, type EvidenceManifest, type EvidenceModel, type EvidencePatch, type EvidenceReasoningEntry, type EvidenceReport, type EvidenceRunIdentity, type EvidenceStateTransition, type EvidenceStore, type EvidenceToolCall, type EvidenceUsageTotals, type EvidenceVerificationResult, type RetentionPolicy, } from "./audit/index.js";
+export { runEvaluationSuite, createScriptedModelPort, EVAL_SCORECARD_SCHEMA_VERSION, type ScriptedModelPort, type EvalScorecard, type EvaluationFixture, type EvaluationDimension, type EvaluationMode, type DimensionResult, type DimensionOutcome, type ScorecardEntry, type ScorecardSummary, type SurfaceParityResult, type FixtureRunResult, type FixtureOracle, type WorkflowKind, } from "./evaluations/index.js";

package/dist/index.js

@@ -0,0 +1,36 @@
+// Package-root boundary: the public surface is the agent harness, the model gateway, and
+// the SDK version constant. The harness barrel already re-exports the session/run API the
+// SDK surfaces, so we pull SDK_VERSION explicitly and avoid duplicate star re-exports.
+export { SDK_VERSION, runAgent, } from "./sdk/index.js";
+export * from "./harness/index.js";
+export * from "./gateway/index.js";
+export * from "./workspace/index.js";
+export * from "./verification/index.js";
+// Both the workspace and verification barrels expose a `summarizeForAudit`. An explicit re-export
+// takes precedence over the two star exports and resolves the ambiguity at the package root: the
+// canonical root `summarizeForAudit` is the workspace one (established by ADR-0005), and the
+// verification audit projection is additionally surfaced under an unambiguous alias. Inside
+// ./verification/index.js the function keeps its layer-local name `summarizeForAudit` (ADR-0007).
+export { summarizeForAudit } from "./workspace/index.js";
+export { summarizeForAudit as summarizeVerificationForAudit } from "./verification/index.js";
+// Reviewable developer-assist workflows (ADR-0008). Exported explicitly rather than via `export *`
+// because the workflow event family reuses the harness event-type NAMES (ModelCallStartedEvent,
+// ModelCallCompletedEvent) by structural convention — a star re-export would collide with the
+// harness ones already surfaced above. The WorkflowEvent union is surfaced; the two name-colliding
+// member interfaces are reachable via that union.
+export { generateUnitTests, renderMarkdownReport as renderUnitTestReport, UNIT_TEST_WORKFLOW_DESCRIPTOR, DEFAULT_WORKFLOW_LIMITS, detectConventions, isTestPath, } from "./workflows/index.js";
+// Bug-investigation workflow (ADR-0009). Exported explicitly (not via `export *`) for the same
+// reason as the unit-test workflow: the event family reuses harness event-type NAMES by structural
+// convention, so a star re-export would collide with the harness ones surfaced above. The Markdown
+// renderer is aliased to renderBugInvestigationReport (mirroring renderUnitTestReport) so the two
+// workflow renderers do not collide at the package root.
+export { investigateBug, renderBugMarkdownReport as renderBugInvestigationReport, BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR, DEFAULT_BUG_WORKFLOW_LIMITS, isSensitivePath, isElevatedReviewPath, parseFailureEvidence, } from "./workflows/index.js";
+// Audit ledger / evidence manifests (ADR-0010). Exported explicitly (not via `export *`) to keep the
+// public surface auditable, matching the workflow precedent above. None of these names collides with
+// an existing root export; in particular the layer does NOT export a bare `summarizeForAudit` or
+// `redact` (it composes them internally), so the canonical root `summarizeForAudit` is unaffected.
+export { buildEvidenceManifest, persistEvidence, createAuditRedactor, createNodeEvidenceStore, createInMemoryEvidenceStore, aggregateUsage, resolveCostClass, listEvidence, loadEvidence, applyRetention, buildEvidenceReport, renderEvidenceReport, assertValidRunId, EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, } from "./audit/index.js";
+// Wave 1 evaluation harness (ADR-0012 D11). Exported explicitly (not via `export *`) to keep the
+// public surface auditable, matching the workflow/audit precedent above. None of these names
+// collides with an existing root export.
+export { runEvaluationSuite, createScriptedModelPort, EVAL_SCORECARD_SCHEMA_VERSION, } from "./evaluations/index.js";

package/dist/sdk/index.d.ts

@@ -0,0 +1,9 @@
+export declare const SDK_VERSION = "0.1.0-beta.0";
+export { createSession, type AgentConfig, type AgentSession, type HarnessDeps, type RunResult, type TaskInput, type TaskType, } from "../harness/index.js";
+export { runAgent, type SdkAgentConfig, type SdkEvidenceOptions } from "./run-agent.js";
+export { buildWorkspaceSummary, detectWorkspace, summarizeForAudit, type AuditEntry, type AuditSummary, type ContextEntrySummary, type ContextPackSummary, type WorkspaceInfo, type WorkspaceSummary, } from "../workspace/index.js";
+export { buildVerificationPlan, buildVerificationSummary, classifyOutcome, detectScripts, renderMarkdownSummary, resolveTargetedTests, runVerification, summarizeForAudit as summarizeVerificationForAudit, DEFAULT_VERIFICATION_LIMITS, type ResourceLimitDecision, type VerificationAuditSummary, type VerificationDeps, type VerificationKind, type VerificationPlan, type VerificationReport, type VerificationResourceLimits, type VerificationResult, type VerificationStatus, type VerificationStep, type VerificationSummary, } from "../verification/index.js";
+export { generateUnitTests, renderMarkdownReport, UNIT_TEST_WORKFLOW_DESCRIPTOR, DEFAULT_WORKFLOW_LIMITS, detectConventions, isTestPath, type AddedTestFile, type FileNamingStyle, type TestConventions, type UnitTestTarget, type UnitTestWorkflowDeps, type UnitTestWorkflowInput, type UnitTestWorkflowReport, type WorkflowDescriptor, type WorkflowEvent, type WorkflowEventSink, type WorkflowInputSpec, type WorkflowLimits, type WorkflowStatus, } from "../workflows/index.js";
+export { investigateBug, renderBugMarkdownReport as renderBugInvestigationReport, BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR, DEFAULT_BUG_WORKFLOW_LIMITS, isSensitivePath, isElevatedReviewPath, parseFailureEvidence, type BugInvestigationDeps, type BugInvestigationEvent, type BugInvestigationInput, type BugInvestigationReport, type BugReportInput, type BugWorkflowEventSink, type BugWorkflowLimits, type BugWorkflowStatus, type ChangedFile, type FailureEvidence, type FailureFrame, type Hypothesis, type VerifiedFindings, } from "../workflows/index.js";
+export { buildEvidenceManifest, persistEvidence, createAuditRedactor, createNodeEvidenceStore, createInMemoryEvidenceStore, aggregateUsage, resolveCostClass, listEvidence, loadEvidence, applyRetention, buildEvidenceReport, renderEvidenceReport, assertValidRunId, EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, type AuditRedactionConfig, type EvidenceBuildInput, type EvidenceCommandExecution, type EvidenceDeps, type EvidenceListEntry, type EvidenceManifest, type EvidenceModel, type EvidencePatch, type EvidenceReasoningEntry, type EvidenceReport, type EvidenceRunIdentity, type EvidenceStateTransition, type EvidenceStore, type EvidenceToolCall, type EvidenceUsageTotals, type EvidenceVerificationResult, type RetentionPolicy, } from "../audit/index.js";
+export { runEvaluationSuite, createScriptedModelPort, EVAL_SCORECARD_SCHEMA_VERSION, type ScriptedModelPort, type EvalScorecard, type EvaluationFixture, type EvaluationDimension, type EvaluationMode, type DimensionResult, type DimensionOutcome, type ScorecardEntry, type ScorecardSummary, type SurfaceParityResult, type FixtureRunResult, type FixtureOracle, type WorkflowKind, } from "../evaluations/index.js";

package/dist/sdk/index.js

@@ -0,0 +1,37 @@
+// Single-sourced package version; CLI and SDK both read this to avoid drift.
+export const SDK_VERSION = "0.1.0-beta.0";
+// The typed agent surface. AgentConfig, the session factory, the run result, and the
+// session handle all live in the harness module (ADR-0004); the SDK re-exports them so
+// callers import the agent API from one place.
+export { createSession, } from "../harness/index.js";
+export { runAgent } from "./run-agent.js";
+// Safe workspace context surface (ADR-0005). The only file-read path is the
+// boundary-checked one; no export returns raw arbitrary file content.
+export { buildWorkspaceSummary, detectWorkspace, summarizeForAudit, } from "../workspace/index.js";
+// Verification orchestrator surface (ADR-0007). Verification reuses the #6 command boundary
+// unchanged; these are the plan/run/summary entry points and their JSON-serializable shapes
+// (the stable contract the #10 audit ledger persists). The audit projection is exposed under an
+// explicit alias because the workspace surface already owns `summarizeForAudit`.
+export { buildVerificationPlan, buildVerificationSummary, classifyOutcome, detectScripts, renderMarkdownSummary, resolveTargetedTests, runVerification, summarizeForAudit as summarizeVerificationForAudit, DEFAULT_VERIFICATION_LIMITS, } from "../verification/index.js";
+// Reviewable developer-assist workflows (ADR-0008). The unit-test generation workflow is the first
+// programmatic workflow surface: generateUnitTests is the single entry, the descriptor lets a UI
+// (#13) render the workflow without the implementation, and the WorkflowEvent union plus report
+// types are the stable contract the #10 audit ledger persists.
+export { generateUnitTests, renderMarkdownReport, UNIT_TEST_WORKFLOW_DESCRIPTOR, DEFAULT_WORKFLOW_LIMITS, detectConventions, isTestPath, } from "../workflows/index.js";
+// Bug-investigation workflow (ADR-0009). The second programmatic workflow surface: investigateBug
+// is the single entry, BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR lets a UI (#13) render it without the
+// implementation, and the BugInvestigationReport (with its structural verified/hypothesis split)
+// plus the BugInvestigationEvent union are the stable contract the #10 audit ledger persists. The
+// Markdown renderer is aliased to avoid colliding with the unit-test workflow's renderMarkdownReport.
+export { investigateBug, renderBugMarkdownReport as renderBugInvestigationReport, BUG_INVESTIGATION_WORKFLOW_DESCRIPTOR, DEFAULT_BUG_WORKFLOW_LIMITS, isSensitivePath, isElevatedReviewPath, parseFailureEvidence, } from "../workflows/index.js";
+// Audit ledger / evidence manifests (ADR-0010). The first persistent-artifact surface: persistEvidence
+// builds → redacts-by-construction → writes a redacted, versioned EvidenceManifest, and listEvidence /
+// loadEvidence are the #13 UI seam. Exported via an explicit named block (not `export *`) to keep the
+// surface auditable; none of these names collides with an existing layer export (the layer does NOT
+// export a bare `summarizeForAudit` or `redact` — it composes them internally).
+export { buildEvidenceManifest, persistEvidence, createAuditRedactor, createNodeEvidenceStore, createInMemoryEvidenceStore, aggregateUsage, resolveCostClass, listEvidence, loadEvidence, applyRetention, buildEvidenceReport, renderEvidenceReport, assertValidRunId, EVIDENCE_SCHEMA_VERSION, DEFAULT_RETENTION, } from "../audit/index.js";
+// Wave 1 evaluation harness (ADR-0012 D11). The deterministic offline runner, the product-code
+// scripted-model replay port, and the versioned scorecard schema, exported via an explicit named
+// block (no `export *`). ScriptedModelPort is surfaced so external callers can build replay tooling
+// without the full runner. No name collides with an existing SDK export.
+export { runEvaluationSuite, createScriptedModelPort, EVAL_SCORECARD_SCHEMA_VERSION, } from "../evaluations/index.js";

package/dist/sdk/run-agent.d.ts

@@ -0,0 +1,16 @@
+import type { AuditRedactionConfig, BuildOptions, RetentionPolicy } from "../audit/types.js";
+import type { EvidenceStore } from "../audit/store.js";
+import { type AgentConfig, type AgentSession, type HarnessDeps, type TaskInput } from "../harness/index.js";
+import type { EnvSource } from "../gateway/index.js";
+export interface SdkEvidenceOptions {
+    readonly write?: boolean | undefined;
+    readonly store?: EvidenceStore | undefined;
+    readonly env?: EnvSource | undefined;
+    readonly retention?: RetentionPolicy | undefined;
+    readonly redaction?: AuditRedactionConfig | undefined;
+    readonly options?: BuildOptions | undefined;
+}
+export interface SdkAgentConfig extends AgentConfig {
+    readonly evidence?: SdkEvidenceOptions | undefined;
+}
+export declare function runAgent(task: TaskInput, config: SdkAgentConfig, deps: HarnessDeps): AgentSession;

package/dist/sdk/run-agent.js

@@ -0,0 +1,56 @@
+// SDK-level runAgent wrapper. The harness createSession remains the deterministic core; this wrapper
+// adds the #10 SDK contract that completed SDK runs persist a redacted EvidenceManifest by default.
+import { persistEvidence } from "../audit/persist.js";
+import { createSession, DEFAULT_LIMITS, HARNESS_VERSION, } from "../harness/index.js";
+function resolveLimits(config) {
+    return { ...DEFAULT_LIMITS, ...config.limits };
+}
+function resolveDryRun(config) {
+    return config.dryRun ?? true;
+}
+function buildRunManifest(task, config, result) {
+    return {
+        runId: result.runId,
+        fingerprint: result.fingerprint,
+        harnessVersion: HARNESS_VERSION,
+        taskType: task.taskType,
+        taskInput: task,
+        limits: resolveLimits(config),
+        modelId: config.model,
+        workingDirectory: config.workingDirectory,
+        dryRun: resolveDryRun(config),
+        startedAt: new Date(result.startedAt).toISOString(),
+        events: result.events,
+    };
+}
+function evidenceBuildInput(task, config, result, evidence) {
+    return {
+        result,
+        manifest: buildRunManifest(task, config, result),
+        ...(evidence?.redaction === undefined ? {} : { redaction: evidence.redaction }),
+        ...(evidence?.options === undefined ? {} : { options: evidence.options }),
+    };
+}
+function evidenceDeps(evidence) {
+    return {
+        ...(evidence?.store === undefined ? {} : { store: evidence.store }),
+        ...(evidence?.env === undefined ? {} : { env: evidence.env }),
+    };
+}
+function persistRunEvidence(task, config, result) {
+    const evidence = config.evidence;
+    if (evidence?.write === false) {
+        return;
+    }
+    persistEvidence(evidenceBuildInput(task, config, result, evidence), evidenceDeps(evidence), evidence?.retention);
+}
+export function runAgent(task, config, deps) {
+    const session = createSession(task, config, deps);
+    return {
+        ...session,
+        result: session.result.then((result) => {
+            persistRunEvidence(task, config, result);
+            return result;
+        }),
+    };
+}

package/dist/tools/browser/cdp-client.d.ts

@@ -0,0 +1,35 @@
+import { WebSocket } from "ws";
+export declare const PERMITTED_CDP_METHODS: ReadonlySet<string>;
+export interface CdpClientOptions {
+    readonly timeoutMs?: number;
+    readonly socketFactory?: (url: string) => WebSocket;
+}
+export type CdpEventListener = (event: {
+    readonly method: string;
+    readonly params: unknown;
+    readonly sessionId?: string;
+}) => void;
+export type CdpCloseListener = (reason: string) => void;
+export declare class CdpClient {
+    private readonly socket;
+    private readonly timeoutMs;
+    private readonly pending;
+    private readonly listeners;
+    private readonly closeListeners;
+    private nextId;
+    private connectPromise;
+    private closed;
+    private closeReason;
+    constructor(url: string, options?: CdpClientOptions);
+    connect(): Promise<void>;
+    onEvent(listener: CdpEventListener): () => void;
+    onClose(listener: CdpCloseListener): () => void;
+    send<T = unknown>(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<T>;
+    close(): void;
+    isClosed(): boolean;
+    closeCause(): string | undefined;
+    private handleMessage;
+    private dispatchEvent;
+    private resolvePending;
+    private handleSocketClosed;
+}