@skillstate/opencode 3.0.0 → 3.0.1

package/dist/spec-loader.js

@@ -0,0 +1,163 @@
+/**
+ * Resolving P — the procedural specification the paper's prompt is built on.
+ *
+ * ── Why the plugin needs a spec at all ────────────────────────────────────
+ *
+ * A.4 is `Format(P, Σₜ, Oₜ)`, and P is the first argument. Paper mode
+ * therefore cannot assemble a paper-conformant prompt without one, even
+ * though the store ({@link ProjectStateStore}) is deliberately schema-free:
+ * notes mode never shows the model a schema, so it never needs P.
+ *
+ * ── Resolution order ─────────────────────────────────────────────────────
+ *
+ * 1. `<project>/skill-spec.json` — the file `skillstate init` writes and the
+ *    one the CLI's `--spec` already points at (`config.ts` default
+ *    `specPath: './skill-spec.json'`). A project that has customised its
+ *    procedure gets that procedure.
+ * 2. {@link GENERIC_PROCEDURE_SPEC} — the built-in, domain-neutral default.
+ *
+ * ── A malformed spec file must not reach the model ────────────────────────
+ *
+ * A half-written or hand-mangled `skill-spec.json` is exactly the kind of
+ * input that produced the v1 failure, where the spec's own instructions
+ * ("You are an autonomous CTF agent … find the flag") overrode the user. So
+ * the file is VALIDATED before it is trusted, field by field, and anything
+ * that does not typecheck falls back to the built-in spec with the reason
+ * recorded. There is no code path that feeds an unvalidated P to the model.
+ *
+ * Reads are cached per directory for the lifetime of the resolver: the
+ * `context` hook runs on every model request, and re-reading and re-validating
+ * a file that cannot change without the user editing it is pure overhead on
+ * the agent loop's hot path. {@link SpecResolver.invalidate} drops the cache
+ * for callers that do edit it.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { GENERIC_PROCEDURE_SPEC, isPlainObject } from '@skillstate/core';
+/** The file a project keeps its procedural spec in. */
+export const SPEC_FILE_NAME = 'skill-spec.json';
+const SCHEMA_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'array',
+    'object',
+]);
+function validateSchema(value, at) {
+    if (!isPlainObject(value))
+        return `${at} is not an object`;
+    const schema = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (!isPlainObject(raw))
+            return `${at}.${key} is not an object`;
+        const type = raw['type'];
+        if (typeof type !== 'string' || !SCHEMA_TYPES.has(type)) {
+            return `${at}.${key}.type must be one of ${[...SCHEMA_TYPES].join(', ')}`;
+        }
+        if (!('default' in raw))
+            return `${at}.${key}.default is required`;
+        const description = raw['description'];
+        if (description !== undefined && typeof description !== 'string') {
+            return `${at}.${key}.description must be a string`;
+        }
+        const field = { type: type, default: raw['default'] };
+        if (typeof description === 'string')
+            field.description = description;
+        schema[key] = field;
+    }
+    return schema;
+}
+/**
+ * Validate a parsed spec document. Returns the spec, or a sentence naming
+ * the first field that failed. Pure.
+ *
+ * The checks are deliberately structural only — they reject a document that
+ * could not be rendered or that would misdescribe Σₜ, and nothing subtler.
+ * Semantic review of an instructions string is not something a type check can
+ * do, and pretending otherwise would be worse than not checking.
+ */
+export function parseSpec(value) {
+    if (!isPlainObject(value))
+        return 'spec is not an object';
+    const id = value['id'];
+    if (typeof id !== 'string' || id.trim() === '')
+        return 'id must be a non-empty string';
+    const name = value['name'];
+    if (typeof name !== 'string' || name.trim() === '')
+        return 'name must be a non-empty string';
+    const version = value['version'];
+    if (typeof version !== 'string' || version.trim() === '') {
+        return 'version must be a non-empty string';
+    }
+    const instructions = value['instructions'];
+    if (typeof instructions !== 'string' || instructions.trim() === '') {
+        return 'instructions must be a non-empty string';
+    }
+    const schema = validateSchema(value['schema'], 'schema');
+    if (typeof schema === 'string')
+        return schema;
+    return { id, name, version, instructions, schema };
+}
+/**
+ * Per-project spec resolution with a cache.
+ *
+ * One instance per plugin setup. The cache key is the resolved project
+ * directory, so a single OpenCode server serving several checkouts gets a
+ * different spec per checkout without the caller managing that.
+ */
+export class SpecResolver {
+    cache = new Map();
+    /**
+     * The spec for `directory`, reading and validating the file at most once
+     * per {@link invalidate}.
+     */
+    resolve(directory) {
+        const key = path.resolve(directory);
+        const cached = this.cache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const resolution = this.load(key);
+        this.cache.set(key, resolution);
+        return resolution;
+    }
+    /** Drop the cached spec for `directory` (or for every directory). */
+    invalidate(directory) {
+        if (directory === undefined)
+            this.cache.clear();
+        else
+            this.cache.delete(path.resolve(directory));
+    }
+    load(directory) {
+        const file = path.join(directory, SPEC_FILE_NAME);
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf-8');
+        }
+        catch {
+            return { spec: GENERIC_PROCEDURE_SPEC, source: 'builtin' };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            return {
+                spec: GENERIC_PROCEDURE_SPEC,
+                source: 'builtin',
+                path: file,
+                rejected: `invalid JSON: ${String(error)}`,
+            };
+        }
+        const validated = parseSpec(parsed);
+        if (typeof validated === 'string') {
+            return {
+                spec: GENERIC_PROCEDURE_SPEC,
+                source: 'builtin',
+                path: file,
+                rejected: validated,
+            };
+        }
+        return { spec: validated, source: 'file', path: file };
+    }
+}
+//# sourceMappingURL=spec-loader.js.map

