@skillstate/opencode 2.2.2 → 3.0.0

package/README.md

@@ -14,11 +14,15 @@
 ---
 
 `@skillstate/opencode` integrates the paper-exact runtime
-([`@skillstate/core`](../core)) into **OpenCode**. It emits a `SKILL.md` so the
-host discovers the skill, and a plugin that hooks
+([`@skillstate/core`](../core)) into **OpenCode**. The integration is the
+npm plugin `SkillStatePlugin` itself, loaded directly from the PROJECT
+`opencode.json(c)` (`"plugin": ["@skillstate/opencode"]`): it hooks
 `experimental.chat.messages.transform` to **trim history before every LLM
 call** — dropping old messages and injecting only the state, which is genuine
-**O(1)** prompt footprint.
+**O(1)** prompt footprint. The plugin is project-local and inert when the
+project has no `.skillstate/` state, and OpenCode reads the shared project
+`.claude/skills/skillstate/SKILL.md` too (Claude-compatible skill discovery),
+so one host-neutral skill file serves both hosts.
 
 > **@non-paper** — no adapters exist in arXiv 2608.26263v3. This adapter is an
 > additive integration, not part of the paper.
@@ -34,89 +38,77 @@ Requires Node.js >= 20. TypeScript types are bundled.
 ## Quick start
 
 ```ts
-import { OpenCodeAdapter } from '@skillstate/opencode';
-import { INTERCODE_CTF_SPEC } from '@skillstate/core/schemas';
+import { OpenCodeAdapter, SkillStatePlugin, createSkillStatePlugin } from '@skillstate/opencode';
 
 const adapter = new OpenCodeAdapter();
 
-// SKILL.md with frontmatter (name/description/version) + an
-// execution_context block pointing at the persisted state file:
-const skillMd = adapter.generateSkillMd(INTERCODE_CTF_SPEC, './.skillstate.json');
-
-// Plugin with real O(1) history trimming via experimental.chat.messages.transform.
-// The state path is resolved per session from the host cwd inside the plugin —
-// no baked path:
-const plugin = adapter.generatePluginCode();
-
-// Default keeps the last 3 non-system messages + state injection.
-// Configure history depth:
-const plugin2 = adapter.generatePluginCode({
-  maxHistoryMessages: 5,   // keep last 5 non-system messages
-});
-
-// Persist the plugin to disk atomically:
-const saved = await adapter.savePluginCode(
-  './skillstate.plugin.ts',
-  { maxHistoryMessages: 5 },
-);
+// The plugin OpenCode loads from "plugin": ["@skillstate/opencode"] —
+// the ready-made instance (the default export carries the same function):
+const plugin = SkillStatePlugin;
+
+// Need a custom configuration? Build your own instance:
+const configured = createSkillStatePlugin({ maxHistoryMessages: 5 });
+
+// Real O(1) history trimming via experimental.chat.messages.transform,
+// compaction context injection via experimental.session.compacting, and
+// state persistence via tool.execute.after. The state path is resolved per
+// session from the host cwd inside the plugin — no baked path, and every
+// state-touching hook returns early when the project has no state file.
 ```
 
 ## Install into OpenCode (host)
 
 Tested end-to-end against OpenCode ≥ 1.17 (`@opencode-ai/plugin` 1.15.x
-hook contracts). Four steps:
-
-**1. Generate the plugin file** (one-off, or wire into a build script):
-
-```ts
-// scripts/gen-plugin.mjs  (run with: node scripts/gen-plugin.mjs)
-import { OpenCodeAdapter } from '@skillstate/opencode';
-import { writeFileSync } from 'node:fs';
-
-const adapter = new OpenCodeAdapter();
-const code = adapter.generatePluginCode({ maxHistoryMessages: 3 });
-writeFileSync('/abs/path/to/skillstate.plugin.ts', code);
-```
-
-Put the generated `skillstate.plugin.ts` anywhere stable (absolute path is
-safest), e.g. `<project>/.opencode-runtime/skillstate.plugin.ts`. The plugin
-must be able to resolve `@skillstate/opencode` at load time (install it in
-the project or globally) — hook logic lives in that package.
+hook contracts). Everything below is PROJECT-LOCAL — nothing is written
+into `~/.config/opencode`. The one-command path is
+`npm i -g @skillstate/cli && skillstate init` in the project (it performs
+steps 1–3 for every detected host); the manual equivalent:
 
