@oscharko-dev/keiko 0.1.6 → 0.1.7

package/node_modules/@oscharko-dev/keiko-harness/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAIvF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACzE;AAED,qBAAa,gBAAiB,YAAW,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,SAAS;IAEzC,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAGtF;AAGD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED,qBAAa,cAAe,YAAW,QAAQ;IAGjC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAEtB,KAAK,GAAE,SAAS,cAAc,EAAO;IAElE,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAY1D,SAAS,IAAI,SAAS,cAAc,EAAE;IAItC,KAAK,IAAI,SAAS,gBAAgB,EAAE;CAGrC"}

package/node_modules/@oscharko-dev/keiko-harness/dist/adapters.js

@@ -0,0 +1,38 @@
+// Production-side port adapters. GatewayModelPort wraps the ADR-0003 Gateway and
+// propagates the run's AbortSignal as GatewayRequest.cancellationSignal. DryRunToolPort
+// records tool calls without executing them — the Wave-1 no-op executor that keeps the
+// CLI dry-run path free of any side effect (real executors land in issue #6).
+import { CancelledError, } from "@oscharko-dev/keiko-model-gateway";
+export class GatewayModelPort {
+    gateway;
+    constructor(gateway) {
+        this.gateway = gateway;
+    }
+    async call(request, signal) {
+        return this.gateway.chat({ ...request, cancellationSignal: signal });
+    }
+}
+export class DryRunToolPort {
+    tools;
+    recorded = [];
+    constructor(tools = []) {
+        this.tools = tools;
+    }
+    execute(request) {
+        if (request.signal.aborted) {
+            return Promise.reject(new CancelledError("tool execution aborted before start"));
+        }
+        this.recorded.push({
+            toolCallId: request.toolCallId,
+            toolName: request.toolName,
+            arguments: request.arguments,
+        });
+        return Promise.resolve({ toolCallId: request.toolCallId, output: "", durationMs: 0 });
+    }
+    listTools() {
+        return this.tools;
+    }
+    calls() {
+        return this.recorded;
+    }
+}

package/node_modules/@oscharko-dev/keiko-harness/dist/context.d.ts

@@ -0,0 +1,32 @@
+import type { ChatMessage, Clock, NormalizedResponse } from "@oscharko-dev/keiko-model-gateway";
+import { Emitter } from "./emitter.js";
+import type { ModelPort, ToolPort } from "./ports.js";
+import type { TaskPlan } from "./tasks/policy.js";
+import type { HarnessFailure, HarnessLimits, HarnessStateName, RunCounters, TaskType } from "./types.js";
+export interface RunContext {
+    readonly model: ModelPort;
+    readonly tools: ToolPort;
+    readonly emitter: Emitter;
+    readonly clock: Clock;
+    readonly signal: AbortSignal;
+    readonly limits: HarnessLimits;
+    readonly modelId: string;
+    readonly taskType: TaskType;
+    readonly plan: TaskPlan;
+    readonly startedAt: number;
+    readonly counters: RunCounters;
+    messages: ChatMessage[];
+    lastResponse: NormalizedResponse | undefined;
+    patchDiff: string | undefined;
+    report: string | undefined;
+    failure: HarnessFailure | undefined;
+    cancelReason: string | undefined;
+    cancelledAtState: HarnessStateName | undefined;
+}
+export interface StateStep {
+    readonly to: HarnessStateName;
+    readonly reason: string;
+}
+export declare function newCounters(): RunCounters;
+export declare function contextBytes(messages: readonly ChatMessage[]): number;
+//# sourceMappingURL=context.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAChG,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACT,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAE/B,QAAQ,EAAE,WAAW,EAAE,CAAC;IAExB,YAAY,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAE7C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,cAAc,GAAG,SAAS,CAAC;IACpC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,gBAAgB,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAChD;AAID,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,WAAW,IAAI,WAAW,CASzC;AAMD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAErE"}

package/node_modules/@oscharko-dev/keiko-harness/dist/context.js

