@skillstate/claude 2.0.0

package/dist/claude-adapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @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 declare class ClaudeAdapter implements PlatformAdapter {
+    readonly name = "claude";
+    private transformer;
+    injectState(state: SkillState, spec: ProceduralSpec): string;
+    extractPatch(response: string): StatePatch | null;
+    extractAction(response: string): string | null;
+    /**
+     * @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.
+     */
+    generateHookScript(eventType: 'PreToolUse' | 'PostToolUse', stateRef: StatePathRef, schema?: ProceduralSpec['schema']): 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 (legacy behavior) or
+     * `{ root, name }` refs confined by `resolveStatePath`. Returns the
+     * absolute destination path.
+     */
+    saveHookScript(target: string | StatePathRef, eventType: 'PreToolUse' | 'PostToolUse', statePath: string | StatePathRef, schema?: ProceduralSpec['schema']): Promise<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.
+     *
+     * 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.
+     */
+    generateCompactHookScript(statePath: string, schema?: ProceduralSpec['schema']): string;
+    generateCompactHookScript(stateRef: StatePathRef, schema?: ProceduralSpec['schema']): 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.
+     */
+    generateSessionStartHookScript(statePath: string): string;
+    generateSessionStartHookScript(stateRef: StatePathRef): string;
+    /**
+     * Convenience: generate both compact-related hooks at once.
+     * Returns `{ preCompact, sessionStartCompact }` — write each to a
+     * `.cjs` file and register in Claude Code settings.
+     */
+    generateAllHooksScripts(statePath: string, schema?: ProceduralSpec['schema']): {
+        preCompact: string;
+        sessionStartCompact: string;
+    };
+    generateAllHooksScripts(stateRef: StatePathRef, schema?: ProceduralSpec['schema']): {
+        preCompact: string;
+        sessionStartCompact: string;
+    };
+    generateAppendPrompt(): string;
+    private describeSchema;
+}
+//# sourceMappingURL=claude-adapter.d.ts.map

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

@@ -0,0 +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"}

package/dist/claude-adapter.js