-**2. Create the initial state file** (`<project>/.skillstate/skillstate.json`),
-matching your spec schema, e.g. for `INTERCODE_CTF_SPEC`:
+**1. Register the npm plugin in the project `opencode.jsonc|json`** — add
+`"@skillstate/opencode"` to the `plugin` array (npm entries are
+auto-installed by OpenCode via Bun; no generated plugin file exists):
 
-```json
+```jsonc
 {
-  "discovered_flags": [],
-  "tested_hypotheses": [],
-  "active_files": [],
-  "working_dir": "/abs/work/dir",
-  "cmd_summary": "initialized"
+  "plugin": [
+    "@ai-sdk/anthropic",
+    "@skillstate/opencode"
+  ]
 }
 ```
 
-**3. Register the plugin in `opencode.jsonc`** — add a `file://` entry to the
-`plugin` array (local paths are resolved by OpenCode and imported directly;
-TypeScript is supported because plugins load under Bun):
+**2. Register the MCP server** in the same config's `mcp` object —
+`skillstate init` writes exactly this entry (`npx -y @skillstate/mcp@^3`):
 
 ```jsonc
 {
-  "plugin": [
-    "@ai-sdk/anthropic",
-    "file:///abs/path/to/skillstate.plugin.ts"
-  ]
+  "mcp": {
+    "skillstate": {
+      "type": "local",
+      "command": ["npx", "-y", "@skillstate/mcp@^3"],
+      "enabled": true
+    }
+  }
 }
 ```
 
-**4. Install the SKILL.md** — write `adapter.generateSkillMd(spec, statePath)`
-to `~/.config/opencode/skills/skillstate/SKILL.md` (global) or
-`.opencode/skills/skillstate/SKILL.md` (project). Keep the frontmatter fields
-`name` (must match the folder name) and a one-line `description`; the
-generated frontmatter may need a manual trim to those two fields.
-
-Verify with `opencode debug config` (plugin entry shows under `plugin`) and
-`opencode debug skill` (your skill is listed). Hook notes for OpenCode ≥ 1.17:
+**3. Share the project skill** — one host-neutral
+`.claude/skills/skillstate/SKILL.md` (written by `skillstate init`) serves
+both OpenCode and Claude Code: OpenCode reads project `.claude/skills/` via
+Claude-compatible discovery. The skill's frontmatter is exactly `name` +
+`description`; the body describes the state-based execution protocol and
+names no host-specific hook/plugin events — the npm plugin injects the
+current state into context every turn, and everything else goes through the
+host-agnostic skillstate MCP tools.
+
+**4. Run `skillstate init` in the project** (or let it do all of the above
+at once) to create the state envelope `./.skillstate/skillstate.json` —
+the plugin resolves it from the session cwd and stays inert until it
+exists.
+
+Verify with `opencode debug config` (the plugin entry shows under `plugin`,
+`mcp.skillstate` under `mcp`) and `opencode debug skill` (your skill is
+listed). Hook notes for OpenCode ≥ 1.17:
 `messages.transform` receives `{ info: Message, parts: Part[] }` entries and
 must mutate `output.messages` **in place**; the plugin injects state as a
 synthetic `{ info, parts }` message.
@@ -125,24 +117,22 @@ synthetic `{ info, parts }` message.
 
 Root path `@skillstate/opencode` exports the adapter and the static plugin:
 
-- `new OpenCodeAdapter()` — implements `PlatformAdapter` (`name = 'opencode'`).
-- `generateSkillMd(spec, statePath?): string` — a `SKILL.md` body with
-  frontmatter and a state-based process description.
-- `generatePluginCode(options?): string` — a thin plugin loader
-  (`import { createSkillStatePlugin } from '@skillstate/opencode'`;
-  `options.maxHistoryMessages`, default 3). State resolution is always
-  per-project and lives inside the static plugin. Hooks:
-  `experimental.chat.messages.transform` (real history trimming),
-  `experimental.session.compacting` (inject state into compaction context),
-  `tool.execute.after` (persist `state_patch` to disk).
+- `new OpenCodeAdapter()` — implements `PlatformAdapter` (`name = 'opencode'`);
+  a pure prompt/parse surface (`injectState`, `extractPatch`,
+  `extractAction`, `formatPrompt`) — host glue is the npm plugin itself,
+  not generated code.
+- `SkillStatePlugin` (+ default export) — the ready-made plugin instance
+  OpenCode loads from `"plugin": ["@skillstate/opencode"]`; identical to
+  `createSkillStatePlugin()`.
 - `createSkillStatePlugin({ maxHistoryMessages? })` — the static plugin
   factory (single source of truth for the hook logic); state is resolved from
   the session cwd on every hook call via
