@skillstate/opencode 2.2.2 → 3.0.1

package/dist/system-hint.js

@@ -0,0 +1,166 @@
+/**
+ * The system-prompt fragment the plugin contributes to each model request.
+ *
+ * ── Why this module is so small and so careful ───────────────────────────
+ *
+ * The v1 integration rewrote the conversation on every turn: it truncated
+ * history to the last three messages and appended a synthetic `role: "user"`
+ * message whose body was the raw state JSON. The reported symptom was that
+ * the agent stopped doing what it was asked and started emitting state
+ * JSON instead. The cause was structural, not a model quirk:
+ *
+ * - The last `role: "user"` message is what the model treats as the current
+ *   instruction, so the state blob displaced the user's actual request.
+ * - Truncating history deleted the task statement, the tool results, and
+ *   the errors the agent had just been given — it could not reason about
+ *   work it could no longer see.
+ *
+ * The fix is a rule, enforced by `tests/opencode/context-integrity.test.ts`:
+ * **this plugin never mutates `event.messages`.** It contributes one
+ * additive, bounded fragment to `event.system`, states what the tools are
+ * for, and explicitly leaves the task alone.
+ *
+ * The wording below is a product requirement, not prose taste. It must
+ * describe the tools without instructing the model to change how it works.
+ * Imperative framing ("you must", "always", "respond with a JSON block")
+ * is what turns a persistence aid into a prompt override.
+ */
+/** Largest state JSON rendered into the hint before falling back to a key list. */
+export const MAX_INLINE_STATE_CHARS = 4000;
+/** The tool names the hint advertises — kept in sync with `tools.ts`. */
+export const ADVERTISED_TOOLS = [
+    'skillstate_read',
+    'skillstate_update',
+    'skillstate_merge',
+];
+/**
+ * Render a state document for inclusion in the system prompt.
+ *
+ * Small documents are inlined verbatim (the model sees what is already
+ * saved without a tool round-trip). Documents past
+ * {@link MAX_INLINE_STATE_CHARS} are summarized as a key list plus a count and
+ * a pointer to `skillstate_read` — an unbounded state file must not be able to
+ * grow the system prompt without limit.
+ *
+ * The reported count is in the SAME UNIT as the limit, and it is labelled with
+ * that unit's name. The first version reported `bytes` next to a limit expressed
+ * in characters, which is this project's whole recurring mistake in one line: a
+ * state of 4,003 Cyrillic characters is 3,003 over the limit and 7,993 bytes, so
+ * the model reading the summary was handed two numbers in two units and a limit
+ * in a third. §4.3 is explicit that sizes here are raw string CHARS.
+ */
+export function renderStateForHint(state) {
+    const json = JSON.stringify(state, null, 2);
+    if (json.length <= MAX_INLINE_STATE_CHARS)
+        return json;
+    const keys = Object.keys(state).sort();
+    return `${JSON.stringify({
+        _truncated: true,
+        chars: json.length,
+        keys,
+        hint: 'Saved state is large — call skillstate_read to load it.',
+    }, null, 2)}`;
+}
+/**
+ * How many MODEL REQUESTS may pass with the state untouched before the drift
+ * notice fires.
+ *
+ * **"Requests", not "turns".** Measured on the weakest model in the
+ * catalogue: 20 file reads took 6 requests, 40 reads took 12, 70 reads took
+ * 27. The model batches tool calls, so a request is worth several file reads
+ * and a threshold described in "turns" is off by a factor of three. The
+ * number here is the unit the hook can actually count.
+ *
+ * 12 is chosen from the corpus rather than taste: the average run in the
+ * host's own store showed the model ~29,900 prompt tokens per request, so a
+ * dozen silent requests is roughly 350k tokens re-sent for a record that
+ * never moved. High enough that an agent reading five files in a row is not
+ * nagged.
+ */
+export const DRIFT_NOTICE_AFTER_TURNS = 12;
+/**
+ * The line that says what the state IS, which depends on whether the project
+ * was initialized.
+ *
+ * Neither version is an imperative. Both are statements about the setup, and
+ * the difference is that one describes a record the user asked for and the
+ * other describes an optional convenience. A model told to skip the tools
+ * when it judges them unnecessary will eventually judge a long task
+ * unnecessary at exactly the wrong moment; a model told the state is the
+ * project's record has a fact to work with.
+ */
+function purposeLine(initialized, statePath) {
+    return initialized
+        ? `This project has an execution state at \`${statePath}\`. It is the project's record: what has been established, decided, and left to do, kept across a context reset or compaction. The conversation is not that record, and it is not kept — the state file is.`
+        : `Notes for this project are saved at \`${statePath}\` and survive a context reset or compaction.`;
+}
+/**
+ * The notice shown once when the state has not moved for a long stretch.
+ *
+ * This is feedback, not an instruction, and the distinction is the whole
+ * design. It states a measured fact — this many turns, no write — and
+ * nothing about what the model ought to do. That keeps the v1 failure
+ * impossible (nothing here can displace the user's task) while still
+ * telling a drifting agent that the user initialized this for a reason.
+ *
+ * It fires once per silence, not every turn: a notice that repeats forever
+ * is wallpaper, and after the second copy nobody reads it.
+ */
+export function driftNotice(turnsSinceWrite) {
+    return `Note: this state file has not changed across the last ${turnsSinceWrite} steps of work.`;
+}
+/**
+ * Build the system-prompt fragment.
+ *
+ * Returns `''` for an empty document so an untouched project contributes
+ * nothing at all — the plugin is inert until the agent actually saves
+ * something, and an inert plugin is indistinguishable from no plugin.
+ */
+export function buildStateHint(options) {
+    const { state, statePath } = options;
+    const scope = options.scope ?? '';
+    if (Object.keys(state).length === 0)
+        return '';
+    // `skillstate_merge` is only meaningful to a sub-agent, which is the one
+    // session that cannot call it — so it is hidden from every other scope.
+    const tools = ADVERTISED_TOOLS.filter((name) => name !== 'skillstate_merge' || scope !== '');
+    const toolLine = `\nTools: ${tools.map((name) => `\`${name}\``).join(', ')}.`;
+    const mergeLine = scope === ''
+        ? ''
+        : '\nThis is a sub-agent session. When you finish, the main session folds your notes back with `skillstate_merge`; write them as if someone else will read them.';
+    const initialized = options.initialized === true;
+    const turns = options.turnsSinceWrite ?? 0;
+    const declared = options.declaredFields ?? [];
+    // Only speak when the state and the spec actually DISAGREE. A line naming
+    // the declared fields on every turn of every project would cost prompt budget
+    // to say something that is true, and the hint has a standing test that it
+    // must stay under a tenth of the conversation it rides along with. The case
+    // worth spending characters on is the one measured: a model that wrote
+    // everything under a namespace it invented while the declared fields sat at
+    // their defaults.
+    const undeclared = Object.keys(state).filter((k) => !declared.some((d) => d.startsWith(`${k} `)));
+    const schemaLine = declared.length === 0 || undeclared.length === 0
+        ? ''
+        : `\nThis project\'s \`skill-spec.json\` declares the state fields ${declared
+            .map((f) => `\`${f}\``)
+            .join(', ')}. The state currently holds ${undeclared
+            .slice(0, 6)
+            .map((k) => `\`${k}\``)
+            .join(', ')}, which the spec does not declare. Write declared fields at the TOP LEVEL under their own names; a later reader looking for \`${declared[0].split(' ')[0]}\` will not find it one level down.`;
+    const lines = [
+        '<skillstate-project-notes>',
+        purposeLine(initialized, statePath),
+        '',
+        renderStateForHint(state),
+        `${toolLine}${mergeLine}${schemaLine}`,
+        initialized
+            ? 'Record what you establish here as you go — plans made, decisions taken, file paths, values read, and what is left — so it is still here after a reset. The notes are not the task: keep doing what the user asked.'
+            : 'Use them only to carry facts across turns — plans already made, decisions already taken, file paths, and what is left to do. The notes are a side channel, not the task: keep doing what the user asked, and skip these tools entirely when the work needs no cross-turn memory.',
+    ];
+    if (initialized && turns >= DRIFT_NOTICE_AFTER_TURNS) {
+        lines.push('', driftNotice(turns));
+    }
+    lines.push('</skillstate-project-notes>');
+    return lines.join('\n');
+}
+//# sourceMappingURL=system-hint.js.map

