@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/harness/errors.js

@@ -1,39 +1,7 @@
-// Harness error taxonomy, mirroring the gateway pattern (ADR-0003). Errors carry a
-// stable `code` discriminant; callers switch on `code`, never parse `message`.
-// Messages are redacted at construction so they are always safe to log.
-import { redact } from "../gateway/redaction.js";
-import { HARNESS_CODES } from "./types.js";
-export { HARNESS_CODES };
-export class HarnessError extends Error {
-    constructor(message, secrets = []) {
-        super(redact(message, secrets));
-        this.name = new.target.name;
-    }
-}
-// Raised when a configured safety limit is breached. Carries the precise category so
-// the loop can map it onto a `limit-exceeded` terminal state with a typed failure.
-export class LimitExceededError extends HarnessError {
-    code;
-    constructor(code, message, secrets = []) {
-        super(message, secrets);
-        this.code = code;
-    }
-}
-// Raised for a non-recoverable model-port error after retries are exhausted.
-export class HarnessModelError extends HarnessError {
-    code = HARNESS_CODES.MODEL_ERROR;
-}
-// Raised for a non-recoverable tool-port error.
-export class HarnessToolError extends HarnessError {
-    code = HARNESS_CODES.TOOL_ERROR;
-}
-// Raised for an unexpected harness-internal invariant violation (e.g. an explain-plan
-// task receiving a tool_calls finishReason, which the read-only path forbids).
-export class HarnessInternalError extends HarnessError {
-    code = HARNESS_CODES.INTERNAL;
-}
-// Builds the machine-readable failure record carried on the run result and the
-// `run:failed` event. `detail` is SENSITIVE and must be redacted before persistence.
-export function toFailure(category, message, detail) {
-    return detail === undefined ? { category, message } : { category, message, detail };
-}
+// Re-export shim: the harness error taxonomy lives in @oscharko-dev/keiko-security
+// (issue #159, ADR-0019). This shim is independent of the @oscharko-dev/keiko-harness
+// extraction (issue #164): security has been the canonical source since issue #159,
+// and the direct-from-security form keeps the type graph shallow for downstream
+// consumers. The harness package barrel itself re-exports the same names so callers
+// can choose either entry point.
+export { HARNESS_CODES, HarnessError, LimitExceededError, HarnessModelError, HarnessToolError, HarnessInternalError, toFailure, } from "@oscharko-dev/keiko-security/errors/harness";

package/dist/harness/executor.d.ts

@@ -1,3 +1 @@
-import { type RunContext, type StateStep } from "./context.js";
-export declare function handleModelCall(ctx: RunContext): Promise<StateStep>;
-export declare function handleToolCall(ctx: RunContext): Promise<StateStep>;
+export { handleModelCall, handleToolCall } from "@oscharko-dev/keiko-harness";

package/dist/harness/executor.js