-  `resolveStatePathForCwd(process.cwd(), os.homedir(), agentId)`. The
-  `event` hook registers sub-agent sessions from the host bus
-  (`session.created`/`session.updated` carry `info.parentID`): a sub-agent
-  session resolves to `agents/<parentPrefix>-<sessionPrefix>/` instead of
-  overwriting its parent's state file.
+  `resolveStatePathForCwd(process.cwd(), os.homedir(), agentId)`, and every
+  state-touching hook returns early when the state file does not exist
+  (hooks never create state files). Hooks:
+  `experimental.chat.messages.transform` (real history trimming),
+  `experimental.session.compacting` (inject state into compaction context),
+  `tool.execute.after` (persist `state_patch` to disk).
 - `resolveStatePathForCwd(cwd, home?, agentId?): string` — the per-project
   state path resolution (pure path arithmetic, no filesystem access).
 - `pluginAgentId(input, messages?)` / `scopedAgentId(agentId)` /
@@ -150,9 +140,6 @@ Root path `@skillstate/opencode` exports the adapter and the static plugin:
   the agent-scope plumbing (session id → `agents/` directory name).
 - `readSkillState` / `saveSkillState` / `mergePatch` / `extractPatch` — the
   plugin's state helpers, shared by the static plugin.
-- `savePluginCode(target, options?): Promise<string>` — writes the plugin
-  atomically and returns the destination. `target` accepts a raw path or a
-  `{ root, name }` ref confined by `resolveStatePath` (`..` escapes throw).
 - `injectState(state, spec): string` / `formatPrompt(state, observation, spec): string`.
 - `extractPatch(response): StatePatch | null` / `extractAction(response): string | null`.
 
@@ -163,11 +150,11 @@ Root path `@skillstate/opencode` exports the adapter and the static plugin:
   `experimental.chat.messages.transform`, so the plugin drops old messages
   instead of just hiding them — only the last N non-system messages plus an
   injected state message reach the LLM.
-- The generated plugin is a **thin loader**: it imports
-  `createSkillStatePlugin` from `@skillstate/opencode` (one source of truth).
-  Hook logic lives only in `src/plugin.ts` — regenerate rather than editing
-  generated files. **WHERE STATE LIVES** (each opencode session reads AND
-  writes the same path within its cwd — no cross-file surprises):
+- **The plugin is the npm package, not generated code.** Hook logic lives
+  only in `src/plugin.ts` — nothing is emitted to disk by an installer, so
+  there are no generated files to edit. **WHERE STATE LIVES** (each opencode
+  session reads AND writes the same path within its cwd — no cross-file
+  surprises):
   - main session: `<cwd>/.skillstate/skillstate.json`
   - sub-agent session (Task sub-agents carry `parentID` on the session):
     `<cwd>/.skillstate/agents/<parentPrefix>-<sessionPrefix>/skillstate.json`

package/dist/index.d.ts