@@ -0,0 +1,21 @@
+// Mutable run state shared across the state handlers. Created once per run by the loop;
+// handlers read ports/limits/clock and mutate counters, the message accumulator, and the
+// terminal-outcome carriers (patchDiff, report, failure). Keeping this in one place lets
+// each handler file stay small and free of cross-handler imports.
+import { Emitter } from "./emitter.js";
+export function newCounters() {
+    return {
+        iterations: 0,
+        modelCalls: 0,
+        toolCalls: 0,
+        commandExecutions: 0,
+        failureAttempts: 0,
+        browserNavigations: 0,
+    };
+}
+// UTF-8 byte length of the serialised message array — the zero-dependency context-size
+// proxy (ADR-0004 D3). Tokens require a model-specific tokeniser; bytes do not.
+const encoder = new TextEncoder();
+export function contextBytes(messages) {
+    return encoder.encode(JSON.stringify(messages)).length;
+}

package/node_modules/@oscharko-dev/keiko-harness/dist/emitter.d.ts

@@ -0,0 +1,16 @@
+import { type Clock } from "@oscharko-dev/keiko-model-gateway";
+import type { EventSink } from "./ports.js";
+import type { HarnessEvent } from "./types.js";
+type IdentityField = "schemaVersion" | "runId" | "fingerprint" | "seq" | "ts";
+type EventBody = HarnessEvent extends infer E ? E extends HarnessEvent ? Omit<E, IdentityField> : never : never;
+export declare class Emitter {
+    private readonly sinks;
+    private readonly clock;
+    private readonly runId;
+    private readonly fingerprint;
+    private seq;
+    constructor(sinks: readonly EventSink[], clock: Clock, runId: string, fingerprint: string);
+    emit(body: EventBody): void;
+}
+export {};
+//# sourceMappingURL=emitter.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,KAAK,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,KAAK,aAAa,GAAG,eAAe,GAAG,OAAO,GAAG,aAAa,GAAG,KAAK,GAAG,IAAI,CAAC;AAC9E,KAAK,SAAS,GAAG,YAAY,SAAS,MAAM,CAAC,GACzC,CAAC,SAAS,YAAY,GACpB,IAAI,CAAC,CAAC,EAAE,aAAa,CAAC,GACtB,KAAK,GACP,KAAK,CAAC;AAoDV,qBAAa,OAAO;IAMhB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAR9B,OAAO,CAAC,GAAG,CAAK;gBAKG,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM;IAGtC,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;CAe5B"}

package/node_modules/@oscharko-dev/keiko-harness/dist/emitter.js

@@ -0,0 +1,72 @@
+// Stamps every harness event with run identity, a monotonic seq, and a clock timestamp,
+// then forwards it to the sink. SENSITIVE fields (rationale, modelResponse, diff) are
+// redacted before forwarding UNLESS the sink retains raw content for replay (ADR-0004 D6).
+import { redact } from "@oscharko-dev/keiko-model-gateway";
+function redactReasoningTrace(event) {
+    return {
+        ...event,
+        rationale: redact(event.rationale),
+        ...(event.modelResponse === undefined ? {} : { modelResponse: redact(event.modelResponse) }),
+    };
+}
+function redactRunCompleted(event) {
+    // WHY: report and patchDiff carry full model output; keep known secret formats out of every
+    // sink that does not explicitly retain raw content for replay.
+    return {
+        ...event,
+        report: redact(event.report),
+        ...(event.patchDiff === undefined ? {} : { patchDiff: redact(event.patchDiff) }),
+    };
+}
+function redactRunFailed(event) {
+    const failure = {
+        ...event.failure,
+        message: redact(event.failure.message),
+        ...(event.failure.detail === undefined ? {} : { detail: redact(event.failure.detail) }),
+    };
+    return { ...event, failure };
+}
+const REDACTORS = {
+    "reasoning:trace": redactReasoningTrace,
+    "patch:proposed": (event) => ({ ...event, diff: redact(event.diff) }),
+    "model:call:failed": (event) => ({ ...event, message: redact(event.message) }),
+    "tool:call:failed": (event) => ({ ...event, message: redact(event.message) }),
+    "verification:result": (event) => ({ ...event, detail: redact(event.detail) }),
+    "run:completed": redactRunCompleted,
+    "run:cancelled": (event) => event.reason === undefined ? event : { ...event, reason: redact(event.reason) },
+    "run:failed": redactRunFailed,
+};
+function redactSensitive(event) {
+    const redactor = REDACTORS[event.type];
+    return redactor === undefined ? event : redactor(event);
+}
+export class Emitter {
+    sinks;
+    clock;
+    runId;
+    fingerprint;
+    seq = 0;
+    // Fans every event out to all sinks. Each sink receives raw SENSITIVE fields only if it
+    // declares `retainsRawContent`; otherwise it receives a redacted copy.
+    constructor(sinks, clock, runId, fingerprint) {
+        this.sinks = sinks;
+        this.clock = clock;
+        this.runId = runId;
+        this.fingerprint = fingerprint;
+    }
+    emit(body) {
+        this.seq += 1;
+        const event = {
+            schemaVersion: "1",
+            runId: this.runId,
+            fingerprint: this.fingerprint,
+            seq: this.seq,
+            ts: this.clock.now(),
+            ...body,
+        };
+        const redacted = redactSensitive(event);
+        for (const sink of this.sinks) {
+            sink.emit(sink.retainsRawContent === true ? event : redacted);
+        }
+    }
+}

