@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/gateway/redaction.js

@@ -1,51 +1,4 @@
-// Secret redaction at the boundary. Every provider-derived string passes through
-// redact() before it can reach an error message, log call, or serialised artefact.
-const REDACTED = "[REDACTED]";
-// Bearer <token>: keep the scheme, drop the credential.
-const BEARER_PATTERN = /\bBearer\s+[\w.\-+/=]+/gi;
-const BASIC_AUTH_PATTERN = /\bBasic\s+[\w.\-+/=]+/gi;
-// OpenAI-style keys (sk-, sk-proj-, etc.): a prefix followed by >= 16 secret chars.
-const API_KEY_PATTERN = /\bsk-[A-Za-z0-9_-]{16,}/g;
-// Common third-party credential shapes. Each is a single linear character class with one
-// bounded/open quantifier (no nesting), so none can backtrack catastrophically — this keeps
-// CodeQL js/polynomial-redos satisfied while scrubbing non-OpenAI secrets from tool output.
-const GITHUB_TOKEN_PATTERN = /\bgh[pousr]_[A-Za-z0-9]{20,}/g;
-const AWS_ACCESS_KEY_PATTERN = /\bAKIA[0-9A-Z]{16}\b/g;
-const SLACK_TOKEN_PATTERN = /\bxox[baprs]-[A-Za-z0-9-]{10,}/g;
-const GOOGLE_API_KEY_PATTERN = /\bAIza[0-9A-Za-z_-]{20,}/g;
-const PEM_PRIVATE_KEY_BLOCK_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
-const PEM_PRIVATE_KEY_HEADER_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
-const GENERIC_API_KEY_HEADER_PATTERN = /\b(x-api-key\s*:\s*)[^\s"'`,;]+/gi;
-const GENERIC_API_KEY_ASSIGNMENT_PATTERN = /\b(api[_-]?key\s*[=:]\s*)[^\s"'`,;&]+/gi;
-const BUILTIN_PATTERNS = [
-    GITHUB_TOKEN_PATTERN,
-    AWS_ACCESS_KEY_PATTERN,
-    SLACK_TOKEN_PATTERN,
-    GOOGLE_API_KEY_PATTERN,
-    PEM_PRIVATE_KEY_BLOCK_PATTERN,
-    PEM_PRIVATE_KEY_HEADER_PATTERN,
-];
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-// Strips known secret shapes and any caller-supplied literal secrets from `input`.
-// `additionalSecrets` lets the gateway pass the exact apiKey/baseUrl values it holds
-// so even non-standard key formats are scrubbed.
-export function redact(input, additionalSecrets = []) {
-    let output = input
-        .replace(BEARER_PATTERN, `Bearer ${REDACTED}`)
-        .replace(BASIC_AUTH_PATTERN, `Basic ${REDACTED}`)
-        .replace(GENERIC_API_KEY_HEADER_PATTERN, `$1${REDACTED}`)
-        .replace(GENERIC_API_KEY_ASSIGNMENT_PATTERN, `$1${REDACTED}`)
-        .replace(API_KEY_PATTERN, REDACTED);
-    for (const pattern of BUILTIN_PATTERNS) {
-        output = output.replace(pattern, REDACTED);
-    }
-    for (const secret of additionalSecrets) {
-        if (secret.length === 0) {
-            continue;
-        }
-        output = output.replace(new RegExp(escapeRegExp(secret), "g"), REDACTED);
-    }
-    return output;
-}
+// Re-export shim: the gateway redaction engine now lives in @oscharko-dev/keiko-security (issue
+// #159, ADR-0019). All existing import sites (`from "../gateway/redaction.js"`) keep resolving
+// unchanged via this barrel.
+export { redact } from "@oscharko-dev/keiko-security";

package/dist/gateway/resilience.d.ts

@@ -1,24 +1,2 @@
-import type { CircuitBreakerConfig, CircuitBreakerStatus, Clock } from "./types.js";
-export declare const systemClock: Clock;
-export interface RetryConfig {
-    readonly maxRetries: number;
-    readonly retryBaseDelayMs: number;
-    readonly timeoutMs?: number | undefined;
-}
-export declare function executeWithRetry<T>(operation: (attemptTimeoutMs?: number) => Promise<T>, config: RetryConfig, clock: Clock, signal?: AbortSignal): Promise<T>;
-export declare class CircuitBreaker {
-    private readonly modelId;
-    private readonly config;
-    private readonly clock;
-    private state;
-    private consecutiveFailures;
-    private openedAt;
-    private probesRemaining;
-    constructor(modelId: string, config: CircuitBreakerConfig, clock: Clock);
-    assertAllowed(): void;
-    recordSuccess(): void;
-    recordFailure(): void;
-    status(modelId: string): CircuitBreakerStatus;
-    private open;
-    private close;
-}
+export { CircuitBreaker, executeWithRetry, systemClock, } from "@oscharko-dev/keiko-model-gateway/internal/resilience";
+export type { RetryConfig } from "@oscharko-dev/keiko-model-gateway/internal/resilience";

package/dist/gateway/resilience.js

@@ -1,166 +1,3 @@
-// Resilience primitives: a real-time Clock, a bounded exponential-backoff retry
-// loop, and a per-(model,endpoint) circuit breaker. All time-dependent behaviour
-// flows through the injectable Clock so tests are deterministic and instant.
-import { CancelledError, CircuitOpenError, GatewayError, RateLimitError } from "./errors.js";
-const MAX_BACKOFF_MS = 30_000;
-export const systemClock = {
-    now: () => Date.now(),
-    sleep: (ms, signal) => {
-        if (signal?.aborted === true) {
-            return Promise.reject(new DOMException("cancelled", "AbortError"));
-        }
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                signal?.removeEventListener("abort", onAbort);
-                resolve();
-            }, ms);
-            function onAbort() {
-                clearTimeout(timeout);
-                reject(new DOMException("cancelled", "AbortError"));
-            }
-            signal?.addEventListener("abort", onAbort, { once: true });
-        });
-    },
-};
-function backoffDelayMs(attempt, base) {
-    return Math.min(base * 2 ** (attempt - 1), MAX_BACKOFF_MS);
-}
-// A RateLimitError with an explicit retryAfterMs is honoured; otherwise the error's
-// own `retryable` flag decides. Non-GatewayErrors are never retried.
-function retryDelayMs(error, attempt, base) {
-    if (!(error instanceof GatewayError) || !error.retryable) {
-        return null;
-    }
-    if (error instanceof RateLimitError && error.retryAfterMs !== null && error.retryAfterMs > 0) {
-        return Math.min(error.retryAfterMs, MAX_BACKOFF_MS);
-    }
-    return backoffDelayMs(attempt, base);
-}
-function assertNotAborted(signal) {
-    if (signal?.aborted === true) {
-        throw new CancelledError("request cancelled during retry");
-    }
-}
-function remainingBudgetMs(start, timeoutMs, clock) {
-    if (timeoutMs === undefined) {
-        return Number.POSITIVE_INFINITY;
-    }
-    return Math.max(0, timeoutMs - (clock.now() - start));
-}
-function asError(error) {
-    if (error instanceof Error) {
-        return error;
-    }
-    return new Error(String(error));
-}
-async function sleepWithCancellation(clock, delayMs, signal) {
-    assertNotAborted(signal);
-    try {
-        await clock.sleep(delayMs, signal);
-    }
-    catch (error) {
-        if (signal?.aborted === true) {
-            throw new CancelledError("request cancelled during retry backoff");
-        }
-        throw error;
-    }
-    assertNotAborted(signal);
-}
-export async function executeWithRetry(operation, config, clock, signal) {
-    let lastError;
-    const start = clock.now();
-    for (let attempt = 1; attempt <= config.maxRetries + 1; attempt += 1) {
-        assertNotAborted(signal);
-        const attemptBudget = remainingBudgetMs(start, config.timeoutMs, clock);
-        if (attemptBudget <= 0) {
-            if (lastError) {
-                throw lastError;
-            }
-            throw new CancelledError("request timeout budget exhausted before provider call");
-        }
-        try {
-            return await operation(Number.isFinite(attemptBudget) ? Math.max(1, Math.floor(attemptBudget)) : undefined);
-        }
-        catch (error) {
-            lastError = asError(error);
-            const delay = attempt <= config.maxRetries
-                ? retryDelayMs(lastError, attempt, config.retryBaseDelayMs)
-                : null;
-            if (delay === null) {
-                throw lastError;
-            }
-            const remaining = remainingBudgetMs(start, config.timeoutMs, clock);
-            if (remaining <= 0) {
-                throw lastError;
-            }
-            await sleepWithCancellation(clock, Math.min(delay, remaining), signal);
-        }
-    }
-    throw lastError ?? new CancelledError("request timeout budget exhausted after retries");
-}
-export class CircuitBreaker {
-    modelId;
-    config;
-    clock;
-    state = "closed";
-    consecutiveFailures = 0;
-    openedAt = null;
-    probesRemaining = 0;
-    constructor(modelId, config, clock) {
-        this.modelId = modelId;
-        this.config = config;
-        this.clock = clock;
-    }
-    // Called before forwarding a request. Throws CircuitOpenError when the breaker is
-    // open and the cooldown has not elapsed; otherwise lets the call through (entering
-    // half-open as a side effect when cooldown has passed).
-    assertAllowed() {
-        if (this.state === "open") {
-            if (this.openedAt !== null && this.clock.now() - this.openedAt >= this.config.cooldownMs) {
-                this.state = "half-open";
-                this.probesRemaining = this.config.halfOpenProbes;
-                return;
-            }
-            throw new CircuitOpenError(`circuit open for model '${this.modelId}'`);
-        }
-    }
-    recordSuccess() {
-        if (this.state === "half-open") {
-            this.probesRemaining -= 1;
-            if (this.probesRemaining <= 0) {
-                this.close();
-            }
-            return;
-        }
-        this.consecutiveFailures = 0;
-    }
-    recordFailure() {
-        if (this.state === "half-open") {
-            this.open();
-            return;
-        }
-        this.consecutiveFailures += 1;
-        if (this.consecutiveFailures >= this.config.failureThreshold) {
-            this.open();
-        }
-    }
-    status(modelId) {
-        return {
-            modelId,
-            state: this.state,
-            consecutiveFailures: this.consecutiveFailures,
-            openedAt: this.openedAt,
-        };
-    }
-    open() {
-        this.state = "open";
-        this.openedAt = this.clock.now();
-        this.probesRemaining = 0;
-    }
-    close() {
-        this.state = "closed";
-        this.consecutiveFailures = 0;
-        this.openedAt = null;
-        this.probesRemaining = 0;
-    }
-}
+// Re-export shim: resilience now lives in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/resilience.js"`) keep resolving unchanged via this barrel.
+export { CircuitBreaker, executeWithRetry, systemClock, } from "@oscharko-dev/keiko-model-gateway/internal/resilience";