@@ -1,3 +1,29 @@
-export * from './opencode-adapter.js';
-export * from './plugin.js';
+/**
+ * `@skillstate/opencode` — the OpenCode v2 plugin package.
+ *
+ * The default export IS the plugin definition: OpenCode loads
+ * `opencode.json` → `"plugins": ["@skillstate/opencode"]`, imports this
+ * module and calls `setup(ctx)`. Everything else is exported for tests and
+ * for embedders that want the pieces without the plugin lifecycle.
+ *
+ * See `plugin.ts` for the design contract, in particular the rule that this
+ * package never mutates `event.messages`.
+ */
+export { SkillStatePlugin, PLUGIN_ID, default } from './plugin.js';
+/**
+ * The paper-exact `PlatformAdapter` (arXiv 2608.26263v3 A.4 prompt format).
+ * Kept as the research surface used by the benchmark; it is NOT the host
+ * integration and nothing in the plugin path calls it. In particular its
+ * `injectState` still emits the paper's `STATE_PATCH_CONTRACT`, which is
+ * exactly the instruction pattern the v2 plugin avoids.
+ */
+export { OpenCodeAdapter } from './opencode-adapter.js';
+export { SessionRegistry, stateScopeFor, DEFAULT_SESSION_TTL_MS, } from './session-registry.js';
+export type { SessionRecord, SessionRegistryOptions } from './session-registry.js';
+export { ProjectStateStore, diffDocuments, mergeDocuments, statePathFor, } from './state-store.js';
+export type { StateChanges, StateDocument, ProjectStateStoreOptions, } from './state-store.js';
+export { buildStateHint, renderStateForHint, ADVERTISED_TOOLS, MAX_INLINE_STATE_CHARS, } from './system-hint.js';
+export type { StateHintOptions } from './system-hint.js';
+export { registerTools, normalizePatch, MAX_PATCH_BYTES } from './tools.js';
+export type { MergeValue, ReadValue, ToolDeps, ToolError, ToolOk, ToolResult, UpdateValue, } from './tools.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACnE;;;;;;GAMG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,eAAe,EACf,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,YAAY,EACZ,aAAa,EACb,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EACV,UAAU,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EACT,MAAM,EACN,UAAU,EACV,WAAW,GACZ,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,4 +1,25 @@
-// @skillstate/opencode — OpenCode platform adapter.
-export * from './opencode-adapter.js';
-export * from './plugin.js';
+/**
+ * `@skillstate/opencode` — the OpenCode v2 plugin package.
+ *
+ * The default export IS the plugin definition: OpenCode loads
+ * `opencode.json` → `"plugins": ["@skillstate/opencode"]`, imports this
+ * module and calls `setup(ctx)`. Everything else is exported for tests and
+ * for embedders that want the pieces without the plugin lifecycle.
+ *
+ * See `plugin.ts` for the design contract, in particular the rule that this
+ * package never mutates `event.messages`.
+ */
+export { SkillStatePlugin, PLUGIN_ID, default } from './plugin.js';
+/**
+ * The paper-exact `PlatformAdapter` (arXiv 2608.26263v3 A.4 prompt format).
+ * Kept as the research surface used by the benchmark; it is NOT the host
+ * integration and nothing in the plugin path calls it. In particular its
+ * `injectState` still emits the paper's `STATE_PATCH_CONTRACT`, which is
+ * exactly the instruction pattern the v2 plugin avoids.
+ */
+export { OpenCodeAdapter } from './opencode-adapter.js';
+export { SessionRegistry, stateScopeFor, DEFAULT_SESSION_TTL_MS, } from './session-registry.js';
+export { ProjectStateStore, diffDocuments, mergeDocuments, statePathFor, } from './state-store.js';
+export { buildStateHint, renderStateForHint, ADVERTISED_TOOLS, MAX_INLINE_STATE_CHARS, } from './system-hint.js';
+export { registerTools, normalizePatch, MAX_PATCH_BYTES } from './tools.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACnE;;;;;;GAMG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,eAAe,EACf,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,YAAY,GACb,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/opencode-adapter.d.ts

@@ -4,21 +4,17 @@
  * Bridges the skillstate runtime into OpenCode via:
  * - Prompts formatted with the skillstate XML-style skill envelope
  *   (delegates to PromptTransformer.formatForOpenCode).
- * - A generated SKILL.md so OpenCode discovers the skill and follows the
- *   state-based execution process.
- * - A generated plugin that hooks `experimental.chat.messages.transform` for
- *   real O(1) history trimming: old messages are dropped, only the last N
- *   non-system messages plus injected state are sent to the LLM.
- * - `experimental.session.compacting` injects state into compaction context.
- * - `tool.execute.after` persists state updates from LLM responses.
+ *
+ * Host glue is NO LONGER GENERATED by this adapter:
+ * - the plugin is the npm package `@skillstate/opencode` itself, loaded
+ *   directly from the project `opencode.json`
+ *   `"plugin": ["@skillstate/opencode"]` (see `SkillStatePlugin` /
+ *   `createSkillStatePlugin` in `src/plugin.ts` — project-local and inert
+ *   when the project has no skillstate state);
+ * - skill markdown (SKILL.md) generation is host-neutral and lives in the
+ *   CLI, not in the platform adapters.
  */
 import type { SkillState, StatePatch, ProceduralSpec, Observation, PlatformAdapter } from '@skillstate/core';
-import type { StatePathRef } from '@skillstate/core';
-/** Options for {@link OpenCodeAdapter.generatePluginCode}. */
-export interface GeneratePluginOptions {
-    /** Non-system messages kept by the plugin (default 3). */
-    maxHistoryMessages?: number;
-}
 /**
  * OpenCode platform adapter (@non-paper; see module doc).
  */