package/dist/spec-loader.js.map

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

package/dist/step-boundary.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The step boundary — §5.1's one observation per step, enforced in code.
+ *
+ * ── The divergence this fixes ─────────────────────────────────────────────
+ *
+ * The paper's Algorithm 1 alternates, once per step:
+ *
+ *     Aₜ ← Format(P, Σₜ, Oₜ);  resp ← llm(Aₜ);  Σₜ₊₁ ← Σₜ ⊕ ΔΣₜ;  Oₜ₊₁ ← execute(aₜ)
+ *
+ * One prompt, one patch, one action, one observation. The model is never
+ * given a loop of its own, so it has no opportunity to run twenty things
+ * inside one step, and the state cannot lag the work.
+ *
+ * This integration cannot own the model call or the tool execution — the
+ * OpenCode plugin API exposes neither, and that is a real limit rather than a
+ * design choice. What it can do is own the *boundary*, and that is the half
+ * that was missing. Delegating execution to the host's agent loop handed the
+ * model an unbounded inner loop, and it used it: 21 tool calls, 3 text
+ * blocks, one state patch written at the end from whatever observation was
+ * current. Two models, repeated runs. The state lagged the work, and a model
+ * whose running total lags cannot accumulate.
+ *
+ * The fix uses a capability that is present and unused: `SessionContext.tools`
+ * is handed to the `context` hook on *every* model request. So requests
+ * alternate. One may act — tools present, the host executes, the observation
+ * lands in Oₜ. The next is given no tools at all, and a model that has just
+ * acted and is asked again with nothing to call can only answer in text, which
+ * is exactly where `state_patch` lives.
+ *
+ * That is §5.1's alternation with the host standing in for both `llm` and
+ * `execute`. It is not a simulation of the loop: the host really runs the
+ * action, and the state really moves between steps.
+ *
+ * ── What it does not do ───────────────────────────────────────────────────
+ *
+ * It cannot make the model write a *good* patch, only make it answer. The
+ * merge, the validation and the retry-with-rollback are unchanged, and a
+ * patch that fails validation is still refused. This buys the paper's
+ * one-observation-per-step; it does not buy correctness of reasoning.
+ */
+export declare class StepBoundary {
+    #private;
+    /**
+     * Decide what a request may do, and remember the answer.
+     *
+     * Returns true when the model may act. A session starts in `act`, so the
+     * first request can do real work; every request after an action is a report.
+     */
+    mayAct(sessionID: string): boolean;
+    /**
+     * Record that an action ran, so the next request must report.
+     *
+     * Called when the host executed a tool on this session's behalf. There is
+     * no event that says "a tool finished" in a form the plugin can trust for
+     * this, so the boundary is advanced from the patch instead — see
+     * {@link reportRequired}. Kept as a separate method so the trigger can
+     * change without the cycle changing.
+     */
+    actionTaken(sessionID: string): void;
+    /**
+     * Whether this request must be answered with a state patch.
+     *
+     * The single question the context hook needs. It is also the whole point:
+     * the model gets one turn to act and one turn to account for it.
+     */
+    reportRequired(sessionID: string): boolean;
+    /**
+     * A patch was applied, so the next request may act again.
+     *
+     * Only an *applied* patch clears the phase. A rejected one leaves the model
+     * in `report`, which is what the retry-with-rollback in §6.3 needs: it is
+     * re-asked for the same step rather than being let off the hook to act
+     * before it has recorded anything.
+     */
+    patchApplied(sessionID: string): void;
+    /** Reset a session, on teardown or a fresh run. */
+    reset(sessionID: string): void;
+    /** Forget everything. A plugin unload must not leak a phase map. */
+    clear(): void;
+    /** How many sessions are mid-cycle, for diagnostics and tests. */
+    get size(): number;
+}
+/**
+ * Whether an action ends the procedure.
+ *
+ * Shared with the runtime so the two agree on what "finished" means. They
+ * answer the same question from the same string, and two copies of that would
+ * be two definitions to keep in step.
+ */
+export declare function isTerminalAction(action: string): boolean;
+//# sourceMappingURL=step-boundary.d.ts.map