@@ -1,211 +1,5 @@
-// Handlers for the model-call and tool-call states. The harness — not the model — owns
-// control flow: it inspects finishReason and toolCalls and decides the next state. A model
-// response is never executed as an instruction (ADR-0004 D1).
-import { CancelledError, GatewayError } from "../gateway/errors.js";
-import { ToolError } from "../tools/errors.js";
-import { WorkspaceError } from "../workspace/errors.js";
-import { contextBytes } from "./context.js";
-import { HARNESS_CODES, toFailure } from "./errors.js";
-const RUN_COMMAND_TOOL = "run_command";
-function toolFailureCode(error) {
-    if (error instanceof ToolError || error instanceof WorkspaceError) {
-        return error.code;
-    }
-    return "TOOL_ERROR";
-}
-function buildRequest(ctx) {
-    const tools = ctx.plan.allowsTools ? ctx.tools.listTools() : undefined;
-    return tools === undefined
-        ? { modelId: ctx.modelId, messages: ctx.messages }
-        : { modelId: ctx.modelId, messages: ctx.messages, tools };
-}
-function routeAfterModel(ctx, response) {
-    if (response.finishReason === "tool_calls") {
-        if (!ctx.plan.allowsTools) {
-            ctx.failure = toFailure(HARNESS_CODES.INTERNAL, "model requested tool calls on a read-only task type");
-            return { to: "failed", reason: "tool_calls finishReason forbidden for this task type" };
-        }
-        return { to: "tool-call", reason: "model requested tool calls" };
-    }
-    if (ctx.plan.allowsPatch) {
-        return { to: "patch-proposal", reason: "model produced final content; assembling patch" };
-    }
-    return { to: "reporting", reason: "model produced final content; read-only task" };
-}
-function onModelError(ctx, error) {
-    if (ctx.signal.aborted || error instanceof CancelledError) {
-        if (ctx.failure?.category === HARNESS_CODES.LIMIT_WALL_TIME) {
-            return { to: "limit-exceeded", reason: "maxWallTimeMs exceeded during model call" };
-        }
-        return { to: "cancelled", reason: "abort detected during model call" };
-    }
-    const code = error instanceof GatewayError ? error.code : "UNKNOWN";
-    const message = error instanceof Error ? error.message : "model call failed";
-    ctx.emitter.emit({ type: "model:call:failed", modelId: ctx.modelId, errorCode: code, message });
-    const retryable = error instanceof GatewayError && error.retryable;
-    if (!retryable) {
-        ctx.failure = toFailure(HARNESS_CODES.MODEL_ERROR, message);
-        return { to: "failed", reason: "non-retryable model error" };
-    }
-    ctx.counters.failureAttempts += 1;
-    if (ctx.counters.failureAttempts >= ctx.limits.maxFailureAttempts) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_FAILURE_ATTEMPTS, "max failure attempts reached");
-        return { to: "limit-exceeded", reason: "maxFailureAttempts exceeded" };
-    }
-    return { to: "planning", reason: "retryable model error; re-planning" };
-}
-export async function handleModelCall(ctx) {
-    ctx.counters.modelCalls += 1;
-    ctx.emitter.emit({
-        type: "model:call:started",
-        modelId: ctx.modelId,
-        messageCount: ctx.messages.length,
-        contextBytes: contextBytes(ctx.messages),
-    });
-    let response;
-    try {
-        response = await ctx.model.call(buildRequest(ctx), ctx.signal);
-    }
-    catch (error) {
-        return onModelError(ctx, error);
-    }
-    ctx.emitter.emit({
-        type: "model:call:completed",
-        modelId: ctx.modelId,
-        finishReason: response.finishReason,
-        toolCallCount: response.toolCalls.length,
-        usage: {
-            requestId: response.usage.requestId,
-            promptTokens: response.usage.promptTokens,
-            completionTokens: response.usage.completionTokens,
-            latencyMs: response.usage.latencyMs,
-        },
-    });
-    ctx.emitter.emit({
-        type: "reasoning:trace",
-        phase: "model-call",
-        rationale: "evaluated model response and selected next state",
-        modelResponse: response.content,
-    });
-    ctx.messages = [...ctx.messages, assistantMessage(response)];
-    ctx.lastResponse = response;
-    return routeAfterModel(ctx, response);
-}
-function assistantMessage(response) {
-    return response.toolCalls.length === 0
-        ? { role: "assistant", content: response.content }
-        : { role: "assistant", content: response.content, toolCalls: response.toolCalls };
-}
-// S-M1: emits the redacted audit event matching a tool's metadata, in addition to
-// tool:call:completed, so the issue #10 ledger sees THAT a command ran / a patch applied — never
-// the args, stdout, or file paths. No-op when the tool returned no metadata (read-only tools).
-function emitToolMetadata(ctx, metadata, durationMs) {
-    if (metadata === undefined) {
-        return;
-    }
-    if (metadata.kind === "command") {
-        ctx.emitter.emit({
-            type: "sandbox:configured",
-            envAllowlist: metadata.sandbox.envAllowlist,
-            network: metadata.sandbox.network,
-            maxOutputBytes: metadata.sandbox.maxOutputBytes,
-            timeoutMs: metadata.sandbox.timeoutMs,
-            terminationGraceMs: metadata.sandbox.terminationGraceMs,
-            cwdRequested: metadata.sandbox.cwdRequested,
-        });
-        ctx.emitter.emit({
-            type: "command:executed",
-            executable: metadata.executable,
-            argCount: metadata.argCount,
-            exitCode: metadata.exitCode,
-            timedOut: metadata.timedOut,
-            durationMs,
-        });
-        return;
-    }
-    ctx.emitter.emit({
-        type: "patch:applied",
-        changedFiles: metadata.changedFiles,
-        created: metadata.created,
-        deleted: metadata.deleted,
-    });
-}
-function abortStep(ctx, reason) {
-    if (ctx.failure?.category === HARNESS_CODES.LIMIT_WALL_TIME) {
-        return { to: "limit-exceeded", reason: "maxWallTimeMs exceeded during tool call" };
-    }
-    return { to: "cancelled", reason };
-}
-function commandBudgetExceeded(ctx) {
-    ctx.failure = toFailure(HARNESS_CODES.LIMIT_COMMAND_EXEC, "command-execution budget exhausted");
-    return { to: "limit-exceeded", reason: "maxCommandExecutions exceeded" };
-}
-function toolOutputBudgetExceeded(ctx, bytes) {
-    ctx.failure = toFailure(HARNESS_CODES.LIMIT_CONTEXT_SIZE, `context ${String(bytes)} bytes exceeds limit ${String(ctx.limits.maxContextBytes)}`);
-    return { to: "limit-exceeded", reason: "maxContextBytes exceeded after tool output" };
-}
-function isStateStep(value) {
-    return "to" in value;
-}
-async function runOneTool(ctx, call) {
-    ctx.counters.toolCalls += 1;
-    ctx.emitter.emit({ type: "tool:call:started", toolName: call.name, toolCallId: call.id });
-    try {
-        const result = await ctx.tools.execute({
-            toolCallId: call.id,
-            toolName: call.name,
-            arguments: call.arguments,
-            signal: ctx.signal,
-        });
-        if (result.commandExecuted === true) {
-            ctx.counters.commandExecutions += 1;
-        }
-        ctx.emitter.emit({
-            type: "tool:call:completed",
-            toolName: call.name,
-            toolCallId: call.id,
-            durationMs: result.durationMs,
-        });
-        emitToolMetadata(ctx, result.metadata, result.durationMs);
-        return { role: "tool", content: result.output, toolCallId: call.id };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "tool execution failed";
-        ctx.emitter.emit({
-            type: "tool:call:failed",
-            toolName: call.name,
-            toolCallId: call.id,
-            errorCode: toolFailureCode(error),
-            message,
-        });
-        if (ctx.signal.aborted || error instanceof CancelledError) {
-            return abortStep(ctx, "abort detected during tool call");
-        }
-        ctx.failure = toFailure(HARNESS_CODES.TOOL_ERROR, message);
-        return { to: "failed", reason: "tool execution failed" };
-    }
-}
-export async function handleToolCall(ctx) {
-    const calls = ctx.lastResponse?.toolCalls ?? [];
-    const results = [];
-    for (const call of calls) {
-        if (ctx.signal.aborted) {
-            return abortStep(ctx, "abort detected before tool call");
-        }
-        if (call.name === RUN_COMMAND_TOOL &&
-            ctx.counters.commandExecutions >= ctx.limits.maxCommandExecutions) {
-            return commandBudgetExceeded(ctx);
-        }
-        const result = await runOneTool(ctx, call);
-        if (isStateStep(result)) {
-            return result;
-        }
-        const bytes = contextBytes([...ctx.messages, ...results, result]);
-        if (bytes > ctx.limits.maxContextBytes) {
-            return toolOutputBudgetExceeded(ctx, bytes);
-        }
-        results.push(result);
-    }
-    ctx.messages = [...ctx.messages, ...results];
-    return { to: "model-call", reason: "tool results fed back to model" };
-}
+// Re-export shim: harness model + tool-call handlers live in
+// @oscharko-dev/keiko-harness (issue #164, ADR-0019). These are harness internals —
+// kept on the package barrel only so this legacy shim resolves without
+// subpath-importing into the package.
+export { handleModelCall, handleToolCall } from "@oscharko-dev/keiko-harness";