@@ -46,38 +42,5 @@ export declare class OpenCodeAdapter implements PlatformAdapter {
      * Paper-exact callers use `PromptTransformer.formatPaper` (Appendix A.4).
      */
     formatPrompt(state: SkillState, observation: Observation, spec: ProceduralSpec): string;
-    /**
-     * Generate a SKILL.md suitable for OpenCode's skill system.
-     *
-     * The frontmatter carries the skill name/description plus an
-     * execution_context block pointing at the persisted state file; the body
-     * describes the state-based execution process. History is discarded by
-     * the plugin's `messages.transform` hook — the LLM sees only the state.
-     */
-    generateSkillMd(spec: ProceduralSpec, statePath?: string): string;
-    /**
-     * Generate an OpenCode plugin file.
-     *
-     * The plugin is ALWAYS a thin loader in per-project resolver mode: the
-     * state path is computed from the session cwd on every hook call inside
-     * the static plugin (`resolveStatePathForCwd(process.cwd(),
-     * os.homedir())`), so each project gets its own
-     * `<cwd>/.skillstate/skillstate.json` and a session opened anywhere
-     * resolves the same state for the same project.
-     *
-     * Hooks (see `src/plugin.ts`): `experimental.chat.messages.transform`
-     * (real O(1) history trimming, `{ info, parts }` entries, in-place
-     * mutation), `experimental.session.compacting` (state into compaction
-     * context), `tool.execute.after` (persist `state_patch` from
-     * `output.output`).
-     */
-    generatePluginCode(options?: GeneratePluginOptions): string;
-    /**
-     * @non-paper additive helper: generate the plugin and persist it via
-     * `atomicWriteFile` (tmp + fsync + rename). The destination accepts a raw
-     * string or a `{ root, name }` ref confined by `resolveStatePath`.
-     * Returns the absolute destination path.
-     */
-    savePluginCode(target: string | StatePathRef, options?: GeneratePluginOptions): Promise<string>;
 }
 //# sourceMappingURL=opencode-adapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"opencode-adapter.d.ts","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,WAAW,EACX,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAS1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,eAAe;IACrD,QAAQ,CAAC,IAAI,cAAc;IAE3B,OAAO,CAAC,WAAW,CAAmD;IAEtE;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAe3D;IAED;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEhD;IAED;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7C;IAED;;;;;OAKG;IACH,YAAY,CACV,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,cAAc,GACnB,MAAM,CAER;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAWhE;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAAkB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAa1D;IAED;;;;;OAKG;IACG,cAAc,CAClB,MAAM,EAAE,MAAM,GAAG,YAAY,EAC7B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAOjB;CAKF"}
+{"version":3,"file":"opencode-adapter.d.ts","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,WAAW,EACX,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAI1B;;GAEG;AACH,qBAAa,eAAgB,YAAW,eAAe;IACrD,QAAQ,CAAC,IAAI,cAAc;IAE3B,OAAO,CAAC,WAAW,CAAmD;IAEtE;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAe3D;IAED;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEhD;IAED;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7C;IAED;;;;;OAKG;IACH,YAAY,CACV,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,cAAc,GACnB,MAAM,CAER;CAOF"}

package/dist/opencode-adapter.js

@@ -1,5 +1,5 @@
 import { PromptTransformer } from '@skillstate/core';
-import { atomicWriteFile, describeSchema, resolveStatePath, skillMdBody, STATE_PATCH_CONTRACT, } from '@skillstate/core';
+import { describeSchema, STATE_PATCH_CONTRACT } from '@skillstate/core';
 /**
  * OpenCode platform adapter (@non-paper; see module doc).
  */
