@skillstate/claude 2.0.5 → 2.0.7

package/README.md

@@ -2,11 +2,10 @@
 
 # @skillstate/claude
 
-**Claude Code platform adapter for the @skillstate/core runtime — state injection and persistence via hook scripts.**
+**Claude Code platform adapter for the @skillstate/core runtime — state injection and patch persistence via hook scripts (2.1.260 hooks contract).**
 
 [![npm version](https://img.shields.io/npm/v/@skillstate/claude)](https://www.npmjs.com/package/@skillstate/claude)
 [![node](https://img.shields.io/node/v/@skillstate/claude)](https://www.npmjs.com/package/@skillstate/claude)
-[![Tests](https://img.shields.io/badge/tests-873%20passing-brightgreen)](https://github.com/vitalykuzyaev/skillstate)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/vitalykuzyaev/skillstate/blob/main/LICENSE)
 
 </div>
@@ -15,16 +14,40 @@
 
 `@skillstate/claude` bridges the paper-exact core ([`@skillstate/core`](../core))
 into **Claude Code** sessions. It emits self-contained CommonJS hook scripts
-(run via `node script.cjs`) that inject the persisted skill state into tool
-context and extract a validated `state_patch` from the model's response.
+(run via `node script.cjs`) that inject the persisted skill state into every
+turn, re-inject it after compaction, and merge a validated `state_patch` from
+Bash tool responses back into the state file.
 
 > **@non-paper** — no adapters exist in arXiv 2608.26263v3. This adapter is an
 > additive integration, not part of the paper.
 
+## The honest architecture (Claude Code 2.1.260)
+
+**History trimming from hooks is impossible.** The compaction-time hook cannot
+inject context (its only decision is `decision: "block"` — forbid compaction),
+and the post-compaction hook has no decision control at all (its
+`systemMessage` is discarded). So this adapter implements the state-injection
+model, not a trim model:
+
+| Event | Matcher | What the script does |
+| --- | --- | --- |
+| `UserPromptSubmit` | — (no matcher support) | Injects `Current skill state (JSON): {...}` as `additionalContext` — the model gets the authoritative state at every turn. |
+| `SessionStart` | `^compact$` | Re-injects the state right after auto/manual compaction — state SURVIVES compaction even though history was compressed. |
+| `PostToolUse` | `^Bash$` | Extracts a fenced ```json `state_patch` from the tool response (or a raw JSON / object `tool_response.state_patch`), applies the paper's ⊕ null-deletion merge, and writes `{ version: 1, state }`. stdout is `{}` or a `systemMessage` when the patch is invalid. |
+
+Reading and writing the full state is available at any time through the
+skillstate MCP server (`state.get` / `state.patch` — schema-validated) that
+`skillstate init` registers in the project's `.mcp.json`.
+
+Prompts stay O(T) with a fresh state at every turn. **True O(1) requires
+host-side trimming, which Claude Code does not expose.**
+
 ## Installation
 
 ```bash
 npm i @skillstate/core @skillstate/claude
+# or wire everything into a live host at once:
+skillstate init   # writes scripts, merges ~/.claude/settings.json, adds .mcp.json + SKILL.md
 ```
 
 Requires Node.js >= 20. TypeScript types are bundled.
@@ -37,66 +60,75 @@ import { INTERCODE_CTF_SPEC } from '@skillstate/core/schemas';
 
 const adapter = new ClaudeAdapter();
 
-// System-prompt boilerplate that turns any Claude Code session into
-// state-based execution mode:
-const modePrompt = adapter.generateAppendPrompt();
-
-// PreToolUse: injects the persisted state into the tool call's additionalContext.
-const pre = adapter.generateHookScript('PreToolUse', './.skillstate.json');
-
-// PostToolUse: extracts state_patch from the response, validates it against the
-// embedded schema, applies the null-deletion ⊕ merge, and saves the state file.
-const post = adapter.generateHookScript(
-  'PostToolUse',
-  './.skillstate.json',
-  INTERCODE_CTF_SPEC.schema,
-);
-
-// PreCompact + SessionStart(compact): the best available O(1)-friendly pair.
-const hooks = adapter.generateAllHooksScripts('./.skillstate.json', INTERCODE_CTF_SPEC.schema);
-// hooks.preCompact       -> injects state + diff into compaction summary
-// hooks.sessionStartCompact -> re-injects state after compaction
-
-// Persist a hook script to disk (atomic tmp + fsync + rename), returns path:
-const saved = await adapter.saveHookScript(
-  './hooks/post-tool-use.cjs',
-  'PostToolUse',
-  './.skillstate.json',
-  INTERCODE_CTF_SPEC.schema,
-);
+// Self-contained hook scripts (Node builtins only). Each resolves the
+// per-project state from input.cwd at runtime — one global script dir
+// serves every project:
+const inject = adapter.generateHookScript('user-prompt-submit');
+const survive = adapter.generateHookScript('session-start-compact');
+const persist = adapter.generateHookScript('post-tool-use');
+
+// The hooks section for ~/.claude/settings.json (2.1.260 schema:
+// { hooks: { Event: [ { matcher?, hooks: [ { type: "command", command, timeout } ] } ] } }):
+const hooksJson = adapter.generateHooksConfig('./.skillstate/skillstate.json', {
+  scriptDir: '/home/me/.claude/hooks/skillstate',
+});
+
+// Merge into a live settings.json — preserves env/permissions/model and
+// every foreign hook; byte-identical (no-op) when already wired:
+const merged = adapter.mergeHooksConfig(existingSettingsText, {
+  scriptDir: '/home/me/.claude/hooks/skillstate',
+});
+
+// Uninstall surgery: remove exactly the skillstate groups/handlers from a
+// live settings.json (mixed groups keep their foreign handlers):
+const { text, changed } = removeSkillstateHookGroups(liveSettingsText);
+
+// Atomic persistence helpers (tmp + fsync + rename):
+await adapter.saveHookScript('post-tool-use', '/h/skillstate/post-tool-use.cjs');
+await adapter.saveSkillMd('/home/me/.claude/skills/skillstate/SKILL.md', spec);
 ```
 
 ## API / Exports
 
-Root path `@skillstate/claude` exports one thing: `ClaudeAdapter`.
-
-- `new ClaudeAdapter()` — implements `PlatformAdapter` (`name = 'claude'`).
-- `generateHookScript(eventType, statePath, schema?): string` — where
-  `eventType` is `'PreToolUse' | 'PostToolUse'`. Accepts a raw path or a
-  `{ root, name }` ref confined by `resolveStatePath` (`..` escapes throw).
-- `generateCompactHookScript(statePath, schema?): string` — PreCompact script
-  injecting the current state + a diff since the last compact snapshot.
-- `generateSessionStartHookScript(statePath): string` — SessionStart hook with
-  a `source: "compact"` matcher.
-- `generateAllHooksScripts(statePath, schema?): { preCompact; sessionStartCompact }`.
+Root path `@skillstate/claude` exports:
+
+- `new ClaudeAdapter()` — implements `PlatformAdapter` (`name = 'claude'`):
+  `injectState`, `extractPatch`, `extractAction`, `formatPrompt`.
+- `generateHookScript(event, statePath?): string` — `event` is
+  `'user-prompt-submit' | 'session-start-compact' | 'post-tool-use'`.
+  Accepts a raw path or a `{ root, name }` ref confined by
+  `resolveStatePath` (`..` escapes throw). The path only documents the
+  header — the script resolves the state from the session cwd.
+- `generateHooksConfig(statePath?, options?): string` — JSON with ONLY the
+  `hooks` section. Options: `scriptDir`, `command`, `timeoutSeconds`
+  (default 30).
+- `mergeHooksConfig(existingJson, options?): string` — idempotent merge into
+  a live settings.json; preserves every other key.
+- `removeSkillstateHookGroups(existingJson): { text, changed }` — surgical
+  uninstall (pure groups dropped, mixed groups trimmed, empty events
+  removed).
+- `claudeHookScriptPath(scriptDir, event): string`.
+- `generateSkillMd(spec, statePath?): string` + `saveSkillMd`,
+  `saveHookScript(event, target, statePath?)`, `saveHooksConfig(target,
+  statePath?, options?)` — atomic writes.
 - `generateAppendPrompt(): string` — mode-switch prompt boilerplate.
-- `injectState(state, spec): string` / `formatPrompt(state, observation, spec): string`.
-- `extractPatch(response): StatePatch | null` / `extractAction(response): string | null`.
-- `saveHookScript(target, eventType, statePath, schema?): Promise<string>` —
-  generates a hook script and persists it atomically; returns the destination.
+- `CLAUDE_HOOK_EVENTS`, `CLAUDE_SESSION_START_MATCHER` (`^compact$`),
+  `CLAUDE_POST_TOOL_USE_MATCHER` (`^Bash$`), `CLAUDE_HOOK_TIMEOUT_SECONDS`.
+- `resolveStateForCwd(cwd, home?)` — re-export of the core
+  `resolveHostStateForCwd` (single source of truth for the per-project
+  resolver).
 
 ## Notes
 
-- **Honest limitation.** Claude Code hooks are **append-only** — history cannot
-  be trimmed from hooks, so true O(1) is not possible. The hooks inject state
-  into the compaction summary (PreCompact) and re-inject it after compaction
-  (SessionStart), but the conversation history keeps growing until the host
-  trims it.
-- The generated scripts are self-contained CommonJS and embed the schema, so
-  unknown keys / wrong types are rejected and **malformed outputs are never
-  persisted** — state corruption by a bad patch is impossible.
-- Depends on [`@skillstate/core`](../core) for the ⊕ merge semantics
-  (`mergeState`), `PromptTransformer`, `atomicWriteFile`, and `resolveStatePath`.
+- **Honest limitation.** Claude Code hooks cannot trim history and cannot
+  inject context at compaction time, so prompts are O(T) with fresh state
+  per turn. The injected state is authoritative — history is not.
+- The generated scripts are self-contained CommonJS. Malformed patches are
+  never persisted — the ⊕ merge either fully applies or the hook reports a
+  `systemMessage` and leaves the state file untouched.
+- Depends on [`@skillstate/core`](../core) for `PromptTransformer`,
+  `atomicWriteFile`, `resolveStatePath`, and the shared
+  `resolveHostStateForCwd`.
 
 ## Related
 

package/dist/claude-adapter.d.ts

@@ -1,17 +1,37 @@
-/**
- * @non-paper adapter — no adapters exist in arXiv 2608.26263v3.
- *
- * This file bridges the paper-exact core (Algorithm 1 prompt, ⊕ merge,
- * §7 rollback-retry rejection) into Claude Code sessions via hook scripts
- * and prompt boilerplate.
- *
- * LIMITATION: Claude Code hooks are append-only — history cannot be trimmed
- * from hooks. The best strategy is: PreCompact injects state into the
- * compaction summary, SessionStart(source:compact) re-injects state after
- * compaction. True O(1) is not possible without host-side trimming.
- */
 import type { SkillState, StatePatch, ProceduralSpec, Observation, PlatformAdapter } from '@skillstate/core';
 import type { StatePathRef } from '@skillstate/core';
+export { resolveHostStateForCwd as resolveStateForCwd } from '@skillstate/core';
+/** Claude Code hook events this adapter generates scripts for (script/CLI names). */
+export type ClaudeHookEvent = 'user-prompt-submit' | 'session-start-compact' | 'post-tool-use';
+/** All {@link ClaudeHookEvent} values in generation order. */
+export declare const CLAUDE_HOOK_EVENTS: readonly ["user-prompt-submit", "session-start-compact", "post-tool-use"];
+/** SessionStart matcher that fires after Claude Code compacts the conversation. */
+export declare const CLAUDE_SESSION_START_MATCHER = "^compact$";
+/** PostToolUse matcher restricted to Bash tool results. */
+export declare const CLAUDE_POST_TOOL_USE_MATCHER = "^Bash$";
+/**
+ * Hook `timeout` in seconds written into every generated hook entry — the
+ * UserPromptSubmit default, spelled out so the budget is explicit.
+ */
+export declare const CLAUDE_HOOK_TIMEOUT_SECONDS = 30;
+/** Options for {@link ClaudeAdapter.generateHooksConfig} / merge. */
+export interface ClaudeHooksConfigOptions {
+    /**
+     * Directory holding the generated `.cjs` hook scripts. Defaults to the
+     * state file's directory when a `statePath` is given, else a
+     * `<stateDir>/hooks` placeholder; the CLI install passes
+     * `~/.claude/hooks/skillstate`.
+     */
+    scriptDir?: string;
+    /** Full command override for every event (defaults to `node <script> <event>`). */
+    command?: string;
+    /** Hook `timeout` in seconds (default {@link CLAUDE_HOOK_TIMEOUT_SECONDS}). */
+    timeoutSeconds?: number;
+}
+/**
+ * Claude Code platform adapter (@non-paper; see module doc for the 2.1.260
+ * hooks contract and the honest O(T) limitation).
+ */
 export declare class ClaudeAdapter implements PlatformAdapter {
     readonly name = "claude";
     private transformer;
@@ -19,59 +39,120 @@ export declare class ClaudeAdapter implements PlatformAdapter {
     extractPatch(response: string): StatePatch | null;
     extractAction(response: string): string | null;
     /**
-     * @non-paper — adapter convenience (delegates to the transformer).
+     * @non-paper adapter convenience (delegates to the transformer).
      * Paper-exact callers use `PromptTransformer.formatPaper` (Appendix A.4).
      */
     formatPrompt(state: SkillState, observation: Observation, spec: ProceduralSpec): string;
-    generateHookScript(eventType: 'PreToolUse' | 'PostToolUse', statePath: string, schema?: ProceduralSpec['schema']): string;
     /**
-     * @non-paper additive overload: accept a `{ root, name }` ref confined
-     * via `resolveStatePath` — `..` escapes throw instead of embedding an
-     * unsafe path into the generated script. The string overload above is
-     * byte-identical to the pre-wave-2 codegen.
+     * Canonical absolute path of the hook script for `event` inside
+     * `scriptDir` (e.g. `~/.claude/hooks/skillstate/user-prompt-submit.cjs`).
+     * {@link generateHooksConfig} and {@link saveHookScript} share this
+     * convention so the settings.json commands and the on-disk scripts agree.
      */
-    generateHookScript(eventType: 'PreToolUse' | 'PostToolUse', stateRef: StatePathRef, schema?: ProceduralSpec['schema']): string;
+    claudeHookScriptPath(scriptDir: string, event: ClaudeHookEvent): string;
     /**
-     * @non-paper additive helper: generate a hook script and persist it via
-     * `atomicWriteFile` (tmp + fsync + rename). Both the destination and the
-     * embedded state path accept raw strings or
-     * `{ root, name }` refs confined by `resolveStatePath`. Returns the
-     * absolute destination path.
+     * Generate the hooks section for `~/.claude/settings.json` (2.1.260
+     * schema: `{ hooks: { Event: [ { matcher?, hooks: [ { type: "command",
+     * command, timeout } ] } ] } }`). The document carries ONLY the
+     * `hooks` key — {@link mergeHooksConfig} is what splices these groups
+     * into a live settings.json while preserving every other key:
+     *
+     * - `UserPromptSubmit` → inject the current state as additionalContext;
+     * - `SessionStart` (matcher `^compact$`) → re-inject after compaction;
+     * - `PostToolUse` (matcher `^Bash$`) → persist `state_patch` blocks from
+     *   Bash tool outputs.
+     *
+     * Commands are absolute `node <script> <event>` lines pointing at the
+     * generated `.cjs` scripts in `options.scriptDir` (default: the state
+     * file's directory, else a `<stateDir>/hooks` placeholder). No matcher
+     * on UserPromptSubmit — the event has no matcher support and fires on
+     * every prompt.
      */
-    saveHookScript(target: string | StatePathRef, eventType: 'PreToolUse' | 'PostToolUse', statePath: string | StatePathRef, schema?: ProceduralSpec['schema']): Promise<string>;
+    generateHooksConfig(statePath?: string | StatePathRef, options?: ClaudeHooksConfigOptions): string;
     /**
-     * Generate a PreCompact hook script that injects the current skill state
-     * into the compaction summary. Also tracks what changed since the last
-     * compact to provide a diff in additionalContext.
+     * Generate a self-contained CommonJS hook script for a Claude Code
+     * lifecycle event. The script reads ONE hook JSON document from stdin,
+     * resolves the state file from `input.cwd` (the session cwd) via the
+     * {@link resolveStateForCwd} semantics, and:
+     *
+     * - `user-prompt-submit`: emits
+     *   `{ hookSpecificOutput: { hookEventName: "UserPromptSubmit",
+     *   additionalContext } }` carrying the current state JSON;
+     * - `session-start-compact`: the same injection with
+     *   `hookEventName: "SessionStart"` (state survives compaction; wire
+     *   with the `^compact$` matcher);
+     * - `post-tool-use`: extracts a `state_patch` from the tool_response
+     *   (fenced ```json block or raw JSON), applies the ⊕ null-deletion merge
+     *   and writes the state file; stdout is `{}` or a `systemMessage` when
+     *   the patch is invalid.
      *
-     * The script reads `.skillstate.json`, reads the previous compact snapshot
-     * from `.skillstate.last-compact.json` (if it exists), computes a diff,
-     * and injects the current state + diff into additionalContext. After
-     * injection it saves the current state as the new compact snapshot.
+     * `statePath` is accepted for `{ root, name }` confinement (traversal
+     * refs throw) and documented in the script header; the content itself is
+     * cwd-resolving and never bakes an absolute state path in.
+     */
+    generateHookScript(event: ClaudeHookEvent, statePath?: string | StatePathRef): string;
+    /**
+     * Generate a SKILL.md for Claude Code's skill directory
+     * (`~/.claude/skills/<name>/SKILL.md`). The body instructs the agent to
+     * treat the hook-injected state as authoritative (history is not
+     * reliable), to read state via the skillstate MCP tool `state.get`, and
+     * to persist via `state.patch` — the PostToolUse hook also merges any
+     * fenced ```json `state_patch` block printed by a Bash tool call.
      */
-    generateCompactHookScript(statePath: string, schema?: ProceduralSpec['schema']): string;
-    generateCompactHookScript(stateRef: StatePathRef, schema?: ProceduralSpec['schema']): string;
+    generateSkillMd(spec: ProceduralSpec, statePath?: string): string;
     /**
-     * Generate a SessionStart hook script that re-injects state after
-     * compaction. The hook uses a matcher for `source: "compact"` so it
-     * only fires when the session was resumed from a compacted state.
+     * Merge the skillstate hook groups into an existing `settings.json`
+     * text. Preserves every other top-level key (env, permissions, model,
+     * …) and every existing (non-skillstate) hook. Idempotent: if any
+     * skillstate command is already wired, the ORIGINAL text is returned
+     * byte-unchanged. Malformed/empty input starts from a fresh hooks-only
+     * document (the CLI guards a live settings.json before calling).
      */
-    generateSessionStartHookScript(statePath: string): string;
-    generateSessionStartHookScript(stateRef: StatePathRef): string;
+    mergeHooksConfig(existingJson: string, options?: ClaudeHooksConfigOptions): string;
     /**
-     * Convenience: generate both compact-related hooks at once.
-     * Returns `{ preCompact, sessionStartCompact }` — write each to a
-     * `.cjs` file and register in Claude Code settings.
+     * Generate a hook script and persist it via `atomicWriteFile`. `target`
+     * is the script destination (usually
+     * {@link ClaudeAdapter.claudeHookScriptPath}); `statePath` is forwarded
+     * to {@link generateHookScript}. Returns the absolute destination path.
      */
-    generateAllHooksScripts(statePath: string, schema?: ProceduralSpec['schema']): {
-        preCompact: string;
-        sessionStartCompact: string;
-    };
-    generateAllHooksScripts(stateRef: StatePathRef, schema?: ProceduralSpec['schema']): {
-        preCompact: string;
-        sessionStartCompact: string;
-    };
+    saveHookScript(event: ClaudeHookEvent, target: string | StatePathRef, statePath?: string | StatePathRef): Promise<string>;
+    /**
+     * Generate the hooks config document and persist it via
+     * `atomicWriteFile`. Both the destination and the embedded state path
+     * accept raw strings or `{ root, name }` refs confined by
+     * `resolveStatePath`. Returns the absolute destination path.
+     */
+    saveHooksConfig(target: string | StatePathRef, statePath?: string | StatePathRef, options?: ClaudeHooksConfigOptions): Promise<string>;
+    /**
+     * Generate a SKILL.md and persist it via `atomicWriteFile`. Returns the
+     * absolute destination path.
+     */
+    saveSkillMd(target: string | StatePathRef, spec: ProceduralSpec, statePath?: string): Promise<string>;
     generateAppendPrompt(): string;
+    /** Resolve a `string | StatePathRef` via `resolveStatePath` (throws on `..`). */
+    private resolve;
+    /** PostToolUse script: extract state_patch, ⊕ merge, persist. */
+    private buildPostToolUseScript;
     private describeSchema;
 }
+/**
+ * Surgically remove every skillstate hook handler from an existing
+ * `settings.json` text (the uninstall path — restoring a backup would
+ * lose live settings, so groups are edited in place):
+ *
+ * - a handler is skillstate when its command points at a generated
+ *   `<event>.cjs` script (matched by basename, independent of where the
+ *   script dir lived);
+ * - groups whose handlers are ALL skillstate are dropped; MIXED groups
+ *   keep their foreign handlers and lose only the skillstate ones;
+ * - event arrays left empty are removed from the `hooks` object;
+ * - every other top-level key (env, permissions, model, …) survives.
+ *
+ * Returns the original text untouched (`changed: false`) when it is
+ * malformed, has no hooks object, or carries no skillstate handlers.
+ */
+export declare function removeSkillstateHookGroups(existingJson: string): {
+    text: string;
+    changed: boolean;
+};
 //# sourceMappingURL=claude-adapter.d.ts.map

package/dist/claude-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-adapter.d.ts","sourceRoot":"","sources":["../src/claude-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,WAAW,EACX,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAM1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,qBAAa,aAAc,YAAW,eAAe;IACnD,QAAQ,CAAC,IAAI,YAAY;IAEzB,OAAO,CAAC,WAAW,CAAiD;IAEpE,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CA+B3D;IAED,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEhD;IAED,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7C;IAED;;;OAGG;IACH,YAAY,CACV,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,cAAc,GACnB,MAAM,CAER;IAED,kBAAkB,CAChB,SAAS,EAAE,YAAY,GAAG,aAAa,EACvC,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC,MAAM,CAAC;IACV;;;;;OAKG;IACH,kBAAkB,CAChB,SAAS,EAAE,YAAY,GAAG,aAAa,EACvC,QAAQ,EAAE,YAAY,EACtB,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC,MAAM,CAAC;IAmJV;;;;;;OAMG;IACG,cAAc,CAClB,MAAM,EAAE,MAAM,GAAG,YAAY,EAC7B,SAAS,EAAE,YAAY,GAAG,aAAa,EACvC,SAAS,EAAE,MAAM,GAAG,YAAY,EAChC,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC,CAYjB;IAED;;;;;;;;;OASG;IACH,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IACxF,yBAAyB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAuE7F;;;;OAIG;IACH,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1D,8BAA8B,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC;IA6B/D;;;;OAIG;IACH,uBAAuB,CACrB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,uBAAuB,CACrB,QAAQ,EAAE,YAAY,EACtB,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC;IAWvD,oBAAoB,IAAI,MAAM,CAe7B;IAED,OAAO,CAAC,cAAc;CASvB"}
+{"version":3,"file":"claude-adapter.d.ts","sourceRoot":"","sources":["../src/claude-adapter.ts"],"names":[],"mappings":"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"}