@mikode13/harness 0.1.0

package/LICENSE

@@ -0,0 +1,44 @@
+"Commons Clause" License Condition v1.0
+
+The Software is provided to you by the Licensor under the License, as defined below,
+subject to the following condition.
+
+Without limiting other conditions in the License, the grant of rights under the License
+will not include, and the License does not grant to you, the right to Sell the Software.
+
+For purposes of the foregoing, "Sell" means practicing any or all of the rights granted
+to you under the License to provide to third parties, for a fee or other consideration
+(including without limitation fees for hosting or consulting/support services related
+to the Software), a product or service whose value derives, entirely or substantially,
+from the functionality of the Software.
+
+Any license notice or attribution required by the License must also include this
+Commons Clause License Condition notice.
+
+Software: @mikode13/harness
+License: MIT License
+Licensor: MiKode13
+
+MIT License
+
+Copyright (c) 2026 MiKode13
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the Commons Clause License Condition above
+and the following conditions:
+
+The above copyright notice, this permission notice, and the Commons Clause
+License Condition notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @mikode13/harness
+
+A small, hand-built agent harness in TypeScript. It coordinates OpenAI Codex and
+Claude Agent SDK instances — as a single terminal chat, or as a multi-agent
+plan → execute → review workflow — and is growing into the runtime that
+coordinates specialized agents across MiKode projects.
+
+## Motivation
+
+This project exists for three reasons, in this order:
+
+1. **Learning.** Understand how agent SDKs work internally — the agent loop,
+   messages, tool calls, cancellation, context continuity, and multi-agent
+   coordination — by building the fundamental parts personally instead of
+   consuming a framework. No LangGraph, no OpenAI Agents SDK as the engine;
+   those come later as comparison points, not as foundations.
+2. **A reusable base.** The harness is the substrate for a future chatbot and
+   for MiKode tooling: routing, typed tools, specialized agents, memory, and
+   validation layers will be added on top of it once real consumers need them.
+3. **Defining how AI works inside MiKode.** Standards, explicit per-agent
+   responsibilities and tools, traceability, and reproducible runs — following
+   the conventions of the `mikode-engineering` repository.
+
+The project advances in small vertical slices: each abstraction must be justified
+by a real problem before it is introduced, and no public API is stabilized until
+there is at least one real consumer.
+
+## What it does today
+
+An interactive terminal chat, backed by one `Agent` — a single engine, or a full
+multi-agent workflow, chosen entirely by what gets wired up in `cli/cli.ts`; the
+chat loop itself never knows the difference.
+
+- **A provider-agnostic `Agent` contract** (`run(prompt, signal, callback)`) with
+  two real implementations, `CodexAgent` and `ClaudeAgent` — swapping one for the
+  other, anywhere in the composition, changes nothing else.
+- **Conversation continuity for free** in both engines: Codex reuses one `Thread`
+  across turns; Claude resumes via a captured `session_id` — the engine keeps
+  context server-side either way.
+- **`OrchestratorAgent`**: coordinates a planner, an executor, and a reviewer
+  (each an injected `Agent`) in a plan → execute → review loop. The reviewer's
+  decision is a Zod-validated structured `{decision, feedback}`, not free text —
+  a rejected or malformed decision retries with the reason fed back, bounded by
+  `maxAttempts`, converting to `UnrecoverableError` only once exhausted. A
+  malformed reviewer response retries only the reviewer call, not the whole
+  cycle. Because it implements `Agent` itself, the chat loop drives it exactly
+  like it drives a bare engine.
+- **Live progress streaming**: every engine reports ongoing activity (tool
+  calls, searches, file changes, reasoning) through a typed `ProgressEvent`
+  callback, separate from the final response — so an agent's own words never
+  get mixed with narration of what it did to produce them, and a caller (the
+  CLI today, a future web UI) decides how to render it.
+- **Retry policy** (`RetryingAgent`) wraps individual agents, not whole
+  workflows — a transient failure in one sub-agent is absorbed locally, without
+  redoing another sub-agent's already-successful work.
+- Cancellation with `AbortController`/`AbortSignal`, shared between the prompt
+  and every agent call, all the way down through the orchestrator.
+
+## Where it is going
+
+Remaining work (see `tasks.txt` for the actionable, dated list):
+
+- Live streaming already ships; still open: type-while-thinking (respond to
+  new input without blocking on the current agent call), session persistence
+  across process restarts, and structured per-turn usage/duration logging.
+- Terminal UX polish (bordered chat box, markdown rendering, user-friendly
+  error messages) — explicitly deferred until the above is solid.
+- Dynamic routing (deciding which flow/agent a request needs, instead of
+  always running the fixed plan → execute → review workflow) — deliberately
+  built _after_ that fixed flow, not alongside it, so the routing decision
+  reuses a technique already proven on a simpler problem.
+
+Deliberately out of scope for now: MCP, long-term memory, graph execution, and
+file-based agent registries — each waits for a real need.
+
+## Adding an engine
+
+A new provider only needs one thing to compose safely into everything above:
+**it must only ever reject with `RecoverableError` or `UnrecoverableError`**
+(`src/agent/domain/errors.ts`), never a raw SDK error. `RetryingAgent` and
+`OrchestratorAgent` both decide what to do next by `instanceof`-checking
+against those two types; anything else leaking through is treated as
+unrecoverable and ends the run, because nothing above the adapter can tell
+whether replaying it is safe. Wrap every call into the underlying SDK,
+including failures the SDK itself doesn't model as a domain error (network
+errors, malformed responses): `classifyProviderFailure` covers a single call,
+`classifiedProviderStream` covers an SDK stream. Both are deliberately narrow —
+the classification must not span your own item mapping, logging, or the
+consumer callback, or a failure in the host is reported as a provider failure
+and gets retried. Those host failures are instead classified as unrecoverable,
+because the provider turn may already have produced side effects. See the doc
+comment on `Agent` in `src/agent/domain/agent.ts`.
+
+## Install
+
+```sh
+pnpm add @mikode13/harness
+```
+
+An agent is composed, then driven; the package brings no I/O of its own:
+
+```ts
+import {
+	ClaudeAgent,
+	RetryingAgent,
+	UnrecoverableError,
+	type ProgressEvent,
+} from '@mikode13/harness';
+
+const agent = new RetryingAgent(new ClaudeAgent('sonnet'));
+const controller = new AbortController();
+
+const render = (event: ProgressEvent) => {
+	if (event.type === 'agentMessage') process.stdout.write(event.message);
+};
+
+try {
+	const result = await agent.run('Summarize this repository.', controller.signal, render);
+	console.log(result?.duration, result?.inputTokens, result?.outputTokens);
+} catch (error) {
+	if (error instanceof UnrecoverableError) console.error(error.message, error.cause);
+}
+```
+
+`ProgressEvent` is the public seam for live activity; rendering it is the
+consumer's decision, not the harness's. `cli/progressEventFormatter.ts` is one
+terminal-shaped implementation to copy from. Swapping `ClaudeAgent` for
+`CodexAgent`, or for an `OrchestratorAgent` wrapping all three roles, changes
+nothing else in the snippet above.
+
+## Tests
+
+`pnpm test` runs the unit suite against deterministic fakes; it never contacts a
+real provider. Provider-boundary correctness (SDK auth, request shape, model
+availability) is not covered by an automated suite here — it surfaces through
+actual usage and monitoring, not by scheduling calls to a live SDK on a timer.
+
+## Local development smoke test
+
+`cli/` is a separate, unpublished workspace project — a development-only harness
+runner (own `package.json`, not part of the `@mikode13/harness` package) that
+exists solely to exercise the library manually while working in this repository:
+
+```sh
+pnpm run dev
+```
+
+Type your prompt at `>`. Press Ctrl+C while idle at the prompt to exit; pressing
+it while an agent is running cancels only that turn and returns to the prompt.
+
+`cli/cli.ts` currently enables `autoApprove` for its trusted backend agents.
+This maps to each provider's permission-bypass mode and grants those processes
+unrestricted command access. Keep it disabled when the host may receive untrusted
+prompts, or provide an approval workflow from the entry point.
+
+Real consumers (a future REST/WebSocket server, a chatbot UI) compose the
+exported `Agent`, `OrchestratorAgent`, and other harness building blocks with
+their own I/O and `ILogger` adapter. `ConversationLoop`/`IPromptEmitter` are not
+part of the published package — they encode one specific interactive,
+turn-by-turn consumption pattern (see `cli/`), not the harness seam itself; a
+consumer that wants that same loop can use `cli/`'s implementation as a
+reference rather than depend on it as a library.
+
+## License
+
+This project is source-available under the MIT License with the
+[Commons Clause License Condition v1.0](https://commonsclause.com/). See
+[LICENSE](./LICENSE) for the complete text. It is not OSI open source: the Commons
+Clause restricts selling the software or a service whose value derives substantially
+from it.

package/dist/agent/domain/agent.d.ts

@@ -0,0 +1,63 @@
+export interface AgentResponse {
+    response: string;
+    inputTokens: number;
+    outputTokens: number;
+    duration: number;
+}
+export type Callback = (item: ProgressEvent) => void;
+export type ProgressEvent = {
+    type: 'command';
+    command: string;
+    exitCode?: number;
+} | {
+    type: 'reasoning';
+    message: string;
+} | {
+    type: 'search';
+    query: string;
+} | {
+    type: 'fileChange';
+    changes: {
+        path: string;
+        kind: 'add' | 'update' | 'delete';
+    }[];
+} | {
+    type: 'mcpTool';
+    server: string;
+    tool: string;
+    status: string;
+} | {
+    type: 'agentMessage';
+    message: string;
+} | {
+    type: 'todoList';
+    items: {
+        text: string;
+        completed: boolean;
+    }[];
+} | {
+    type: 'turnStarted';
+} | {
+    type: 'turnEnded';
+};
+/**
+ * The contract every engine (CodexAgent, ClaudeAgent, future providers) and every
+ * decorator (RetryingAgent, OrchestratorAgent) is built against.
+ *
+ * Implementers MUST only ever reject with `RecoverableError` or `UnrecoverableError`
+ * (see ./errors.ts) — never a raw SDK error, a plain `Error`, or anything else leaked
+ * unclassified. Every consumer of `Agent` (RetryingAgent's retry decision,
+ * OrchestratorAgent's failure handling) `instanceof`-checks against those two types to
+ * decide what to do next; a leaked, unclassified error bypasses that decision
+ * entirely — it gets retried when it shouldn't be, or crashes a run that a retry
+ * would have recovered. Wrap every call into the underlying SDK so nothing escapes
+ * unclassified, including failures the SDK itself doesn't model as a domain error
+ * (network errors, malformed responses, etc.); `classifyProviderFailure` does this.
+ *
+ * Cancellation is the one exception: an `AbortError` must propagate unchanged, because
+ * consumers check for it before either error type.
+ */
+export interface Agent {
+    run(prompt: string, signal: AbortSignal, callback: Callback): Promise<AgentResponse | undefined>;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent/domain/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/agent/domain/agent.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,aAAa;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IAErB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;AAErD,MAAM,MAAM,aAAa,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;KAAE,EAAE,CAAA;CAAE,GACtF;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAK;IACrB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;CACjG"}

package/dist/agent/domain/agent.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent.js.map

package/dist/agent/domain/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../src/agent/domain/agent.ts"],"names":[],"mappings":""}

package/dist/agent/domain/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class RecoverableError extends Error {
+    cause: string;
+    constructor(message: string, options: {
+        cause: string;
+    });
+}
+export declare class UnrecoverableError extends Error {
+    cause: string;
+    constructor(message: string, options: {
+        cause: string;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/agent/domain/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/agent/domain/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAiB,SAAQ,KAAK;IACjC,KAAK,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE;CAIvD;AACD,qBAAa,kBAAmB,SAAQ,KAAK;IACnC,KAAK,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE;CAIvD"}

package/dist/agent/domain/errors.js

@@ -0,0 +1,15 @@
+export class RecoverableError extends Error {
+    cause;
+    constructor(message, options) {
+        super(message, options);
+        this.cause = options.cause;
+    }
+}
+export class UnrecoverableError extends Error {
+    cause;
+    constructor(message, options) {
+        super(message, options);
+        this.cause = options.cause;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/agent/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/agent/domain/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IACjC,KAAK,CAAS;IAEvB,YAAY,OAAe,EAAE,OAA0B;QACtD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC5B,CAAC;CACD;AACD,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IACnC,KAAK,CAAS;IAEvB,YAAY,OAAe,EAAE,OAA0B;QACtD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC5B,CAAC;CACD"}

package/dist/agent/domain/providerFailure.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Unclassified failures are transport-shaped, so recoverable is the useful default:
+ * `RetryingAgent` turns a persistent one into an `UnrecoverableError` on exhaustion, while
+ * the opposite default would make every transient blip fatal.
+ */
+export declare function classifyProviderFailure(error: unknown, context: string): Error;
+/** A host failure cannot be retried safely because the provider turn may already have side effects. */
+export declare function classifyHostFailure(error: unknown, context: string): Error;
+/** Preserves deliberate domain errors while making unexpected local failures fatal. */
+export declare function classifyLocalFailure(error: unknown, context: string): Error;
+/** The message alone: a stack or serialized object could expose unstable implementation details. */
+export declare function describeFailure(error: unknown): string;
+/**
+ * Classifies the stream itself and nothing else. Consuming an SDK stream inside a
+ * `try/catch` puts the loop body — item mapping, logging, the consumer callback — inside
+ * the provider boundary too, so a host failure gets reported as a recoverable provider
+ * failure and `RetryingAgent` replays a turn that already ran its side effects.
+ */
+export declare function classifiedProviderStream<T>(stream: AsyncIterable<T>, context: string): AsyncGenerator<T>;
+//# sourceMappingURL=providerFailure.d.ts.map

package/dist/agent/domain/providerFailure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providerFailure.d.ts","sourceRoot":"","sources":["../../../src/agent/domain/providerFailure.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAK9E;AAED,uGAAuG;AACvG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAK1E;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAK3E;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMtD;AAED;;;;;GAKG;AACH,wBAAuB,wBAAwB,CAAC,CAAC,EAChD,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,MAAM,GACb,cAAc,CAAC,CAAC,CAAC,CAsCnB"}

package/dist/agent/domain/providerFailure.js

@@ -0,0 +1,84 @@
+import { isAbortError } from "../../shared/domain/isAbortError.js";
+import { RecoverableError, UnrecoverableError } from "./errors.js";
+/**
+ * Unclassified failures are transport-shaped, so recoverable is the useful default:
+ * `RetryingAgent` turns a persistent one into an `UnrecoverableError` on exhaustion, while
+ * the opposite default would make every transient blip fatal.
+ */
+export function classifyProviderFailure(error, context) {
+    if (isAbortError(error))
+        return error;
+    if (error instanceof RecoverableError || error instanceof UnrecoverableError)
+        return error;
+    return new RecoverableError(context, { cause: describeFailure(error) });
+}
+/** A host failure cannot be retried safely because the provider turn may already have side effects. */
+export function classifyHostFailure(error, context) {
+    if (isAbortError(error))
+        return error;
+    if (error instanceof UnrecoverableError)
+        return error;
+    return new UnrecoverableError(context, { cause: describeFailure(error) });
+}
+/** Preserves deliberate domain errors while making unexpected local failures fatal. */
+export function classifyLocalFailure(error, context) {
+    if (isAbortError(error))
+        return error;
+    if (error instanceof RecoverableError || error instanceof UnrecoverableError)
+        return error;
+    return new UnrecoverableError(context, { cause: describeFailure(error) });
+}
+/** The message alone: a stack or serialized object could expose unstable implementation details. */
+export function describeFailure(error) {
+    if (error instanceof RecoverableError || error instanceof UnrecoverableError)
+        return error.cause;
+    if (error instanceof Error && error.message)
+        return error.message;
+    if (typeof error === 'string' && error)
+        return error;
+    return 'The provider failed without a description.';
+}
+/**
+ * Classifies the stream itself and nothing else. Consuming an SDK stream inside a
+ * `try/catch` puts the loop body — item mapping, logging, the consumer callback — inside
+ * the provider boundary too, so a host failure gets reported as a recoverable provider
+ * failure and `RetryingAgent` replays a turn that already ran its side effects.
+ */
+export async function* classifiedProviderStream(stream, context) {
+    let events;
+    try {
+        events = stream[Symbol.asyncIterator]();
+    }
+    catch (error) {
+        throw classifyProviderFailure(error, context);
+    }
+    let completed = false;
+    try {
+        for (;;) {
+            let next;
+            try {
+                next = await events.next();
+            }
+            catch (error) {
+                throw classifyProviderFailure(error, context);
+            }
+            if (next.done) {
+                completed = true;
+                return;
+            }
+            yield next.value;
+        }
+    }
+    finally {
+        if (!completed) {
+            try {
+                await events.return?.();
+            }
+            catch {
+                // Cleanup is secondary to the failure that interrupted consumption. It must
+                // never replace a classified provider error or an unrecoverable host error.
+            }
+        }
+    }
+}
+//# sourceMappingURL=providerFailure.js.map

package/dist/agent/domain/providerFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providerFailure.js","sourceRoot":"","sources":["../../../src/agent/domain/providerFailure.ts"],"names":[],"mappings":"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"}

package/dist/engines/claude/infrastructure/model/claudeAgent.d.ts

@@ -0,0 +1,17 @@
+import type { EffortLevel } from '@anthropic-ai/claude-agent-sdk';
+import type { Agent, AgentResponse, Callback } from '../../../../agent/domain/agent.ts';
+type Model = 'sonnet' | 'opus' | 'haiku' | 'claude-fable-5';
+export declare class ClaudeAgent implements Agent {
+    private model;
+    private autoApprove;
+    private reasoningEffort;
+    private sessionId?;
+    constructor(model: Model, autoApprove?: boolean, reasoningEffort?: EffortLevel);
+    run(prompt: string, signal: AbortSignal, callback: Callback): Promise<AgentResponse | undefined>;
+    private parseResponse;
+    private handleAssistantMessage;
+    private handleUserMessage;
+    private handleCompletedTool;
+}
+export {};
+//# sourceMappingURL=claudeAgent.d.ts.map

package/dist/engines/claude/infrastructure/model/claudeAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAgent.d.ts","sourceRoot":"","sources":["../../../../../src/engines/claude/infrastructure/model/claudeAgent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,WAAW,EAKX,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACX,KAAK,EACL,aAAa,EACb,QAAQ,EAER,MAAM,mCAAmC,CAAC;AAS3C,KAAK,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,CAAC;AA2H5D,qBAAa,WAAY,YAAW,KAAK;IACxC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,SAAS,CAAC,CAAS;gBAEf,KAAK,EAAE,KAAK,EAAE,WAAW,UAAQ,EAAE,eAAe,GAAE,WAAoB;IAM9E,GAAG,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;YA+BvB,aAAa;IAiD3B,OAAO,CAAC,sBAAsB;IAsC9B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,mBAAmB;CAmB3B"}