package/node_modules/@oscharko-dev/keiko-harness/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export { HARNESS_CODES, HarnessError, LimitExceededError, HarnessModelError, HarnessToolError, HarnessInternalError, toFailure, } from "@oscharko-dev/keiko-security/errors/harness";
+export type { HarnessCode } from "@oscharko-dev/keiko-security/errors/harness";
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,GACV,MAAM,6CAA6C,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,6CAA6C,CAAC"}

package/node_modules/@oscharko-dev/keiko-harness/dist/errors.js

@@ -0,0 +1,4 @@
+// Re-export shim: the harness error taxonomy now lives in @oscharko-dev/keiko-security
+// (issue #159, ADR-0019). All existing import sites (`from "./errors.js"`) keep resolving
+// unchanged via this barrel.
+export { HARNESS_CODES, HarnessError, LimitExceededError, HarnessModelError, HarnessToolError, HarnessInternalError, toFailure, } from "@oscharko-dev/keiko-security/errors/harness";

package/node_modules/@oscharko-dev/keiko-harness/dist/executor.d.ts

@@ -0,0 +1,4 @@
+import { type RunContext, type StateStep } from "./context.js";
+export declare function handleModelCall(ctx: RunContext): Promise<StateStep>;
+export declare function handleToolCall(ctx: RunContext): Promise<StateStep>;
+//# sourceMappingURL=executor.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"AAcA,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AA4D7E,wBAAsB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAmCzE;AAgHD,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAyBxE"}

package/node_modules/@oscharko-dev/keiko-harness/dist/executor.js

@@ -0,0 +1,211 @@
+// 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 "@oscharko-dev/keiko-model-gateway";
+import { ToolError } from "@oscharko-dev/keiko-tools";
+import { WorkspaceError } from "@oscharko-dev/keiko-workspace";
+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" };
+}

package/node_modules/@oscharko-dev/keiko-harness/dist/fingerprint.d.ts

@@ -0,0 +1,8 @@
+import { canonicalise } from "@oscharko-dev/keiko-security";
+import type { Fingerprinter, FingerprintInput, IdSource } from "./ports.js";
+export declare function configFingerprint(input: FingerprintInput): string;
+export declare const defaultFingerprinter: Fingerprinter;
+export declare const defaultIdSource: IdSource;
+export declare function counterIdSource(): IdSource;
+export { canonicalise };
+//# sourceMappingURL=fingerprint.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../src/fingerprint.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAa,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE5E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAEjE;AAED,eAAO,MAAM,oBAAoB,EAAE,aAElC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAE7B,CAAC;AAGF,wBAAgB,eAAe,IAAI,QAAQ,CAQ1C;AAID,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/node_modules/@oscharko-dev/keiko-harness/dist/fingerprint.js