package/dist/harness/fingerprint.d.ts

@@ -1,6 +1 @@
-import type { Fingerprinter, FingerprintInput, IdSource } from "./ports.js";
-export declare function canonicalise(value: unknown): string;
-export declare function configFingerprint(input: FingerprintInput): string;
-export declare const defaultFingerprinter: Fingerprinter;
-export declare const defaultIdSource: IdSource;
-export declare function counterIdSource(): IdSource;
+export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "@oscharko-dev/keiko-harness";

package/dist/harness/fingerprint.js

@@ -1,43 +1,4 @@
-// Deterministic run-ID and configuration-fingerprint sources. Production uses
-// node:crypto (randomUUID, SHA-256); tests inject a counter so IDs are fixed and
-// runs are reproducible for replay (ADR-0004 D7).
-import { createHash, randomUUID } from "node:crypto";
-// Canonical JSON: object keys sorted recursively, array order preserved, undefined
-// values omitted (matching JSON.stringify semantics). Two structurally equal configs
-// thus serialise to byte-identical strings regardless of key insertion order.
-export function canonicalise(value) {
-    if (value === undefined) {
-        return "null";
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => canonicalise(item)).join(",")}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, v]) => v !== undefined)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-        .map(([key, v]) => `${JSON.stringify(key)}:${canonicalise(v)}`);
-    return `{${entries.join(",")}}`;
-}
-export function configFingerprint(input) {
-    const canonical = canonicalise(input);
-    return createHash("sha256").update(canonical, "utf8").digest("hex");
-}
-export const defaultFingerprinter = {
-    compute: configFingerprint,
-};
-export const defaultIdSource = {
-    newRunId: () => randomUUID(),
-};
-// Test/replay helper: deterministic monotonically increasing run IDs.
-export function counterIdSource() {
-    let n = 0;
-    return {
-        newRunId: () => {
-            n += 1;
-            return `run-${String(n)}`;
-        },
-    };
-}
+// Re-export shim: harness fingerprinting + ID sources live in @oscharko-dev/keiko-harness
+// (issue #164, ADR-0019). `canonicalise` itself originates in @oscharko-dev/keiko-security
+// and is re-exported from the harness barrel for one-import-source.
+export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "@oscharko-dev/keiko-harness";