package/dist/gateway/types.d.ts

@@ -1,110 +1 @@
-export type ModelKind = "chat" | "embedding" | "ocr-vision";
-export type CostClass = "low" | "medium" | "high";
-export type LatencyClass = "fast" | "standard" | "slow";
-export interface ModelCapability {
-    readonly id: string;
-    readonly kind: ModelKind;
-    readonly contextWindow: number;
-    readonly maxOutputTokens: number;
-    readonly toolCalling: boolean;
-    readonly structuredOutput: boolean;
-    readonly streaming: boolean;
-    readonly costClass: CostClass;
-    readonly latencyClass: LatencyClass;
-    readonly throughputHint: string;
-    readonly preferredUseCases: readonly string[];
-    readonly knownLimitations: readonly string[];
-}
-export interface ModelProviderConfig {
-    readonly modelId: string;
-    readonly baseUrl: string;
-    readonly apiKey: string;
-    readonly apiKeyHeaderName?: string | undefined;
-    readonly timeoutMs: number;
-    readonly maxRetries: number;
-    readonly retryBaseDelayMs: number;
-}
-export interface CircuitBreakerConfig {
-    readonly failureThreshold: number;
-    readonly cooldownMs: number;
-    readonly halfOpenProbes: number;
-}
-export interface GatewayConfig {
-    readonly providers: readonly ModelProviderConfig[];
-    readonly circuitBreaker: CircuitBreakerConfig;
-    readonly capabilities?: readonly ModelCapability[] | undefined;
-}
-export interface ChatMessage {
-    readonly role: "system" | "user" | "assistant" | "tool";
-    readonly content: string;
-    readonly toolCallId?: string | undefined;
-    readonly toolCalls?: readonly NormalizedToolCall[] | undefined;
-}
-export interface ToolDefinition {
-    readonly name: string;
-    readonly description: string;
-    readonly parameters: Record<string, unknown>;
-}
-export type ResponseFormat = {
-    readonly type: "text";
-} | {
-    readonly type: "json_schema";
-    readonly schema: Record<string, unknown>;
-};
-export interface GatewayRequest {
-    readonly modelId: string;
-    readonly messages: readonly ChatMessage[];
-    readonly tools?: readonly ToolDefinition[] | undefined;
-    readonly responseFormat?: ResponseFormat | undefined;
-    readonly stream?: boolean | undefined;
-    readonly cancellationSignal?: AbortSignal | undefined;
-}
-export interface NormalizedToolCall {
-    readonly id: string;
-    readonly name: string;
-    readonly arguments: Record<string, unknown>;
-}
-export interface UsageMetadata {
-    readonly requestId: string;
-    readonly promptTokens: number;
-    readonly completionTokens: number;
-    readonly latencyMs: number;
-    readonly costClass: CostClass;
-}
-export type FinishReason = "stop" | "tool_calls" | "length" | "content_filter" | "error" | "cancelled";
-export interface NormalizedResponse {
-    readonly modelId: string;
-    readonly content: string;
-    readonly finishReason: FinishReason;
-    readonly toolCalls: readonly NormalizedToolCall[];
-    readonly structuredOutput: Record<string, unknown> | null;
-    readonly usage: UsageMetadata;
-}
-export interface StreamDelta {
-    readonly role?: "assistant" | undefined;
-    readonly contentDelta?: string | undefined;
-    readonly toolCallDelta?: Partial<NormalizedToolCall> | undefined;
-    readonly finishReason?: FinishReason | undefined;
-    readonly usage?: UsageMetadata | undefined;
-}
-export type StreamEvent = {
-    readonly type: "delta";
-    readonly delta: StreamDelta;
-} | {
-    readonly type: "done";
-    readonly response: NormalizedResponse;
-};
-export interface ProviderAdapter {
-    readonly call: (request: GatewayRequest, config: ModelProviderConfig) => Promise<NormalizedResponse>;
-}
-export interface Clock {
-    readonly now: () => number;
-    readonly sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
-}
-export type CircuitState = "closed" | "open" | "half-open";
-export interface CircuitBreakerStatus {
-    readonly modelId: string;
-    readonly state: CircuitState;
-    readonly consecutiveFailures: number;
-    readonly openedAt: number | null;
-}
+export type { CircuitBreakerConfig, CircuitBreakerStatus, CircuitState, ChatMessage, Clock, CostClass, FinishReason, GatewayConfig, GatewayRequest, LatencyClass, ModelCapability, ModelKind, ModelProviderConfig, NormalizedResponse, NormalizedToolCall, ProviderAdapter, ResponseFormat, StreamDelta, StreamEvent, ToolDefinition, UsageMetadata, } from "@oscharko-dev/keiko-model-gateway";

