@oscharko-dev/keiko 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/gateway/capabilities.data.js

@@ -1,203 +1,5 @@
-// Raw capability registry data for the Wave 1 model portfolio plus locally deployed Azure models.
-// All numeric and class values are documented assumptions based on public model cards and provider
-// documentation as of 2026-05-28 unless the entry names a live Azure deployment; [assumption] marks
-// figures the customer may override via config when authoritative deployment numbers are available.
-export const CAPABILITY_DATA = [
-    {
-        id: "Qwen3-Coder-480B-A35B-Instruct-FP8",
-        kind: "chat",
-        contextWindow: 128_000, // [assumption]
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "high",
-        latencyClass: "slow",
-        throughputHint: "~40 tok/s [assumption]",
-        preferredUseCases: ["Large-codebase refactor", "Cross-file analysis"],
-        knownLimitations: ["Very high VRAM; slow for interactive use"],
-    },
-    {
-        id: "Qwen/Qwen3-Coder-Next-FP8",
-        kind: "chat",
-        contextWindow: 128_000, // [assumption]
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "high",
-        latencyClass: "slow",
-        throughputHint: "~40 tok/s [assumption]",
-        preferredUseCases: ["Deep code synthesis requiring maximum reasoning depth"],
-        knownLimitations: [
-            "Same VRAM/latency constraints as Qwen3-Coder-480B; treat as next-generation upgrade path",
-        ],
-    },
-    {
-        id: "Devstral-2-123B-Instruct-2512",
-        kind: "chat",
-        contextWindow: 128_000, // [assumption]
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "high",
-        latencyClass: "standard",
-        throughputHint: "~80 tok/s [assumption]",
-        preferredUseCases: ["Agentic code completion", "Multi-step software engineering"],
-        knownLimitations: [
-            "123B scale; requires dedicated GPU allocation; not suitable for high-QPS workloads",
-        ],
-    },
-    {
-        id: "gpt-oss-120b",
-        kind: "chat",
-        contextWindow: 128_000, // [assumption]
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "high",
-        latencyClass: "standard",
-        throughputHint: "~80 tok/s [assumption]",
-        preferredUseCases: ["General-purpose coding", "Code review", "Explanation"],
-        knownLimitations: [
-            "Customer-hosted OSS model; endpoint reliability depends on customer infrastructure",
-        ],
-    },
-    {
-        id: "mistral-large-3",
-        kind: "chat",
-        contextWindow: 128_000, // Azure deployment Mistral-Large-3, Swedish Central.
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true, // [assumption]
-        streaming: true,
-        costClass: "high",
-        latencyClass: "standard",
-        throughputHint: "20 RPM / 20k TPM on current Visual Studio subscription quota",
-        preferredUseCases: ["Alternative coding agent", "Large-context explanation", "Review"],
-        knownLimitations: [
-            "Current subscription quota caps this deployment at 20 capacity units without quota increase",
-        ],
-    },
-    {
-        id: "llama-4-maverick-vision",
-        kind: "chat",
-        contextWindow: 128_000, // Azure deployment Llama-4-Maverick-17B-128E-Instruct-FP8.
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: false, // [assumption]
-        streaming: true,
-        costClass: "high",
-        latencyClass: "standard",
-        throughputHint: "20 RPM / 20k TPM on current Visual Studio subscription quota",
-        preferredUseCases: ["Alternative agent model", "Vision-capable review path", "Explanation"],
-        knownLimitations: [
-            "Current subscription quota caps this deployment at 20 capacity units without quota increase",
-            "Structured output reliability must be verified before routing patch-producing workflows",
-        ],
-    },
-    {
-        id: "Mistral-Small-3.1-24B-Instruct-2503",
-        kind: "chat",
-        contextWindow: 128_000,
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "medium",
-        latencyClass: "fast",
-        throughputHint: "~150 tok/s [assumption]",
-        preferredUseCases: ["Interactive code assist", "Quick edits", "Low-latency agent steps"],
-        knownLimitations: ["Smaller model; may require multi-turn for complex reasoning"],
-    },
-    {
-        id: "Qwen2.5-Coder-7B-Instruct",
-        kind: "chat",
-        contextWindow: 128_000,
-        maxOutputTokens: 4_096, // [assumption]
-        toolCalling: true,
-        structuredOutput: false, // [assumption]
-        streaming: true,
-        costClass: "low",
-        latencyClass: "fast",
-        throughputHint: "~200 tok/s [assumption]",
-        preferredUseCases: [
-            "Inline completion",
-            "Snippet generation",
-            "High-throughput batch coding tasks",
-        ],
-        knownLimitations: [
-            "Limited structured-output reliability; context degradation beyond 64K tokens observed in benchmarks [assumption]",
-        ],
-    },
-    {
-        id: "gemma-4-31b-it",
-        kind: "chat",
-        contextWindow: 128_000, // [assumption]
-        maxOutputTokens: 8_192, // [assumption]
-        toolCalling: true,
-        structuredOutput: true,
-        streaming: true,
-        costClass: "medium",
-        latencyClass: "standard",
-        throughputHint: "~120 tok/s [assumption]",
-        preferredUseCases: ["Document summarisation", "Code explanation", "Regulated-context Q&A"],
-        knownLimitations: [
-            "Instruction-tuned variant; verify function-calling reliability against customer endpoint",
-        ],
-    },
-    {
-        id: "dotsocr",
-        kind: "ocr-vision",
-        contextWindow: 0,
-        maxOutputTokens: 0,
-        toolCalling: false,
-        structuredOutput: false,
-        streaming: false,
-        costClass: "medium",
-        latencyClass: "standard",
-        throughputHint: "n/a",
-        preferredUseCases: [
-            "Document OCR",
-            "Scanned contract/form extraction",
-            "Image-to-text in regulated workflows",
-        ],
-        knownLimitations: [
-            "Not a chat model; chat-completions adapter does not apply; callOcr method is Wave 2",
-        ],
-    },
-    {
-        id: "multilingual-e5-large Embedding",
-        kind: "embedding",
-        contextWindow: 512, // [assumption]
-        maxOutputTokens: 0,
-        toolCalling: false,
-        structuredOutput: false,
-        streaming: false,
-        costClass: "low",
-        latencyClass: "fast",
-        throughputHint: "n/a",
-        preferredUseCases: [
-            "Semantic search",
-            "RAG retrieval",
-            "Similarity ranking across multilingual content",
-        ],
-        knownLimitations: ["Max 512 tokens per input; callEmbedding method is Wave 2"],
-    },
-    {
-        id: "text-embedding-3-large",
-        kind: "embedding",
-        contextWindow: 8_191, // Azure OpenAI embedding deployment.
-        maxOutputTokens: 0,
-        toolCalling: false,
-        structuredOutput: false,
-        streaming: false,
-        costClass: "low",
-        latencyClass: "fast",
-        throughputHint: "120 requests / 10s and 120k TPM on current deployment",
-        preferredUseCases: ["Semantic search", "RAG retrieval", "Similarity ranking"],
-        knownLimitations: ["Embedding-only model; chat-completions adapter does not apply"],
-    },
-];
+// Raw built-in capability registry data.
+//
+// Keiko intentionally ships no customer or deployment-specific model ids. Private model
+// capabilities are supplied by local config or discovered at runtime during UI onboarding.
+export const CAPABILITY_DATA = [];