package/dist/harness/index.d.ts

@@ -1,9 +1,8 @@
-export { createSession, HARNESS_VERSION, type AgentConfig, type AgentSession, type HarnessDeps, } from "./session.js";
-export { createSession as runAgent } from "./session.js";
-export { DEFAULT_LIMITS, HARNESS_CODES, TERMINAL_STATES, type ExplainPlanInput, type GenerateUnitTestsInput, type HarnessCode, type HarnessEvent, type HarnessFailure, type HarnessLimits, type HarnessStateName, type InvestigateBugInput, type ModelCallCompletedEvent, type ModelCallFailedEvent, type ModelCallStartedEvent, type PatchProposedEvent, type ReasoningTraceEvent, type RunCancelledEvent, type RunCompletedEvent, type RunCounters, type RunFailedEvent, type RunManifest, type RunOutcome, type RunResult, type RunStartedEvent, type StateTransition, type StateTransitionEvent, type TaskInput, type TaskType, type TerminalState, type ToolCallCompletedEvent, type ToolCallFailedEvent, type ToolCallStartedEvent, type VerificationResultEvent, } from "./types.js";
-export { HarnessError, HarnessInternalError, HarnessModelError, HarnessToolError, LimitExceededError, toFailure, } from "./errors.js";
-export type { EventSink, Fingerprinter, FingerprintInput, IdSource, ModelPort, ToolCallRequest, ToolCallResult, ToolPort, } from "./ports.js";
-export { DryRunToolPort, GatewayModelPort, type ChatModel, type RecordedToolCall, } from "./adapters.js";
-export { CliEventSink, MemoryEventSink, type EventWriter, type ManifestSeed } from "./sinks.js";
-export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "./fingerprint.js";
-export { resolveTaskPlan, type TaskPlan } from "./tasks/policy.js";
+export { createSession, HARNESS_VERSION, runAgent, type AgentConfig, type AgentSession, type HarnessDeps, } from "@oscharko-dev/keiko-harness";
+export { DEFAULT_LIMITS, HARNESS_CODES, TERMINAL_STATES, type ExplainPlanInput, type GenerateUnitTestsInput, type HarnessCode, type HarnessEvent, type HarnessFailure, type HarnessLimits, type HarnessStateName, type InvestigateBugInput, type ModelCallCompletedEvent, type ModelCallFailedEvent, type ModelCallStartedEvent, type PatchProposedEvent, type ReasoningTraceEvent, type RunCancelledEvent, type RunCompletedEvent, type RunCounters, type RunFailedEvent, type RunManifest, type RunOutcome, type RunResult, type RunStartedEvent, type StateTransition, type StateTransitionEvent, type TaskInput, type TaskType, type TerminalState, type ToolCallCompletedEvent, type ToolCallFailedEvent, type ToolCallStartedEvent, type VerificationResultEvent, } from "@oscharko-dev/keiko-harness";
+export { HarnessError, HarnessInternalError, HarnessModelError, HarnessToolError, LimitExceededError, toFailure, } from "@oscharko-dev/keiko-harness";
+export type { EventSink, Fingerprinter, FingerprintInput, IdSource, ModelPort, ToolCallRequest, ToolCallResult, ToolPort, } from "@oscharko-dev/keiko-harness";
+export { DryRunToolPort, GatewayModelPort, type ChatModel, type RecordedToolCall, } from "@oscharko-dev/keiko-harness";
+export { CliEventSink, MemoryEventSink, type EventWriter, type ManifestSeed, } from "@oscharko-dev/keiko-harness";
+export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "@oscharko-dev/keiko-harness";
+export { resolveTaskPlan, type TaskPlan } from "@oscharko-dev/keiko-harness";