package/dist/gateway/types.js

@@ -1,2 +1,3 @@
-// All gateway interfaces and type aliases. No runtime code lives here.
+// Re-export shim: types now live in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/types.js"`) keep resolving unchanged via this barrel.
 export {};

package/dist/harness/adapters.d.ts

@@ -1,23 +1 @@
-import type { GatewayRequest, NormalizedResponse, ToolDefinition } from "../gateway/types.js";
-import type { ModelPort, ToolCallRequest, ToolCallResult, ToolPort } from "./ports.js";
-export interface ChatModel {
-    readonly chat: (request: GatewayRequest) => Promise<NormalizedResponse>;
-}
-export declare class GatewayModelPort implements ModelPort {
-    private readonly gateway;
-    constructor(gateway: ChatModel);
-    call(request: GatewayRequest, signal: AbortSignal): Promise<NormalizedResponse>;
-}
-export interface RecordedToolCall {
-    readonly toolCallId: string;
-    readonly toolName: string;
-    readonly arguments: Record<string, unknown>;
-}
-export declare class DryRunToolPort implements ToolPort {
-    private readonly tools;
-    private readonly recorded;
-    constructor(tools?: readonly ToolDefinition[]);
-    execute(request: ToolCallRequest): Promise<ToolCallResult>;
-    listTools(): readonly ToolDefinition[];
-    calls(): readonly RecordedToolCall[];
-}
+export { DryRunToolPort, GatewayModelPort, type ChatModel, type RecordedToolCall, } from "@oscharko-dev/keiko-harness";