package/dist/gateway/capabilities.js

@@ -10,6 +10,24 @@ export function findCapability(modelId) {
 export function listCapabilities() {
     return CAPABILITY_REGISTRY;
 }
+export function createDefaultChatCapability(modelId) {
+    return {
+        id: modelId,
+        kind: "chat",
+        contextWindow: 0,
+        maxOutputTokens: 0,
+        toolCalling: true,
+        structuredOutput: true,
+        streaming: true,
+        costClass: "medium",
+        latencyClass: "standard",
+        throughputHint: "runtime-configured endpoint",
+        preferredUseCases: ["Chat", "Agent workflow"],
+        knownLimitations: [
+            "Runtime-configured capability; validate against the target endpoint before production use",
+        ],
+    };
+}
 function matches(cap, query) {
     if (query.kind !== undefined && cap.kind !== query.kind) {
         return false;

package/dist/gateway/config.d.ts

@@ -1,4 +1,4 @@
-import type { CircuitBreakerConfig, GatewayConfig } from "./types.js";
+import type { CircuitBreakerConfig, GatewayConfig, ModelCapability } from "./types.js";
 export type EnvSource = Readonly<Record<string, string | undefined>>;
 export interface SafeProviderConfig {
     readonly modelId: string;
@@ -9,6 +9,7 @@ export interface SafeProviderConfig {
 export interface SafeGatewayConfig {
     readonly providers: readonly SafeProviderConfig[];
     readonly circuitBreaker: CircuitBreakerConfig;
+    readonly capabilities?: readonly ModelCapability[] | undefined;
 }
 export declare function parseGatewayConfig(raw: unknown, env?: EnvSource): GatewayConfig;
 export declare function loadConfigFromFile(path: string, env?: EnvSource): GatewayConfig;

package/dist/gateway/config.js

@@ -3,7 +3,6 @@
 // API keys are sourced only from environment or the config file, never CLI flags,
 // and are excluded from every serialisation path.
 import { readFileSync } from "node:fs";
-import { findCapability } from "./capabilities.js";
 import { ConfigInvalidError } from "./errors.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_RETRIES = 3;
@@ -26,6 +25,45 @@ function requireNonEmptyString(value, path) {
     }
     return value;
 }
+function optionalStringArray(value, path, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new ConfigInvalidError(`${path} must be an array of strings`);
+    }
+    return value;
+}
+function optionalNonNegativeInt(value, path, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new ConfigInvalidError(`${path} must be a non-negative integer`);
+    }
+    return value;
+}
+function optionalBoolean(value, path, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value !== "boolean") {
+        throw new ConfigInvalidError(`${path} must be a boolean`);
+    }
+    return value;
+}
+function optionalNonEmptyString(value, path, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    return requireNonEmptyString(value, path);
+}
+function requireEnum(value, path, allowed) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new ConfigInvalidError(`${path} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
 // Model id → KEIKO_MODEL_<UPPER>_ form: non-alphanumerics become "_", uppercased.
 function envModelToken(modelId) {
     return modelId.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
@@ -42,7 +80,7 @@ function resolveSecret(modelId, fileValue, env, suffix) {
     return fallback ?? "";
 }
 // Validates a resolved baseUrl for scheme and credential hygiene. Host/IP is
-// intentionally NOT restricted: Keiko addresses customer-internally-hosted endpoints
+// intentionally NOT restricted: Keiko addresses private network endpoints
 // (private IPs are a valid, first-class target); this guard is scheme/credential
 // hygiene + defence-in-depth, not host filtering.
 function isLoopbackHost(hostname) {
@@ -69,15 +107,41 @@ function validateBaseUrl(baseUrl, path) {
         throw new ConfigInvalidError(`${path}.baseUrl must not embed credentials in the URL; provide the key via apiKey`);
     }
 }
-function parseProvider(raw, index, env) {
-    const path = `providers[${String(index)}]`;
+function parseProviderCapability(raw, path, modelId) {
+    if (raw === undefined) {
+        return undefined;
+    }
     if (!isRecord(raw)) {
         throw new ConfigInvalidError(`${path} must be an object`);
     }
-    const modelId = requireNonEmptyString(raw.modelId, `${path}.modelId`);
-    if (findCapability(modelId) === undefined) {
-        throw new ConfigInvalidError(`${path}.modelId must be registered in the capability registry`);
+    const id = optionalNonEmptyString(raw.id, `${path}.id`, modelId);
+    if (id !== modelId) {
+        throw new ConfigInvalidError(`${path}.id must match the provider modelId`);
     }
+    return {
+        id,
+        kind: requireEnum(raw.kind, `${path}.kind`, ["chat", "embedding", "ocr-vision"]),
+        contextWindow: optionalNonNegativeInt(raw.contextWindow, `${path}.contextWindow`, 0),
+        maxOutputTokens: optionalNonNegativeInt(raw.maxOutputTokens, `${path}.maxOutputTokens`, 0),
+        toolCalling: optionalBoolean(raw.toolCalling, `${path}.toolCalling`, false),
+        structuredOutput: optionalBoolean(raw.structuredOutput, `${path}.structuredOutput`, false),
+        streaming: optionalBoolean(raw.streaming, `${path}.streaming`, false),
+        costClass: requireEnum(raw.costClass ?? "medium", `${path}.costClass`, [
+            "low",
+            "medium",
+            "high",
+        ]),
+        latencyClass: requireEnum(raw.latencyClass ?? "standard", `${path}.latencyClass`, ["fast", "standard", "slow"]),
+        throughputHint: optionalNonEmptyString(raw.throughputHint, `${path}.throughputHint`, "runtime-configured"),
+        preferredUseCases: optionalStringArray(raw.preferredUseCases, `${path}.preferredUseCases`, [
+            "Runtime-configured model",
+        ]),
+        knownLimitations: optionalStringArray(raw.knownLimitations, `${path}.knownLimitations`, [
+            "Capabilities are runtime-declared and should be verified in the target environment",
+        ]),
+    };
+}
+function resolveProviderConnection(raw, path, modelId, env) {
     const fileBaseUrl = typeof raw.baseUrl === "string" ? raw.baseUrl : "";
     const fileApiKey = typeof raw.apiKey === "string" ? raw.apiKey : "";
     const baseUrl = resolveSecret(modelId, fileBaseUrl, env, "BASE_URL");
@@ -89,6 +153,10 @@ function parseProvider(raw, index, env) {
         throw new ConfigInvalidError(`${path}.apiKey must be set via config or environment`);
     }
     validateBaseUrl(baseUrl, path);
+    return { baseUrl, apiKey };
+}
+function parseProviderConfig(raw, path, modelId, env) {
+    const { baseUrl, apiKey } = resolveProviderConnection(raw, path, modelId, env);
     return {
         modelId,
         baseUrl,
@@ -98,6 +166,18 @@ function parseProvider(raw, index, env) {
         retryBaseDelayMs: requirePositiveInt(raw.retryBaseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS, `${path}.retryBaseDelayMs`),
     };
 }
+function parseProvider(raw, index, env) {
+    const path = `providers[${String(index)}]`;
+    if (!isRecord(raw)) {
+        throw new ConfigInvalidError(`${path} must be an object`);
+    }
+    const modelId = requireNonEmptyString(raw.modelId, `${path}.modelId`);
+    const capability = parseProviderCapability(raw.capability, `${path}.capability`, modelId);
+    return {
+        provider: parseProviderConfig(raw, path, modelId, env),
+        ...(capability === undefined ? {} : { capability }),
+    };
+}
 function requireNonNegativeInt(value, path) {
     if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
         throw new ConfigInvalidError(`${path} must be a non-negative integer`);
@@ -120,8 +200,16 @@ export function parseGatewayConfig(raw, env = {}) {
     if (!Array.isArray(providersRaw) || providersRaw.length === 0) {
         throw new ConfigInvalidError("providers must be a non-empty array");
     }
-    const providers = providersRaw.map((item, index) => parseProvider(item, index, env));
-    return { providers, circuitBreaker: parseCircuitBreaker(raw.circuitBreaker) };
+    const parsed = providersRaw.map((item, index) => parseProvider(item, index, env));
+    const providers = parsed.map((item) => item.provider);
+    const capabilities = parsed
+        .map((item) => item.capability)
+        .filter((item) => item !== undefined);
+    return {
+        providers,
+        circuitBreaker: parseCircuitBreaker(raw.circuitBreaker),
+        ...(capabilities.length === 0 ? {} : { capabilities }),
+    };
 }
 export function loadConfigFromFile(path, env = {}) {
     let text;
@@ -150,5 +238,6 @@ export function toSafeObject(config) {
             retryBaseDelayMs: provider.retryBaseDelayMs,
         })),
         circuitBreaker: config.circuitBreaker,
+        ...(config.capabilities === undefined ? {} : { capabilities: config.capabilities }),
     };
 }

package/dist/gateway/gateway.js

@@ -3,8 +3,8 @@
 // (request id, latency, cost class) is owned by the gateway, not the provider, so
 // the audit ledger (issue #10) has a reliable typed target on every response.
 import { randomUUID } from "node:crypto";
-import { findCapability } from "./capabilities.js";
 import { UnknownModelError } from "./errors.js";
+import { findConfiguredCapability } from "./model-selection.js";
 import { OpenAiAdapter } from "./openai-adapter.js";
 import { CircuitBreaker, executeWithRetry, systemClock } from "./resilience.js";
 export class Gateway {
@@ -65,9 +65,9 @@ export class Gateway {
         if (provider === undefined) {
             throw new UnknownModelError(`no provider configured for model '${modelId}'`);
         }
-        const capability = findCapability(modelId);
+        const capability = findConfiguredCapability(this.config, modelId);
         if (capability === undefined) {
-            throw new UnknownModelError(`model '${modelId}' is not in the capability registry`);
+            throw new UnknownModelError(`model '${modelId}' has no capability metadata`);
         }
         if (capability.kind !== "chat") {
             throw new UnknownModelError(`model '${modelId}' has kind '${capability.kind}'; the chat path requires a chat model`);

package/dist/gateway/index.d.ts

@@ -1,9 +1,9 @@
 export type { CircuitBreakerConfig, CircuitBreakerStatus, CircuitState, ChatMessage, Clock, CostClass, FinishReason, GatewayConfig, GatewayRequest, LatencyClass, ModelCapability, ModelKind, ModelProviderConfig, NormalizedResponse, NormalizedToolCall, ProviderAdapter, ResponseFormat, StreamDelta, StreamEvent, ToolDefinition, UsageMetadata, } from "./types.js";
-export { CAPABILITY_REGISTRY, findCapability, listCapabilities, selectCheapest, type CapabilityQuery, } from "./capabilities.js";
+export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, selectCheapest, type CapabilityQuery, } from "./capabilities.js";
 export { loadConfigFromFile, parseGatewayConfig, toSafeObject, type EnvSource, type SafeGatewayConfig, type SafeProviderConfig, } from "./config.js";
 export { Gateway, type GatewayDeps } from "./gateway.js";
 export { OpenAiAdapter, type AdapterDeps } from "./openai-adapter.js";
-export { assertConfiguredModel, selectConfiguredModel, type ModelSelectionQuery, } from "./model-selection.js";
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, type ModelSelectionQuery, } from "./model-selection.js";
 export { CircuitBreaker, executeWithRetry, systemClock, type RetryConfig } from "./resilience.js";
 export { normalizeChatResponse, type UsageSeed } from "./normalize.js";
 export { redact } from "./redaction.js";

package/dist/gateway/index.js

@@ -1,10 +1,10 @@
 // Public barrel for the model gateway: all types, the Gateway orchestrator, the
 // capability registry helpers, config loaders, and the typed error taxonomy.
-export { CAPABILITY_REGISTRY, findCapability, listCapabilities, selectCheapest, } from "./capabilities.js";
+export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, selectCheapest, } from "./capabilities.js";
 export { loadConfigFromFile, parseGatewayConfig, toSafeObject, } from "./config.js";
 export { Gateway } from "./gateway.js";
 export { OpenAiAdapter } from "./openai-adapter.js";
-export { assertConfiguredModel, selectConfiguredModel, } from "./model-selection.js";
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "./model-selection.js";
 export { CircuitBreaker, executeWithRetry, systemClock } from "./resilience.js";
 export { normalizeChatResponse } from "./normalize.js";
 export { redact } from "./redaction.js";

package/dist/gateway/model-selection.d.ts

@@ -1,4 +1,4 @@
-import type { GatewayConfig, ModelKind } from "./types.js";
+import type { GatewayConfig, ModelCapability, ModelKind } from "./types.js";
 export interface ModelSelectionQuery {
     readonly kind: ModelKind;
     readonly toolCalling?: boolean | undefined;
@@ -6,4 +6,6 @@ export interface ModelSelectionQuery {
     readonly minContextWindow?: number | undefined;
 }
 export declare function assertConfiguredModel(config: GatewayConfig, modelId: string): void;
+export declare function findConfiguredCapability(config: GatewayConfig, modelId: string): ModelCapability | undefined;
+export declare function listConfiguredCapabilities(config: GatewayConfig): readonly ModelCapability[];
 export declare function selectConfiguredModel(config: GatewayConfig, query: ModelSelectionQuery): string | undefined;

package/dist/gateway/model-selection.js

@@ -1,4 +1,4 @@
-import { listCapabilities } from "./capabilities.js";
+import { createDefaultChatCapability, listCapabilities } from "./capabilities.js";
 import { ConfigInvalidError } from "./errors.js";
 const COST_RANK = { low: 0, medium: 1, high: 2 };
 function matches(capability, query) {
@@ -21,11 +21,22 @@ export function assertConfiguredModel(config, modelId) {
         throw new ConfigInvalidError(`model '${modelId}' is not configured as a provider`);
     }
 }
+export function findConfiguredCapability(config, modelId) {
+    return (config.capabilities?.find((capability) => capability.id === modelId) ??
+        listCapabilities().find((capability) => capability.id === modelId) ??
+        (config.providers.some((provider) => provider.modelId === modelId)
+            ? createDefaultChatCapability(modelId)
+            : undefined));
+}
+export function listConfiguredCapabilities(config) {
+    return config.providers
+        .map((provider) => findConfiguredCapability(config, provider.modelId))
+        .filter((capability) => capability !== undefined);
+}
 export function selectConfiguredModel(config, query) {
-    const configured = new Set(config.providers.map((provider) => provider.modelId));
     let best;
-    for (const capability of listCapabilities()) {
-        if (!configured.has(capability.id) || !matches(capability, query)) {
+    for (const capability of listConfiguredCapabilities(config)) {
+        if (!matches(capability, query)) {
             continue;
         }
         if (best === undefined || COST_RANK[capability.costClass] < COST_RANK[best.costClass]) {

package/dist/gateway/types.d.ts

@@ -31,6 +31,7 @@ export interface CircuitBreakerConfig {
 export interface GatewayConfig {
     readonly providers: readonly ModelProviderConfig[];
     readonly circuitBreaker: CircuitBreakerConfig;
+    readonly capabilities?: readonly ModelCapability[] | undefined;
 }
 export interface ChatMessage {
     readonly role: "system" | "user" | "assistant" | "tool";

package/dist/harness/session.d.ts

@@ -1,7 +1,7 @@
 import type { Clock } from "../gateway/types.js";
 import type { EventSink, Fingerprinter, IdSource, ModelPort, ToolPort } from "./ports.js";
 import { type HarnessLimits, type RunResult, type TaskInput } from "./types.js";
-export declare const HARNESS_VERSION = "0.1.0-beta.0";
+export declare const HARNESS_VERSION = "0.1.0-beta.2";
 export interface AgentConfig {
     readonly model: string;
     readonly workingDirectory: string;

package/dist/harness/session.js

@@ -10,7 +10,7 @@ import { runLoop } from "./loop.js";
 import { MemoryEventSink } from "./sinks.js";
 import { resolveTaskPlan } from "./tasks/policy.js";
 import { DEFAULT_LIMITS, } from "./types.js";
-export const HARNESS_VERSION = "0.1.0-beta.0";
+export const HARNESS_VERSION = "0.1.0-beta.2";
 function resolveLimits(config) {
     return { ...DEFAULT_LIMITS, ...config.limits };
 }

package/dist/sdk/index.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "0.1.0-beta.0";
+export declare const SDK_VERSION = "0.1.0-beta.2";
 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";

package/dist/sdk/index.js

@@ -1,5 +1,5 @@
 // Single-sourced package version; CLI and SDK both read this to avoid drift.
-export const SDK_VERSION = "0.1.0-beta.0";
+export const SDK_VERSION = "0.1.0-beta.2";
 // 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.

package/dist/tools/patch-normalize.js

@@ -8,8 +8,7 @@ function isBodyLine(line) {
     return marker === " " || marker === "+" || marker === "-";
 }
 function isFileHeaderPair(lines, index) {
-    return (lines[index]?.startsWith("--- ") === true &&
-        lines[index + 1]?.startsWith("+++ ") === true);
+    return lines[index]?.startsWith("--- ") === true && lines[index + 1]?.startsWith("+++ ") === true;
 }
 function hunkEnd(lines, start) {
     let index = start;

package/dist/tools/terminal-policy.js

@@ -42,14 +42,7 @@ export const TERMINAL_COMMAND_RULES = Object.freeze([
     {
         executable: "npm",
         allowedSubcommands: Object.freeze(["ls", "list", "help"]),
-        denyFlags: Object.freeze([
-            "-c",
-            "--call",
-            "--prefix",
-            "--global",
-            "-g",
-            "--location",
-        ]),
+        denyFlags: Object.freeze(["-c", "--call", "--prefix", "--global", "-g", "--location"]),
     },
     {
         executable: "git",