package/dist/harness/index.js

@@ -1,13 +1,12 @@
-// Public barrel for the agent harness: the session API, all ports/adapters/sinks, the
-// task types, the event schema, the limit/error taxonomy, and the deterministic ID and
-// fingerprint sources. Downstream issues (#6 tools, #10 audit, #13 UI) depend only on
-// these typed seams (ADR-0004 D2).
-export { createSession, HARNESS_VERSION, } from "./session.js";
-// runAgent is the ergonomic SDK alias of createSession; both start a bounded run.
-export { createSession as runAgent } from "./session.js";
-export { DEFAULT_LIMITS, HARNESS_CODES, TERMINAL_STATES, } from "./types.js";
-export { HarnessError, HarnessInternalError, HarnessModelError, HarnessToolError, LimitExceededError, toFailure, } from "./errors.js";
-export { DryRunToolPort, GatewayModelPort, } from "./adapters.js";
-export { CliEventSink, MemoryEventSink } from "./sinks.js";
-export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "./fingerprint.js";
-export { resolveTaskPlan } from "./tasks/policy.js";
+// Re-export shim: the harness now lives in @oscharko-dev/keiko-harness (issue #164,
+// ADR-0019). All existing import sites (`from "../harness/index.js"`) keep resolving
+// unchanged via this barrel. Symbols enumerated explicitly to match the PRE-MOVE surface
+// of src/harness/index.ts (per the keiko-tools / keiko-workspace / keiko-evidence
+// precedent — never `export *` in a legacy shim).
+export { createSession, HARNESS_VERSION, runAgent, } from "@oscharko-dev/keiko-harness";
+export { DEFAULT_LIMITS, HARNESS_CODES, TERMINAL_STATES, } from "@oscharko-dev/keiko-harness";
+export { HarnessError, HarnessInternalError, HarnessModelError, HarnessToolError, LimitExceededError, toFailure, } from "@oscharko-dev/keiko-harness";
+export { DryRunToolPort, GatewayModelPort, } from "@oscharko-dev/keiko-harness";
+export { CliEventSink, MemoryEventSink, } from "@oscharko-dev/keiko-harness";
+export { canonicalise, configFingerprint, counterIdSource, defaultFingerprinter, defaultIdSource, } from "@oscharko-dev/keiko-harness";
+export { resolveTaskPlan } from "@oscharko-dev/keiko-harness";