package/dist/harness/adapters.js

@@ -1,38 +1,3 @@
-// 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 "../gateway/errors.js";
-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;
-    }
-}
+// Re-export shim: harness port adapters live in @oscharko-dev/keiko-harness
+// (issue #164, ADR-0019).
+export { DryRunToolPort, GatewayModelPort, } from "@oscharko-dev/keiko-harness";

package/dist/harness/context.d.ts

@@ -1,33 +1 @@
-import type { ChatMessage } from "../gateway/types.js";
-import type { Clock } from "../gateway/types.js";
-import { Emitter } from "./emitter.js";
-import type { NormalizedResponse } from "../gateway/types.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;
+export { contextBytes, newCounters, type RunContext, type StateStep, } from "@oscharko-dev/keiko-harness";

package/dist/harness/context.js

@@ -1,21 +1,4 @@
-// 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;
-}
+// Re-export shim: harness run-context internals 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 { contextBytes, newCounters, } from "@oscharko-dev/keiko-harness";

package/dist/harness/emitter.d.ts

@@ -1,15 +1 @@
-import type { Clock } from "../gateway/types.js";
-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 {};
+export { Emitter } from "@oscharko-dev/keiko-harness";

package/dist/harness/emitter.js

@@ -1,72 +1,4 @@
-// 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 "../gateway/redaction.js";
-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);
-        }
-    }
-}
+// Re-export shim: the harness Emitter now lives in @oscharko-dev/keiko-harness
+// (issue #164, ADR-0019). Emitter is a harness internal — kept on the package barrel
+// only so this legacy shim resolves without subpath-importing into the package.
+export { Emitter } from "@oscharko-dev/keiko-harness";

package/dist/harness/errors.d.ts

@@ -1,21 +1,2 @@
-import { HARNESS_CODES, type HarnessCode, type HarnessFailure } from "./types.js";
-export { HARNESS_CODES };
-export type { HarnessCode };
-export declare abstract class HarnessError extends Error {
-    abstract readonly code: HarnessCode;
-    constructor(message: string, secrets?: readonly string[]);
-}
-export declare class LimitExceededError extends HarnessError {
-    readonly code: HarnessCode;
-    constructor(code: HarnessCode, message: string, secrets?: readonly string[]);
-}
-export declare class HarnessModelError extends HarnessError {
-    readonly code: "HARNESS_MODEL_ERROR";
-}
-export declare class HarnessToolError extends HarnessError {
-    readonly code: "HARNESS_TOOL_ERROR";
-}
-export declare class HarnessInternalError extends HarnessError {
-    readonly code: "HARNESS_INTERNAL";
-}
-export declare function toFailure(category: HarnessCode, message: string, detail?: string): HarnessFailure;
+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";