package/dist/system-hint.js.map

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

package/dist/tools.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Native OpenCode tools for skillstate.
+ *
+ * These are the NATIVE tools: the fast path when the host is opencode v2.
+ * They carry a real JSON Schema and structured output, where the MCP server
+ * (`@skillstate/mcp`, still shipped and still registered) can only offer a
+ * JSON-RPC round-trip and untyped text. Both read the same state file, so
+ * the choice between them is about speed and typing on one side and reach
+ * on the other -- never about which one is correct.
+ *
+ * The MCP server was once the ONLY option: an opencode v1 plugin could not
+ * contribute first-class tools at all.
+ *
+ * Three tools, deliberately:
+ *
+ * - `skillstate_read`   - what this session has already saved.
+ * - `skillstate_update` - merge a patch (the only write path).
+ * - `skillstate_merge`  - fold sub-agent notes back into the root session.
+ *
+ * A fourth "delete everything" tool is intentionally absent: `null` in a
+ * patch already deletes a key, and a tool whose only job is to erase state
+ * is a foot-gun with no upside.
+ *
+ * ── Result shape ──────────────────────────────────────────────────────────
+ *
+ * Every tool returns a DISCRIMINATED result: `{ ok: true, ... }` or
+ * `{ ok: false, error }`. This is not a stylistic choice. A tool that
+ * declares an `output` schema must return a value matching it, so a failure
+ * path that returned only text was rejected by the host with "tool did not
+ * return its declared output" — a rejected tool call is worse for the agent
+ * than a failed one, because it loses the reason. A validation failure is a
+ * normal outcome here, and it is modelled as one.
+ *
+ * SCOPING is automatic. The current session's scope comes from
+ * `ToolContext.sessionID` plus the {@link SessionRegistry}, so the model
+ * never passes a session id and can never write another agent's file by
+ * guessing one.
+ */
+import type { ToolEditor } from '@opencode/plugin/promise/tool';
+import type { StatePatch, StateSchema } from '@skillstate/core';
+import type { SessionRegistry } from './session-registry.js';
+import { stateScopeFor } from './session-registry.js';
+import type { ProjectStateStore, StateChanges } from './state-store.js';
+/**
+ * Largest serialized patch a single `skillstate_update` accepts. The state
+ * file is a side channel for a human to read; a model that tries to dump a
+ * whole file into it should be told, not silently accommodated.
+ */
+export declare const MAX_PATCH_BYTES: number;
+/** A tool call that succeeded. */
+export interface ToolOk<T> {
+    readonly ok: true;
+    readonly value: T;
+}
+/** A tool call that was refused. `error` is written for the model to read. */
+export interface ToolError {
+    readonly ok: false;
+    readonly error: string;
+}
+/** Every tool result is one of these two. */
+export type ToolResult<T> = ToolOk<T> | ToolError;
+/** Payload of a successful `skillstate_read`. */
+export interface ReadValue {
+    readonly state: Record<string, unknown>;
+    readonly path: string;
+    readonly scope: string;
+    readonly empty: boolean;
+}
+/** Payload of a successful `skillstate_update`. */
+export interface UpdateValue {
+    readonly state: Record<string, unknown>;
+    readonly changes: StateChanges;
+    readonly path: string;
+    readonly scope: string;
+}
+/** Payload of a successful `skillstate_merge`. */
+export interface MergeValue {
+    readonly state: Record<string, unknown>;
+    readonly changes: StateChanges;
+    readonly merged: readonly string[];
+    readonly skipped: readonly string[];
+}
+/** Everything the tool definitions need, bound to one plugin instance. */
+export interface ToolDeps {
+    readonly store: ProjectStateStore;
+    readonly sessions: SessionRegistry;
+    /** Resolve a session id to its state scope; `''` is the root session. */
+    scopeFor: (sessionID: string) => string;
+    /**
+     * The project's declared schema, when it SHIPPED one.
+     *
+     * `undefined` is the normal case and the correct one: §6.2 validates
+     * `ΔΣ_t` against `P.schema`, so there is nothing to check a patch against
+     * for a project that has not declared a schema, and inventing a default here
+     * would reject notes that are perfectly reasonable.
+     *
+     * It is passed because this tool is the same file the paper's Σ lives in, and
+     * §9.3 says "a conforming writer must never emit a `state` containing a key
+     * absent from the schema". Measured: a notes-mode run called this tool
+     * thirty-one times from inside the host's `execute` sandbox, and the state
+     * file ended with a `last` key that the schema does not declare — accepted,
+     * `ok: true`, and written by an unvalidated second writer into the same
+     * document the paper's runtime owns. Only a spec the project SHIPPED is used,
+     * for the same reason `declaredFields` is gated on the source: announcing our
+     * own fallback schema as the project's would be a false claim.
+     */
+    readonly schema?: StateSchema;
+    /**
+     * Called after a patch is written, with the scope it was written to.
+     *
+     * The drift counter resets on it, and the counter is what the system prompt
+     * says out loud: "this state file has not changed across the last N steps of
+     * work". So it has to be reset by *every* write path, not just the one the
+     * paper-mode sink owns.
+     *
+     * Measured: in notes mode there is no sink, `stateWrites` never increments and
+     * `turnsSinceWrite` is never reset — so the notice fires at its threshold and
+     * reports silence for a run in which the model wrote the state on every step.
+     * The drift measurement that "the notice does not work" rested on was reading
+     * a counter that could not see the writes it was counting.
+     */
+    readonly onWrite?: (scope: string) => void;
+}
+/**
+ * Validate and normalize an incoming patch.
+ *
+ * Returns either the patch or a human-readable reason it was rejected. The
+ * checks protect the file; they do not dictate the model's schema. A state
+ * note is free-form by design, so the only hard rules are "must be an
+ * object", "must be JSON-serializable", and "must fit".
+ */
+export declare function normalizePatch(raw: unknown): {
+    ok: true;
+    patch: StatePatch;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Register the skillstate tools on an editor.
+ *
+ * The callback is synchronous, side-effect-free and replayable: OpenCode
+ * re-runs it on every registry rebuild, so it must not do I/O at
+ * registration time. All filesystem work happens inside `execute`.
+ */
+export declare function registerTools(editor: ToolEditor, deps: ToolDeps): void;
+export { stateScopeFor };
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE7E,OAAO,KAAK,EAAc,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAY,CAAC;AAEzC,kCAAkC;AAClC,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,8EAA8E;AAC9E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,6CAA6C;AAC7C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAElD,iDAAiD;AACjD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,kDAAkD;AAClD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,0EAA0E;AAC1E,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,yEAAyE;IACzE,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AA0JD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,OAAO,GACX;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAoCjE;AAwBD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAqJtE;AAOD,OAAO,EAAE,aAAa,EAAE,CAAC"}