package/dist/step-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-boundary.d.ts","sourceRoot":"","sources":["../src/step-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAQH,qBAAa,YAAY;;IAGvB;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEjC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEnC;IAED;;;;;OAKG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEzC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEpC;IAED,mDAAmD;IACnD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED,oEAAoE;IACpE,KAAK,IAAI,IAAI,CAEZ;IAED,kEAAkE;IAClE,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/step-boundary.js

@@ -0,0 +1,109 @@
+/**
+ * The step boundary — §5.1's one observation per step, enforced in code.
+ *
+ * ── The divergence this fixes ─────────────────────────────────────────────
+ *
+ * The paper's Algorithm 1 alternates, once per step:
+ *
+ *     Aₜ ← Format(P, Σₜ, Oₜ);  resp ← llm(Aₜ);  Σₜ₊₁ ← Σₜ ⊕ ΔΣₜ;  Oₜ₊₁ ← execute(aₜ)
+ *
+ * One prompt, one patch, one action, one observation. The model is never
+ * given a loop of its own, so it has no opportunity to run twenty things
+ * inside one step, and the state cannot lag the work.
+ *
+ * This integration cannot own the model call or the tool execution — the
+ * OpenCode plugin API exposes neither, and that is a real limit rather than a
+ * design choice. What it can do is own the *boundary*, and that is the half
+ * that was missing. Delegating execution to the host's agent loop handed the
+ * model an unbounded inner loop, and it used it: 21 tool calls, 3 text
+ * blocks, one state patch written at the end from whatever observation was
+ * current. Two models, repeated runs. The state lagged the work, and a model
+ * whose running total lags cannot accumulate.
+ *
+ * The fix uses a capability that is present and unused: `SessionContext.tools`
+ * is handed to the `context` hook on *every* model request. So requests
+ * alternate. One may act — tools present, the host executes, the observation
+ * lands in Oₜ. The next is given no tools at all, and a model that has just
+ * acted and is asked again with nothing to call can only answer in text, which
+ * is exactly where `state_patch` lives.
+ *
+ * That is §5.1's alternation with the host standing in for both `llm` and
+ * `execute`. It is not a simulation of the loop: the host really runs the
+ * action, and the state really moves between steps.
+ *
+ * ── What it does not do ───────────────────────────────────────────────────
+ *
+ * It cannot make the model write a *good* patch, only make it answer. The
+ * merge, the validation and the retry-with-rollback are unchanged, and a
+ * patch that fails validation is still refused. This buys the paper's
+ * one-observation-per-step; it does not buy correctness of reasoning.
+ */
+/** Actions that end the procedure rather than continuing it. */
+const TERMINAL = new Set(['done', 'complete', 'completed', 'finished', 'stop', 'end', '']);
+export class StepBoundary {
+    #phase = new Map();
+    /**
+     * Decide what a request may do, and remember the answer.
+     *
+     * Returns true when the model may act. A session starts in `act`, so the
+     * first request can do real work; every request after an action is a report.
+     */
+    mayAct(sessionID) {
+        return (this.#phase.get(sessionID) ?? 'act') === 'act';
+    }
+    /**
+     * Record that an action ran, so the next request must report.
+     *
+     * Called when the host executed a tool on this session's behalf. There is
+     * no event that says "a tool finished" in a form the plugin can trust for
+     * this, so the boundary is advanced from the patch instead — see
+     * {@link reportRequired}. Kept as a separate method so the trigger can
+     * change without the cycle changing.
+     */
+    actionTaken(sessionID) {
+        this.#phase.set(sessionID, 'report');
+    }
+    /**
+     * Whether this request must be answered with a state patch.
+     *
+     * The single question the context hook needs. It is also the whole point:
+     * the model gets one turn to act and one turn to account for it.
+     */
+    reportRequired(sessionID) {
+        return (this.#phase.get(sessionID) ?? 'act') === 'report';
+    }
+    /**
+     * A patch was applied, so the next request may act again.
+     *
+     * Only an *applied* patch clears the phase. A rejected one leaves the model
+     * in `report`, which is what the retry-with-rollback in §6.3 needs: it is
+     * re-asked for the same step rather than being let off the hook to act
+     * before it has recorded anything.
+     */
+    patchApplied(sessionID) {
+        this.#phase.set(sessionID, 'act');
+    }
+    /** Reset a session, on teardown or a fresh run. */
+    reset(sessionID) {
+        this.#phase.delete(sessionID);
+    }
+    /** Forget everything. A plugin unload must not leak a phase map. */
+    clear() {
+        this.#phase.clear();
+    }
+    /** How many sessions are mid-cycle, for diagnostics and tests. */
+    get size() {
+        return this.#phase.size;
+    }
+}
+/**
+ * Whether an action ends the procedure.
+ *
+ * Shared with the runtime so the two agree on what "finished" means. They
+ * answer the same question from the same string, and two copies of that would
+ * be two definitions to keep in step.
+ */
+export function isTerminalAction(action) {
+    return TERMINAL.has(action.trim().toLowerCase());
+}
+//# sourceMappingURL=step-boundary.js.map

package/dist/step-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-boundary.js","sourceRoot":"","sources":["../src/step-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKH,gEAAgE;AAChE,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;AAE3F,MAAM,OAAO,YAAY;IACd,MAAM,GAAG,IAAI,GAAG,EAAiB,CAAC;IAE3C;;;;;OAKG;IACH,MAAM,CAAC,SAAiB;QACtB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC;IACzD,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,SAAiB;QAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,SAAiB;QAC9B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,KAAK,CAAC,KAAK,QAAQ,CAAC;IAC5D,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,SAAiB;QAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,mDAAmD;IACnD,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAED,oEAAoE;IACpE,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,kEAAkE;IAClE,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;AACnD,CAAC"}

package/dist/system-hint.d.ts

@@ -34,11 +34,35 @@ export declare const ADVERTISED_TOOLS: readonly ['skillstate_read', 'skillstate_
  *
  * 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 byte
- * count and a pointer to `skillstate_read` — an unbounded state file must
- * not be able to grow the system prompt without limit.
+ * {@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 declare function renderStateForHint(state: Record<string, unknown>): string;
+/**
+ * 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 declare const DRIFT_NOTICE_AFTER_TURNS = 12;
 /** Options for {@link buildStateHint}. */
 export interface StateHintOptions {
     /** The state document this session has saved. */
@@ -50,7 +74,50 @@ export interface StateHintOptions {
      * hint names the merge step so the main session can fold its notes back.
      */
     scope?: string;
+    /**
+     * The fields a project `skill-spec.json` declares, when one is present.
+     *
+     * Notes mode does not ENFORCE a schema — §4.1 scopes the schema to a spec P,
+     * and notes mode has no P because it never formats an A.4 prompt. What it
+     * must not do is stay silent, and it was: a project shipped a schema, a model
+     * read it, ignored it, and wrote thirty files under a namespace it invented
+     * while the declared fields sat at their defaults. Nothing said so, and the
+     * state looked populated to a reader checking the wrong key.
+     *
+     * So the fields are stated, not enforced. A model that follows them writes
+     * the state where the spec says; one that does not has been told where the
+     * spec says, which is the difference between an override and an oversight.
+     */
+    declaredFields?: readonly string[];
+    /**
+     * True when the project is INITIALIZED — a state file exists for it.
+     *
+     * This is the whole difference between an optional side channel and a
+     * record, and the two must not be phrased the same way. Telling a model to
+     * "skip these tools when the work needs no memory" is correct advice for a
+     * scratch project and an invitation to walk away in a real one, where the
+     * user initialized skillstate precisely because the work does need it.
+     */
+    initialized?: boolean;
+    /**
+     * Turns taken since the state last changed. Set by the caller, which
+     * counts; see {@link DRIFT_NOTICE_AFTER_TURNS}.
+     */
+    turnsSinceWrite?: number;
 }
+/**
+ * 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 declare function driftNotice(turnsSinceWrite: number): string;
 /**
  * Build the system-prompt fragment.
  *

package/dist/system-hint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-hint.d.ts","sourceRoot":"","sources":["../src/system-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,YAC3B,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,CACV,CAAC;AAEX;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAezE;AAED,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAwBhE"}
+{"version":3,"file":"system-hint.d.ts","sourceRoot":"","sources":["../src/system-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,YAC3B,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,CACV,CAAC;AAEX;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAczE;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAmBD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAkDhE"}

package/dist/system-hint.js

@@ -38,23 +38,77 @@ export const ADVERTISED_TOOLS = [
  *
  * 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 byte
- * count and a pointer to `skillstate_read` — an unbounded state file must
- * not be able to grow the system prompt without limit.
+ * {@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();
-    const bytes = Buffer.byteLength(json, 'utf-8');
     return `${JSON.stringify({
         _truncated: true,
-        bytes,
+        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.
  *
@@ -74,14 +128,39 @@ export function buildStateHint(options) {
     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.';
-    return [
+    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>',
-        `Notes for this project are saved at \`${statePath}\` and survive a context reset or compaction.`,
+        purposeLine(initialized, statePath),
         '',
         renderStateForHint(state),
-        `${toolLine}${mergeLine}`,
-        '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.',
-        '</skillstate-project-notes>',
-    ].join('\n');
+        `${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

@@ -1 +1 @@
-{"version":3,"file":"system-hint.js","sourceRoot":"","sources":["../src/system-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAE3C,yEAAyE;AACzE,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,iBAAiB;IACjB,mBAAmB;IACnB,kBAAkB;CACV,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAA8B;IAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,IAAI,IAAI,CAAC,MAAM,IAAI,sBAAsB;QAAE,OAAO,IAAI,CAAC;IACvD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,GAAG,IAAI,CAAC,SAAS,CACtB;QACE,UAAU,EAAE,IAAI;QAChB,KAAK;QACL,IAAI;QACJ,IAAI,EAAE,yDAAyD;KAChE,EACD,IAAI,EACJ,CAAC,CACF,EAAE,CAAC;AACN,CAAC;AAeD;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,OAAyB;IACtD,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IACrC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;IAClC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAE/C,yEAAyE;IACzE,wEAAwE;IACxE,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,kBAAkB,IAAI,KAAK,KAAK,EAAE,CAAC,CAAC;IAC7F,MAAM,QAAQ,GAAG,YAAY,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IAE9E,MAAM,SAAS,GACb,KAAK,KAAK,EAAE;QACV,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,+JAA+J,CAAC;IAEtK,OAAO;QACL,4BAA4B;QAC5B,yCAAyC,SAAS,+CAA+C;QACjG,EAAE;QACF,kBAAkB,CAAC,KAAK,CAAC;QACzB,GAAG,QAAQ,GAAG,SAAS,EAAE;QACzB,kRAAkR;QAClR,6BAA6B;KAC9B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}
+{"version":3,"file":"system-hint.js","sourceRoot":"","sources":["../src/system-hint.ts"],"names":[],"mappings":"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"}