@@ -47,68 +47,5 @@ ${STATE_PATCH_CONTRACT}`;
     formatPrompt(state, observation, spec) {
         return this.transformer.formatForOpenCode(spec, state, observation);
     }
-    /**
-     * Generate a SKILL.md suitable for OpenCode's skill system.
-     *
-     * The frontmatter carries the skill name/description plus an
-     * execution_context block pointing at the persisted state file; the body
-     * describes the state-based execution process. History is discarded by
-     * the plugin's `messages.transform` hook — the LLM sees only the state.
-     */
-    generateSkillMd(spec, statePath) {
-        return skillMdBody({
-            hostLabel: 'OpenCode',
-            injectionPhrase: 'injected into the message list before every model call',
-            hooks: {
-                inject: 'messages.transform',
-                reInject: 'session.compacting',
-            },
-            spec,
-            statePath: statePath ?? './.skillstate/skillstate.json',
-        });
-    }
-    /**
-     * Generate an OpenCode plugin file.
-     *
-     * The plugin is ALWAYS a thin loader in per-project resolver mode: the
-     * state path is computed from the session cwd on every hook call inside
-     * the static plugin (`resolveStatePathForCwd(process.cwd(),
-     * os.homedir())`), so each project gets its own
-     * `<cwd>/.skillstate/skillstate.json` and a session opened anywhere
-     * resolves the same state for the same project.
-     *
-     * Hooks (see `src/plugin.ts`): `experimental.chat.messages.transform`
-     * (real O(1) history trimming, `{ info, parts }` entries, in-place
-     * mutation), `experimental.session.compacting` (state into compaction
-     * context), `tool.execute.after` (persist `state_patch` from
-     * `output.output`).
-     */
-    generatePluginCode(options) {
-        const maxHistory = options?.maxHistoryMessages ?? 3;
-        return `// OpenCode plugin (thin loader) generated by skillstate.
-// Hook logic lives in the static plugin — the single source of truth —
-// shipped in the @skillstate/opencode package. PER-PROJECT state is
-// resolved from the session cwd on every hook call —
-// <cwd>/.skillstate/skillstate.json (global bucket when cwd === home).
-import { createSkillStatePlugin } from '@skillstate/opencode';
-
-export default createSkillStatePlugin({
-  maxHistoryMessages: ${maxHistory},
-});
-`;
-    }
-    /**
-     * @non-paper additive helper: generate the plugin and persist it via
-     * `atomicWriteFile` (tmp + fsync + rename). The destination accepts a raw
-     * string or a `{ root, name }` ref confined by `resolveStatePath`.
-     * Returns the absolute destination path.
-     */
-    async savePluginCode(target, options) {
-        const dest = typeof target === 'string'
-            ? target
-            : resolveStatePath(target.root, target.name);
-        await atomicWriteFile(dest, this.generatePluginCode(options));
-        return dest;
-    }
 }
 //# sourceMappingURL=opencode-adapter.js.map

package/dist/opencode-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"opencode-adapter.js","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EACL,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAS1B;;GAEG;AACH,MAAM,OAAO,eAAe;IACjB,IAAI,GAAG,UAAU,CAAC;IAEnB,WAAW,GAAG,IAAI,iBAAiB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;IAEtE;;;;OAIG;IACH,WAAW,CAAC,KAAiB,EAAE,IAAoB;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE/C,OAAO,gBAAgB,IAAI,CAAC,EAAE;gBAClB,IAAI,CAAC,YAAY;EAC/B,UAAU;;EAEV,SAAS;;;;;;EAMT,oBAAoB,EAAE,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,QAAgB;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,YAAY,CACV,KAAiB,EACjB,WAAwB,EACxB,IAAoB;QAEpB,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,IAAoB,EAAE,SAAkB;QACtD,OAAO,WAAW,CAAC;YACjB,SAAS,EAAE,UAAU;YACrB,eAAe,EAAE,wDAAwD;YACzE,KAAK,EAAE;gBACL,MAAM,EAAE,oBAAoB;gBAC5B,QAAQ,EAAE,oBAAoB;aAC/B;YACD,IAAI;YACJ,SAAS,EAAE,SAAS,IAAI,+BAA+B;SACxD,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAAkB,CAAC,OAA+B;QAChD,MAAM,UAAU,GAAG,OAAO,EAAE,kBAAkB,IAAI,CAAC,CAAC;QACpD,OAAO;;;;;;;;wBAQa,UAAU;;CAEjC,CAAC;IACA,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAClB,MAA6B,EAC7B,OAA+B;QAE/B,MAAM,IAAI,GACR,OAAO,MAAM,KAAK,QAAQ;YACxB,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;CAKF"}
+{"version":3,"file":"opencode-adapter.js","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExE;;GAEG;AACH,MAAM,OAAO,eAAe;IACjB,IAAI,GAAG,UAAU,CAAC;IAEnB,WAAW,GAAG,IAAI,iBAAiB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;IAEtE;;;;OAIG;IACH,WAAW,CAAC,KAAiB,EAAE,IAAoB;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE/C,OAAO,gBAAgB,IAAI,CAAC,EAAE;gBAClB,IAAI,CAAC,YAAY;EAC/B,UAAU;;EAEV,SAAS;;;;;;EAMT,oBAAoB,EAAE,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,QAAgB;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,YAAY,CACV,KAAiB,EACjB,WAAwB,EACxB,IAAoB;QAEpB,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;IACtE,CAAC;CAOF"}