package/dist/harness/loop.d.ts

@@ -1,3 +1 @@
-import { type RunContext } from "./context.js";
-import { type RunOutcome } from "./types.js";
-export declare function runLoop(ctx: RunContext): Promise<RunOutcome>;
+export { runLoop } from "@oscharko-dev/keiko-harness";

package/dist/harness/loop.js

@@ -1,159 +1,5 @@
-// The state-machine driver. The harness owns all control flow: it checks abort and limit
-// guards at the top of the loop and before each port call, dispatches the current state to
-// its handler, and emits a state:transition before every change (ADR-0004 D1, D3, D4).
-import { HARNESS_CODES, toFailure } from "./errors.js";
-import { contextBytes } from "./context.js";
-import { handleModelCall, handleToolCall } from "./executor.js";
-import { handlePatchProposal, handleReporting, handleVerification } from "./patcher.js";
-import { handleContextSelection, handlePlanning } from "./planner.js";
-import { TERMINAL_STATES } from "./types.js";
-const MAX_LOOP_STEPS = 10_000; // absolute safety net; bounded states make this unreachable.
-function abortStep(reason) {
-    return { to: "cancelled", reason };
-}
-function checkWallTime(ctx) {
-    if (ctx.clock.now() - ctx.startedAt > ctx.limits.maxWallTimeMs) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_WALL_TIME, "wall-time budget exhausted");
-        return { to: "limit-exceeded", reason: "maxWallTimeMs exceeded" };
-    }
-    return null;
-}
-// Limit checks evaluated when re-entering planning (iterations) plus the wall-time gate for
-// the run as a whole.
-function checkLoopLimits(ctx) {
-    const wallTime = checkWallTime(ctx);
-    if (wallTime !== null) {
-        return wallTime;
-    }
-    if (ctx.counters.iterations >= ctx.limits.maxIterations) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_ITERATIONS, "iteration budget exhausted");
-        return { to: "limit-exceeded", reason: "maxIterations exceeded" };
-    }
-    return null;
-}
-// Context-size and model-call-count checks, evaluated at every model-call entry so the
-// limit bounds calls that follow tool-call (not only the initial context-selection path).
-function checkModelCallLimits(ctx) {
-    if (ctx.counters.modelCalls >= ctx.limits.maxModelCalls) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_MODEL_CALLS, "model-call budget exhausted");
-        return { to: "limit-exceeded", reason: "maxModelCalls exceeded" };
-    }
-    const bytes = contextBytes(ctx.messages);
-    if (bytes > ctx.limits.maxContextBytes) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_CONTEXT_SIZE, `context ${String(bytes)} bytes exceeds limit ${String(ctx.limits.maxContextBytes)}`);
-        return { to: "limit-exceeded", reason: "maxContextBytes exceeded" };
-    }
-    return null;
-}
-// Per-state-entry guards: abort is honoured before any state; call-count limits are
-// enforced immediately before the state that consumes the bounded resource.
-function checkEntryGuards(ctx, state) {
-    const wallTime = checkWallTime(ctx);
-    if (wallTime !== null) {
-        return wallTime;
-    }
-    if (ctx.signal.aborted) {
-        return abortStep("abort detected before state entry");
-    }
-    if (state === "model-call") {
-        return checkModelCallLimits(ctx);
-    }
-    if (state === "tool-call") {
-        return checkToolLimits(ctx);
-    }
-    return null;
-}
-function checkToolLimits(ctx) {
-    const pending = ctx.lastResponse?.toolCalls.length ?? 0;
-    if (ctx.counters.toolCalls + pending > ctx.limits.maxToolCalls) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_TOOL_CALLS, "tool-call budget exhausted");
-        return { to: "limit-exceeded", reason: "maxToolCalls exceeded" };
-    }
-    if (ctx.counters.commandExecutions >= ctx.limits.maxCommandExecutions) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_COMMAND_EXEC, "command-execution budget exhausted");
-        return { to: "limit-exceeded", reason: "maxCommandExecutions exceeded" };
-    }
-    return null;
-}
-async function dispatch(ctx, state) {
-    switch (state) {
-        case "planning":
-            ctx.counters.iterations += 1;
-            return handlePlanning(ctx);
-        case "context-selection":
-            return handleContextSelection(ctx);
-        case "model-call":
-            return handleModelCall(ctx);
-        case "tool-call":
-            return handleToolCall(ctx);
-        case "patch-proposal":
-            return handlePatchProposal(ctx);
-        case "verification":
-            return handleVerification(ctx);
-        case "reporting":
-            return handleReporting(ctx);
-        default:
-            ctx.failure = toFailure(HARNESS_CODES.INTERNAL, `no handler for state ${state}`);
-            return { to: "failed", reason: "internal: unhandled state" };
-    }
-}
-function transition(ctx, from, step) {
-    if (step.to === "cancelled") {
-        ctx.cancelledAtState = from;
-    }
-    ctx.emitter.emit({ type: "state:transition", from, to: step.to, reason: step.reason });
-    return step.to;
-}
-function emitTerminal(ctx, state) {
-    if (state === "completed") {
-        ctx.emitter.emit({
-            type: "run:completed",
-            report: ctx.report ?? "no model output",
-            ...(ctx.patchDiff === undefined ? {} : { patchDiff: ctx.patchDiff }),
-        });
-        return;
-    }
-    if (state === "cancelled") {
-        ctx.emitter.emit({
-            type: "run:cancelled",
-            atState: ctx.cancelledAtState ?? state,
-            ...(ctx.cancelReason === undefined ? {} : { reason: ctx.cancelReason }),
-        });
-        return;
-    }
-    if (state === "failed" || state === "limit-exceeded") {
-        const failure = ctx.failure ?? toFailure(HARNESS_CODES.INTERNAL, "run failed without a failure record");
-        ctx.failure = failure;
-        ctx.emitter.emit({ type: "run:failed", failure, atState: state });
-    }
-}
-// Runs the state machine from `intake` to a terminal state and returns the outcome.
-export async function runLoop(ctx) {
-    let state = transition(ctx, "intake", {
-        to: "planning",
-        reason: "task validated",
-    });
-    for (let step = 0; step < MAX_LOOP_STEPS && !TERMINAL_STATES.has(state); step += 1) {
-        if (ctx.signal.aborted) {
-            state = transition(ctx, state, abortStep("abort detected at top of loop"));
-            break;
-        }
-        const guard = state === "planning" ? checkLoopLimits(ctx) : checkEntryGuards(ctx, state);
-        if (guard !== null) {
-            state = transition(ctx, state, guard);
-            continue;
-        }
-        const dispatched = await dispatch(ctx, state);
-        const postDispatchGuard = checkWallTime(ctx);
-        state = transition(ctx, state, postDispatchGuard ?? dispatched);
-    }
-    if (!TERMINAL_STATES.has(state)) {
-        ctx.failure = toFailure(HARNESS_CODES.INTERNAL, "state-machine safety step limit exceeded");
-        state = transition(ctx, state, {
-            to: "failed",
-            reason: "internal: state-machine step limit exceeded",
-        });
-    }
-    emitTerminal(ctx, state);
-    return state;
-}
+// Re-export shim: the harness state-machine loop lives in
+// @oscharko-dev/keiko-harness (issue #164, ADR-0019). runLoop is a harness internal —
+// kept on the package barrel only so this legacy shim resolves without
+// subpath-importing into the package.
+export { runLoop } from "@oscharko-dev/keiko-harness";