@@ -0,0 +1,28 @@
+// Deterministic run-ID and configuration-fingerprint sources. Production uses
+// node:crypto (randomUUID) for the random ID source and the shared security-package
+// hashing primitives (canonical-JSON + SHA-256 hex) for the config fingerprint; tests
+// inject a counter so IDs are fixed and runs are reproducible for replay (ADR-0004 D7).
+import { randomUUID } from "node:crypto";
+import { canonicalise, sha256Hex } from "@oscharko-dev/keiko-security";
+export function configFingerprint(input) {
+    return sha256Hex(canonicalise(input));
+}
+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 the canonical-JSON serialiser at its historical name for any caller that still imports
+// it from this module. The implementation now lives in @oscharko-dev/keiko-security/hashing.
+export { canonicalise };

package/node_modules/@oscharko-dev/keiko-harness/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { KEIKO_HARNESS_VERSION } from "./version.js";
+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, ToolCallMetadata, 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 { Emitter } from "./emitter.js";
+export { runLoop } from "./loop.js";
+export { handleModelCall, handleToolCall } from "./executor.js";
+export { handlePatchProposal, handleReporting, handleVerification } from "./patcher.js";
+export { handleContextSelection, handlePlanning } from "./planner.js";
+export { contextBytes, newCounters, type RunContext, type StateStep } from "./context.js";
+export { buildExplainPlan } from "./tasks/explain-plan.js";
+export { buildGenerateUnitTests } from "./tasks/generate-unit-tests.js";
+export { buildInvestigateBug } from "./tasks/investigate-bug.js";
+export { buildVerify } from "./tasks/verify.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EACL,aAAa,EACb,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,EACL,cAAc,EACd,aAAa,EACb,eAAe,EACf,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,GAC7B,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,GACV,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEhG,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAWnE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/node_modules/@oscharko-dev/keiko-harness/dist/index.js

@@ -0,0 +1,36 @@
+// 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). After issue #164 (ADR-0019) the harness lives in
+// `packages/keiko-harness/`; the legacy `src/harness/` directory now contains only
+// enumerated re-export shims that keep every consumer's existing import path resolving
+// unchanged.
+export { KEIKO_HARNESS_VERSION } from "./version.js";
+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";
+// Harness internals re-exported on the package barrel so the legacy
+// `src/harness/<file>.ts` shims (issue #164) and the package's own
+// `src/<file>.test.ts` suites can both reach them through one import source. These
+// symbols are NOT documented in the harness public-API surface — they are exposed
+// here purely so a) the legacy `src/harness/` shim layer can keep `from
+// "../harness/loop.js"` style imports resolving without subpath-importing into the
+// package, and b) the in-package tests can use the same `@oscharko-dev/keiko-harness`
+// entry point as production consumers. Downstream consumers should depend on the
+// documented surface above, not on these.
+export { Emitter } from "./emitter.js";
+export { runLoop } from "./loop.js";
+export { handleModelCall, handleToolCall } from "./executor.js";
+export { handlePatchProposal, handleReporting, handleVerification } from "./patcher.js";
+export { handleContextSelection, handlePlanning } from "./planner.js";
+export { contextBytes, newCounters } from "./context.js";
+export { buildExplainPlan } from "./tasks/explain-plan.js";
+export { buildGenerateUnitTests } from "./tasks/generate-unit-tests.js";
+export { buildInvestigateBug } from "./tasks/investigate-bug.js";
+export { buildVerify } from "./tasks/verify.js";

package/node_modules/@oscharko-dev/keiko-harness/dist/loop.d.ts

@@ -0,0 +1,4 @@
+import { type RunContext } from "./context.js";
+import { type RunOutcome } from "./types.js";
+export declare function runLoop(ctx: RunContext): Promise<RunOutcome>;
+//# sourceMappingURL=loop.d.ts.map

package/node_modules/@oscharko-dev/keiko-harness/dist/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../src/loop.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,UAAU,EAAkB,MAAM,cAAc,CAAC;AAI7E,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAyIrF,wBAAsB,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CA4BlE"}