@@ -0,0 +1,323 @@
+import { PromptTransformer } from '@skillstate/core';
+import { atomicWriteFile, resolveStatePath, } from '@skillstate/core';
+export class ClaudeAdapter {
+    name = 'claude';
+    transformer = new PromptTransformer({ platform: 'claude' });
+    injectState(state, spec) {
+        const stateJson = JSON.stringify(state);
+        const schemaDesc = this.describeSchema(spec.schema);
+        return `# System
+
+You are ${spec.name}. ${spec.instructions}
+
+${schemaDesc}
+
+# Current State
+
+\`\`\`json
+${stateJson}
+\`\`\`
+
+# Instructions
+
+Based on your current state, provide your response with:
+
+1. Step-by-step reasoning (will be discarded after execution)
+2. A JSON block containing both your State Patch and your Action. The JSON block MUST have exactly these two keys:
+
+\`\`\`json
+{
+  "state_patch": { "key": "new_value", "obsolete_key": null },
+  "action": "your_action_here"
+}
+\`\`\`
+
+In \`state_patch\`, set keys to null to delete them. Only include fields you want to change. Omit fields to leave them unchanged.`;
+    }
+    extractPatch(response) {
+        return this.transformer.extractStatePatch(response);
+    }
+    extractAction(response) {
+        return this.transformer.extractAction(response);
+    }
+    /**
+     * @non-paper — adapter convenience (delegates to the transformer).
+     * Paper-exact callers use `PromptTransformer.formatPaper` (Appendix A.4).
+     */
+    formatPrompt(state, observation, spec) {
+        return this.transformer.formatForClaude(spec, state, observation);
+    }
+    generateHookScript(eventType, statePathOrRef, schema) {
+        const statePath = typeof statePathOrRef === 'string'
+            ? statePathOrRef
+            : resolveStatePath(statePathOrRef.root, statePathOrRef.name);
+        const sp = JSON.stringify(statePath);
+        if (eventType === 'PreToolUse') {
+            return [
+                '// Claude hook: PreToolUse',
+                '// Reads skill state and injects it into the tool\'s additionalContext.',
+                '// ADDITIVE: the host history is left untouched, so this alone does not',
+                '// reproduce the paper O(1) footprint (see module doc).',
+                'const fs = require("fs");',
+                'const stateFilePath = ' + sp + ';',
+                'let state = {};',
+                'try {',
+                '  if (fs.existsSync(stateFilePath)) {',
+                '    state = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));',
+                '  }',
+                '} catch (e) { state = {}; }',
+                'const stateJson = JSON.stringify(state);',
+                'const output = {',
+                '  hookSpecificOutput: {',
+                '    additionalContext: "Current skill state (JSON): " + stateJson',
+                '  }',
+                '};',
+                'process.stdout.write(JSON.stringify(output));',
+            ].join('\n');
+        }
+        // PostToolUse — schema-validated null-deletion merge. Malformed outputs
+        // are rejected and never persisted (paper Limitations: malformed outputs
+        // cannot corrupt Σt). Self-contained CommonJS (hook scripts run via
+        // `node script.cjs`). The schema is embedded so unknown keys / wrong
+        // types are rejected here instead of corrupting the persisted state.
+        const fence = '`' + '`' + '`';
+        const schemaJson = JSON.stringify(schema ?? {});
+        return [
+            '// Claude hook: PostToolUse',
+            '// Extracts state_patch from the assistant\'s response, validates it against',
+            '// the embedded schema, applies the null-deletion merge, and saves.',
+            'const fs = require("fs");',
+            'const stateFilePath = ' + sp + ';',
+            'const schema = ' + schemaJson + ';',
+            '',
+            'function isPlainObject(v) {',
+            '  return typeof v === "object" && v !== null && !Array.isArray(v);',
+            '}',
+            '',
+            '// ⊕ merge from the paper: null deletes a key, plain objects merge',
+            '// recursively, everything else overwrites. Never mutates `base` —',
+            '// builds and returns a copy.',
+            'function mergePatch(base, patch) {',
+            '  function mergeInto(result, patchObj) {',
+            '    for (const key of Object.keys(patchObj)) {',
+            '      const value = patchObj[key];',
+            '      if (value === null) {',
+            '        delete result[key];',
+            '      } else if (isPlainObject(value) && isPlainObject(result[key])) {',
+            '        result[key] = mergeInto({ ...result[key] }, value);',
+            '      } else {',
+            '        result[key] = value;',
+            '      }',
+            '    }',
+            '    return result;',
+            '  }',
+            '  return mergeInto({ ...base }, patch);',
+            '}',
+            '',
+            '// Schema validation: unknown keys rejected; null is always valid (deletion).',
+            'function validatePatchAgainstSchema(patch) {',
+            '  for (const key of Object.keys(patch)) {',
+            '    const field = schema[key];',
+            '    if (!field) {',
+            '      return "Unknown key: " + key;',
+            '    }',
+            '    const value = patch[key];',
+            '    if (value === null) continue;',
+            '    const expected = field.type;',
+            '    let ok = false;',
+            '    if (expected === "string") ok = typeof value === "string";',
+            '    else if (expected === "number") ok = typeof value === "number";',
+            '    else if (expected === "boolean") ok = typeof value === "boolean";',
+            '    else if (expected === "array") ok = Array.isArray(value);',
+            '    else if (expected === "object") ok = isPlainObject(value);',
+            '    if (!ok) {',
+            '      return "Invalid type for field \'" + key + "\': expected " + expected +',
+            '        ", got " + (Array.isArray(value) ? "array" : typeof value);',
+            '    }',
+            '  }',
+            '  return null;',
+            '}',
+            '',
+            'let state = {};',
+            'try {',
+            '  if (fs.existsSync(stateFilePath)) {',
+            '    state = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));',
+            '  }',
+            '} catch (e) { state = {}; }',
+            'let input = "";',
+            'process.stdin.setEncoding("utf-8");',
+            'process.stdin.on("data", (chunk) => { input += chunk; });',
+            'process.stdin.on("end", () => {',
+            '  const output = {};',
+            '  try {',
+            '    const parsed = JSON.parse(input);',
+            '    const content = parsed.tool_response || parsed.content || "";',
+            '    const re = /' + fence + 'json\\s*\\n?([\\s\\S]*?)\\n?\\s*' + fence + '/;',
+            '    const match = content.match(re);',
+            '    if (match) {',
+            '      // Guarded parse: malformed JSON inside the fence leaves state untouched.',
+            '      let json;',
+            '      try {',
+            '        json = JSON.parse(match[1]);',
+            '      } catch (parseError) {',
+            '        output.error = "Malformed JSON in state patch block: " + parseError.message;',
+            '        process.stdout.write(JSON.stringify(output));',
+            '        return;',
+            '      }',
+            '      if (json.state_patch && typeof json.state_patch === "object" && !Array.isArray(json.state_patch)) {',
+            '        const validationError = validatePatchAgainstSchema(json.state_patch);',
+            '        if (validationError) {',
+            '          // Reject: report the error, never write state.',
+            '          output.error = validationError;',
+            '          process.stdout.write(JSON.stringify(output));',
+            '          return;',
+            '        }',
+            '        state = mergePatch(state, json.state_patch);',
+            '        fs.writeFileSync(stateFilePath, JSON.stringify(state, null, 2));',
+            '      }',
+            '    }',
+            '  } catch (e) {',
+            '    // Malformed stdin JSON or unexpected failure: state stays untouched.',
+            '    output.error = "Failed to process PostToolUse input: " + e.message;',
+            '  }',
+            '  process.stdout.write(JSON.stringify(output));',
+            '});',
+        ].join('\n');
+    }
+    /**
+     * @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 (legacy behavior) or
+     * `{ root, name }` refs confined by `resolveStatePath`. Returns the
+     * absolute destination path.
+     */
+    async saveHookScript(target, eventType, statePath, schema) {
+        const dest = typeof target === 'string'
+            ? target
+            : resolveStatePath(target.root, target.name);
+        const resolvedState = typeof statePath === 'string'
+            ? statePath
+            : resolveStatePath(statePath.root, statePath.name);
+        const script = this.generateHookScript(eventType, resolvedState, schema);
+        await atomicWriteFile(dest, script);
+        return dest;
+    }
+    generateCompactHookScript(statePathOrRef, schema) {
+        const statePath = typeof statePathOrRef === 'string'
+            ? statePathOrRef
+            : resolveStatePath(statePathOrRef.root, statePathOrRef.name);
+        const sp = JSON.stringify(statePath);
+        const schemaJson = JSON.stringify(schema ?? {});
+        const lastCompactPath = JSON.stringify(statePath + '.last-compact.json');
+        return [
+            '// Claude hook: PreCompact',
+            '// Injects the current skill state into the compaction summary.',
+            '// Tracks diff since last compact for incremental context.',
+            'const fs = require("fs");',
+            'const stateFilePath = ' + sp + ';',
+            'const lastCompactFilePath = ' + lastCompactPath + ';',
+            'const schema = ' + schemaJson + ';',
+            '',
+            'function readJsonSafe(filePath) {',
+            '  try {',
+            '    if (fs.existsSync(filePath)) {',
+            '      return JSON.parse(fs.readFileSync(filePath, "utf-8"));',
+            '    }',
+            '  } catch {}',
+            '  return {};',
+            '}',
+            '',
+            'const current = readJsonSafe(stateFilePath);',
+            'const lastCompact = readJsonSafe(lastCompactFilePath);',
+            '',
+            '// Compute diff: keys added, changed, or deleted since last compact.',
+            'const diff = {};',
+            'const allKeys = new Set([...Object.keys(current), ...Object.keys(lastCompact)]);',
+            'for (const key of allKeys) {',
+            '  const cur = current[key];',
+            '  const prev = lastCompact[key];',
+            '  if (cur === undefined) {',
+            '    diff[key] = "(deleted)";',
+            '  } else if (prev === undefined) {',
+            '    diff[key] = cur;',
+            '  } else if (JSON.stringify(cur) !== JSON.stringify(prev)) {',
+            '    diff[key] = { from: prev, to: cur };',
+            '  }',
+            '}',
+            '',
+            'const contextParts = [',
+            '  "Current skill state (JSON): " + JSON.stringify(current),',
+            '];',
+            'if (Object.keys(diff).length > 0) {',
+            '  contextParts.push("Changes since last compact: " + JSON.stringify(diff));',
+            '}',
+            '',
+            'const output = {',
+            '  hookSpecificOutput: {',
+            '    additionalContext: contextParts.join("\\n")',
+            '  }',
+            '};',
+            '',
+            '// Save current state as the new compact snapshot.',
+            'try {',
+            '  fs.writeFileSync(lastCompactFilePath, JSON.stringify(current, null, 2));',
+            '} catch {}',
+            '',
+            'process.stdout.write(JSON.stringify(output));',
+        ].join('\n');
+    }
+    generateSessionStartHookScript(statePathOrRef) {
+        const statePath = typeof statePathOrRef === 'string'
+            ? statePathOrRef
+            : resolveStatePath(statePathOrRef.root, statePathOrRef.name);
+        const sp = JSON.stringify(statePath);
+        return [
+            '// Claude hook: SessionStart (source: compact)',
+            '// Re-injects skill state after compaction so the model retains',
+            '// execution context even though history was compressed.',
+            'const fs = require("fs");',
+            'const stateFilePath = ' + sp + ';',
+            'let state = {};',
+            'try {',
+            '  if (fs.existsSync(stateFilePath)) {',
+            '    state = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));',
+            '  }',
+            '} catch {}',
+            'const output = {',
+            '  hookSpecificOutput: {',
+            '    additionalContext: "Skill state restored after compaction: " + JSON.stringify(state)',
+            '  }',
+            '};',
+            'process.stdout.write(JSON.stringify(output));',
+        ].join('\n');
+    }
+    generateAllHooksScripts(statePathOrRef, schema) {
+        return {
+            preCompact: this.generateCompactHookScript(statePathOrRef, schema),
+            sessionStartCompact: this.generateSessionStartHookScript(statePathOrRef),
+        };
+    }
+    generateAppendPrompt() {
+        return `You are operating in state-based execution mode. Your state is maintained across steps.
+
+After each step, you MUST respond with a JSON block containing your State Patch and your Action. The JSON block MUST have exactly these two keys:
+
+\`\`\`json
+{
+  "state_patch": { "field_to_update": "new_value", "obsolete_field": null },
+  "action": "next_action_name"
+}
+\`\`\`
+
+- In \`state_patch\`, set keys to null to delete them. Only include fields you want to change. Omit fields to leave them unchanged.
+- \`action\` indicates what you want to do next (e.g., "continue", "done", "deploy").
+- Reasoning is discarded after execution — put anything you need to persist into \`state_patch\`.`;
+    }
+    describeSchema(schema) {
+        const fields = Object.entries(schema)
+            .map(([name, field]) => `- ${name} (${field.type}): ${field.description ?? 'no description'}`)
+            .join('\n');
+        return `## Schema\n${fields}`;
+    }
+}
+//# sourceMappingURL=claude-adapter.js.map

package/dist/claude-adapter.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './claude-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+// @skillstate/claude — Claude Code platform adapter.
+export * from './claude-adapter.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,cAAc,qBAAqB,CAAC"}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@skillstate/claude",
+  "version": "2.0.0",
+  "description": "Claude Code platform adapter for the skillstate runtime.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["dist"],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@skillstate/core": "^2.0.0"
+  }
+}