package/dist/harness/patcher.d.ts

@@ -1,4 +1 @@
-import type { RunContext, StateStep } from "./context.js";
-export declare function handlePatchProposal(ctx: RunContext): StateStep;
-export declare function handleVerification(ctx: RunContext): StateStep;
-export declare function handleReporting(ctx: RunContext): StateStep;
+export { handlePatchProposal, handleReporting, handleVerification, } from "@oscharko-dev/keiko-harness";

package/dist/harness/patcher.js

@@ -1,49 +1,5 @@
-// Handlers for the patch-proposal, verification, and reporting states. The harness NEVER
-// applies a patch: the diff is emitted as a patch:proposed event and carried on the run
-// result. Nothing here touches the file system (ADR-0004 D8, dry-run by default).
-import { HARNESS_CODES, toFailure } from "./errors.js";
-const encoder = new TextEncoder();
-function patchByteLength(diff) {
-    return encoder.encode(diff).length;
-}
-export function handlePatchProposal(ctx) {
-    const diff = ctx.lastResponse?.content ?? "";
-    const bytes = patchByteLength(diff);
-    if (bytes > ctx.limits.maxPatchBytes) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_PATCH_SIZE, `patch ${String(bytes)} bytes exceeds limit ${String(ctx.limits.maxPatchBytes)}`);
-        return { to: "limit-exceeded", reason: "maxPatchBytes exceeded" };
-    }
-    ctx.patchDiff = diff;
-    ctx.emitter.emit({
-        type: "patch:proposed",
-        targetFile: ctx.plan.targetFile,
-        patchBytes: bytes,
-        diff,
-    });
-    return { to: "verification", reason: "patch assembled and proposed (not applied)" };
-}
-// Wave-1 verification is a structural check: a proposed patch must be non-empty. Real test/
-// command verification arrives with the tool execution layer (issue #6).
-export function handleVerification(ctx) {
-    const passed = (ctx.patchDiff ?? "").trim().length > 0;
-    ctx.emitter.emit({
-        type: "verification:result",
-        passed,
-        detail: passed ? "non-empty patch produced" : "empty patch",
-    });
-    if (passed) {
-        return { to: "reporting", reason: "verification passed" };
-    }
-    ctx.counters.failureAttempts += 1;
-    if (ctx.counters.failureAttempts >= ctx.limits.maxFailureAttempts) {
-        ctx.failure = toFailure(HARNESS_CODES.LIMIT_FAILURE_ATTEMPTS, "verification kept failing");
-        return { to: "limit-exceeded", reason: "maxFailureAttempts exceeded after verification" };
-    }
-    return { to: "planning", reason: "verification failed; re-planning" };
-}
-// Records the final report on the context. The run:completed event is emitted by the loop
-// once the terminal `completed` state is reached, so it is the last event in the stream.
-export function handleReporting(ctx) {
-    ctx.report = ctx.lastResponse?.content ?? "no model output";
-    return { to: "completed", reason: "report generated" };
-}
+// Re-export shim: harness patch/verification/reporting handlers live in
+// @oscharko-dev/keiko-harness (issue #164, ADR-0019). These are harness internals —
+// kept on the package barrel only so this legacy shim resolves without
+// subpath-importing into the package.
+export { handlePatchProposal, handleReporting, handleVerification, } from "@oscharko-dev/keiko-harness";

package/dist/harness/planner.d.ts

@@ -1,3 +1 @@
-import { type RunContext, type StateStep } from "./context.js";
-export declare function handlePlanning(ctx: RunContext): StateStep;
-export declare function handleContextSelection(ctx: RunContext): StateStep;
+export { handleContextSelection, handlePlanning } from "@oscharko-dev/keiko-harness";