@skillstate/opencode 3.0.0 → 3.0.1

package/dist/feedback.js

@@ -0,0 +1,235 @@
+/**
+ * Corrective feedback for a rejected state patch, in paper mode.
+ *
+ * ── The hole this closes ─────────────────────────────────────────────────
+ *
+ * `PaperStateSink` computed a {@link SinkOutcome} for every assistant text
+ * block and `plugin.ts` discarded it. All seven rejection reasons were
+ * calculated and thrown away, so a model whose `state_patch` failed to parse
+ * received a byte-identical next prompt and no indication that anything had
+ * gone wrong.
+ *
+ * The consequences were not subtle. Σₜ stops moving — a model that has been
+ * silently failing for ten steps sees the same stale state each time and
+ * keeps producing output the integration cannot accept. On a long-horizon
+ * task, which is the entire reason the paper exists, that is total failure
+ * that looks like the model refusing to work.
+ *
+ * `SkillStateRuntime` does not have this problem: it owns the loop, so
+ * `runtime.ts:404` can re-prompt the model with `withRetryFeedback` and try
+ * again inside the same step. A host plugin cannot do that. It cannot invoke
+ * a tool on the model's behalf, and the v2 session API has no response hook
+ * to re-enter the model from.
+ *
+ * ── Where the feedback goes, and why there ───────────────────────────────
+ *
+ * Appendix A.4 gives the model exactly three things: P (instructions), Σₜ
+ * (state), and Oₜ (latest observation). A rejected patch is a fact about the
+ * environment — the integration refused it and can say why. That is an
+ * OBSERVATION, not an instruction, and Oₜ is where observations go.
+ *
+ * Putting it there rather than in P is not a stylistic choice:
+ *
+ * - P is the specification. Appending a correction to P would make the
+ *   prompt shape drift from A.4 and, worse, would inject a *behavioural*
+ *   instruction into the one surface that is supposed to be the operator's
+ *   spec. `tests/opencode/system-hint.test.ts` exists precisely to keep
+ *   behavioural instructions out of the model's view.
+ * - Oₜ is already the mechanism by which the host tells the model what
+ *   happened. Using it keeps the change inside the paper's own shape instead
+ *   of around it.
+ * - The next step's Oₜ is the tool result. Prepending the rejection to it
+ *   means the model reads, in order: what you did was rejected, and here is
+ *   the environment's response, and here is the tool output. That is the
+ *   order the events happened in.
+ *
+ * ── Why the reason is shown once ─────────────────────────────────────────
+ *
+ * A correction that repeats forever becomes wallpaper. By step ten the model
+ * has seen the same complaint nine times and it carries no more information
+ * than a constant line in the prompt would. So a rejection is delivered to
+ * exactly the next prompt and then dropped: if the model fails the same way
+ * again, that is a fresh rejection with a fresh reason, and a reader counting
+ * the prompts can see the failure is ongoing rather than stale.
+ *
+ * This also means feedback is *not* a retry mechanism. It does not re-prompt,
+ * it does not roll back, and it does not count attempts. The host's agent
+ * loop remains the executor, and §7's bounded retry cycle stays where the
+ * paper put it — inside a runtime that can actually own the loop.
+ *
+ * @non-paper — a host-integration affordance. It uses the paper's Oₜ slot but
+ * is not prescribed by the paper.
+ */
+import { invalidPatchObservation } from '@skillstate/core';
+/**
+ * Human-readable correction per rejection reason.
+ *
+ * Every reason is addressed to the model's own action, and each says what to
+ * do differently rather than merely what went wrong. A message that only
+ * reports failure gives the model nothing to correct against.
+ *
+ * `write_failed` is deliberately not here: it describes an environment fault
+ * (disk, lock, permissions), not a mistake in the model's output, and telling
+ * a model to "fix" its patch when the disk rejected the write would point it
+ * at the wrong problem.
+ */
+const FEEDBACK_BY_REASON = {
+    not_a_text_block: 'Your last response was not read as a completed text block, so no state patch was applied.',
+    duplicate: 'Your previous state patch was already applied and was not repeated.',
+    no_block: 'Your previous response contained no JSON block, so no state patch was applied. Respond with a ```json block holding exactly two keys: state_patch and action.',
+    malformed_json: 'The JSON block in your previous response did not parse, so no state patch was applied. Emit valid JSON inside a ```json fence.',
+    missing_state_patch: 'The JSON block in your previous response had no state_patch key, so nothing was applied. The block must have exactly two keys: state_patch and action.',
+    missing_action: 'The JSON block in your previous response had no string action key, so nothing was applied. The block must have exactly two keys: state_patch and action.',
+    schema_invalid: 'The state_patch in your previous response did not match this project\'s schema, so nothing was applied. Use only the fields the schema defines, with their declared types.',
+    empty_patch: 'Your previous state_patch was empty, so there was nothing to apply. Include at least one field you want to change, or omit the block if you have nothing to record.',
+    write_failed: 'Your previous state patch was valid but could not be written to disk, so the state is unchanged. This is an environment fault, not a problem with your patch.',
+};
+/**
+ * §6.4: the synthetic observation a failed step produces.
+ *
+ * Verbatim in shape from the paper — `Invalid state patch after N attempts:
+ * <last error>` — and the reason it exists rather than a retry continuing is
+ * that a step which has spent its attempts is a different event from one which
+ * is still trying. The model needs to know the step is over and the state was
+ * not written, or it has no way to tell a stalled loop from a slow one.
+ *
+ * Returns `''` when there is nothing to report, because `attempts` below one
+ * means no attempt was made and a synthetic observation describing zero
+ * attempts would be a sentence about nothing.
+ */
+/**
+ * The correction text for one rejection.
+ *
+ * Returns `''` for a reason with no entry rather than throwing or returning
+ * `undefined`. `SinkRejection` is a closed union today, so the table is total
+ * — but it is a `Record` over a type that grows, and a reason added without a
+ * message must degrade to "no correction" instead of throwing. This runs
+ * inside the plugin's event loop, where a throw would end the subscription and
+ * silently stop session scoping for the rest of the process's life.
+ */
+export function feedbackFor(rejection) {
+    return FEEDBACK_BY_REASON[rejection] ?? '';
+}
+/**
+ * Holds at most one pending correction per session.
+ *
+ * Keyed by session, because sub-agents each write their own scope: a
+ * correction for one agent's rejected patch must not be shown to another.
+ *
+ * Bounded by construction — one string per session, overwritten by the next
+ * rejection, dropped once delivered. A long-lived server running many
+ * sessions accumulates one entry per session that has failed, which is the
+ * set of sessions worth reporting on anyway, and never more per session.
+ */
+export class FeedbackQueue {
+    pending = new Map();
+    /**
+     * Record the outcome of one block.
+     *
+     * An applied patch CLEARS any pending correction: the model did the right
+     * thing, so a stale complaint must not be carried into the next prompt
+     * alongside good news. Anything else leaves the previous correction in
+     * place, because a second failure before the first was delivered is still
+     * a failure, and the newest reason is the most useful one.
+     */
+    record(sessionID, outcome) {
+        if (outcome.applied) {
+            this.pending.delete(sessionID);
+            return;
+        }
+        if (outcome.rejection === undefined)
+            return;
+        const message = feedbackFor(outcome.rejection);
+        // A rejection with no mapped message must not clear a deliverable one:
+        // showing a slightly stale reason beats showing none.
+        if (message.length > 0)
+            this.pending.set(sessionID, message);
+    }
+    /**
+     * Take the pending correction for a session, if any, and clear it.
+     *
+     * Consuming on read is what makes the correction show up exactly once. A
+     * caller that only ever peeked would turn a one-step correction into a
+     * permanent line in the prompt.
+     */
+    take(sessionID) {
+        const message = this.pending.get(sessionID);
+        if (message === undefined)
+            return undefined;
+        this.pending.delete(sessionID);
+        return message;
+    }
+    /** Peek without consuming. For diagnostics and tests. */
+    peek(sessionID) {
+        return this.pending.get(sessionID);
+    }
+    /**
+     * Take the pending correction only if no synthetic observation is owed.
+     *
+     * §6.4: when every attempt fails, the step's observation is the synthetic
+     * `Invalid state patch after N attempts: <last error>` — not the running
+     * correction, and not nothing. Delivering both would show the model two
+     * complaints, one of which is stale by definition: the correction belongs to
+     * the attempt that just ended, while the synthetic observation reports the
+     * whole step.
+     *
+     * The correction is still cleared when it is dropped. Holding it would put
+     * the same reason in front of the model a second time, on the next step,
+     * where it would be describing a step that is over.
+     */
+    takeUnlessInvalidated(sessionID, attempts, lastError) {
+        const message = this.pending.get(sessionID);
+        this.pending.delete(sessionID);
+        // `||` and not `??`: a synthetic observation for zero attempts is the empty
+        // string, and `'' ?? message` keeps the empty string. That would silence a
+        // real correction with a sentence about nothing, which is the one outcome
+        // this method exists to avoid.
+        return invalidPatchObservation(attempts, lastError) || message;
+    }
+    /** Forget everything (test isolation, plugin reload). */
+    clear() {
+        this.pending.clear();
+    }
+    /** How many sessions currently hold a pending correction. */
+    get size() {
+        return this.pending.size;
+    }
+}
+/**
+ * Prepend a correction to an observation.
+ *
+ * The observation is a single line in A.4 (`Latest Observation: …`), so the
+ * two are joined on one line rather than separated by a blank line that the
+ * template does not have. The correction is marked so the model can tell it
+ * apart from environment output — without a marker, a correction would be
+ * indistinguishable from a tool result, and the model could reasonably read
+ * it as data rather than as a report about its own last turn.
+ *
+ * A blank observation is left to carry the correction alone rather than
+ * becoming `"prefix: "`, which would read as a message addressed to nobody.
+ */
+export function applyFeedback(observation, feedback) {
+    if (feedback === undefined || feedback.length === 0)
+        return observation;
+    return applyObservation(observation, '[state patch rejected]', feedback);
+}
+/**
+ * Prepend a line from the environment to the observation slot.
+ *
+ * Shared by the two things the environment has to say to the model — a patch
+ * it refused, and an action it is carrying out — because they need the same
+ * shape and must not be told apart by accident.
+ *
+ * The marker is a parameter for exactly that reason. An earlier version reused
+ * {@link applyFeedback} for both, and the hard-coded
+ * `[state patch rejected]` would have told the model its patch was refused at
+ * the very moment the runtime was accepting it and asking for the next step —
+ * a message not merely useless but actively false, and the kind of false that
+ * makes a model re-derive state it has already recorded.
+ */
+export function applyObservation(observation, marker, line) {
+    if (line.length === 0)
+        return observation;
+    return observation.length === 0 ? `${marker} ${line}` : `${marker} ${line}\n${observation}`;
+}
+//# sourceMappingURL=feedback.js.map

package/dist/feedback.js.map

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

package/dist/index.d.ts

@@ -6,8 +6,8 @@
  * 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`.
+ * See `plugin.ts` for the design contract, in particular that notes mode
+ * (the default) never mutates `event.messages`.
  */
 export { SkillStatePlugin, PLUGIN_ID, default } from './plugin.js';
 /**
@@ -22,8 +22,38 @@ export { SessionRegistry, stateScopeFor, DEFAULT_SESSION_TTL_MS, } from './sessi
 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 { buildStateHint, renderStateForHint, ADVERTISED_TOOLS, DRIFT_NOTICE_AFTER_TURNS, 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';
+/**
+ * Paper mode — the A.4 context replacement. Pure functions plus the two
+ * halves of the write (`buildPaperPrompt` reads, `applyPaperContext`
+ * writes); the plugin composes them in `plugin.ts`.
+ */
+export { PAPER_MESSAGE_ID, applyPaperContext, HOST_ACTION_NOTE, buildPaperPrompt, currentInstruction, latestObservation, proceduralSpecWithTask, } from './paper-mode.js';
+export type { ObservationSource, PaperContextEvent, PaperMessage, PaperObservation, PaperPrompt, PaperPromptOptions, } from './paper-mode.js';
+/** The Σₜ sink that closes the paper transition in the OpenCode host. */
+export { DEFAULT_DEDUPE_CAPACITY, PaperStateSink, isTextEnded } from './response-sink.js';
+export type { PaperStateSinkOptions, SinkOutcome, SinkRejection } from './response-sink.js';
+/** Corrective feedback for a rejected patch, carried in the A.4 observation. */
+export { FeedbackQueue, applyFeedback, applyObservation, feedbackFor } from './feedback.js';
+export type { PendingFeedback } from './feedback.js';
+/** `SKILLSTATE_DEBUG_PROMPT` diagnostic — what the host actually handed us. */
+export { dumpPromptShape, dumpDrift } from './plugin.js';
+/** `SKILLSTATE_DEBUG_STEPS` diagnostic — what the paper step loop did, per step. */
+export { dumpStepTrace } from './plugin.js';
+/** `SKILLSTATE_MAX_STEPS` — the runtime-driven step ceiling, or the default. */
+export { maxStepsFromEnv } from './plugin.js';
+/** The runtime that owns the paper-mode step loop. */
+export { RuntimeDriver, DEFAULT_MAX_STEPS, DEFAULT_VALIDATION_RETRIES, INVALID_PATCH, } from './runtime.js';
+/** §5.1's one-observation-per-step boundary, enforced by withholding tools. */
+export { StepBoundary, isTerminalAction } from './step-boundary.js';
+export type { RuntimeDriverOptions, RuntimeStep } from './runtime.js';
+/** Mode resolution — `SKILLSTATE_MODE` over `skillstate.json` over default. */
+export { DEFAULT_PLUGIN_MODE, MODE_ENV_VAR, PLUGIN_MODES, asPluginMode, resolvePluginMode, } from './mode.js';
+export type { ModeResolution, ModeSource, PluginMode, ResolveModeOptions } from './mode.js';
+/** Resolving P for paper mode. */
+export { SPEC_FILE_NAME, SpecResolver, parseSpec } from './spec-loader.js';
+export type { SpecResolution, SpecSource } from './spec-loader.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":"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"}
+{"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,wBAAwB,EACxB,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;AACpB;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,yEAAyE;AACzE,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC1F,YAAY,EAAE,qBAAqB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC5F,gFAAgF;AAChF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5F,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,+EAA+E;AAC/E,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,oFAAoF;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,gFAAgF;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,sDAAsD;AACtD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,0BAA0B,EAC1B,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,+EAA+E;AAC/E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACtE,+EAA+E;AAC/E,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC5F,kCAAkC;AAClC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC3E,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -6,8 +6,8 @@
  * 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`.
+ * See `plugin.ts` for the design contract, in particular that notes mode
+ * (the default) never mutates `event.messages`.
  */
 export { SkillStatePlugin, PLUGIN_ID, default } from './plugin.js';
 /**
@@ -20,6 +20,30 @@ export { SkillStatePlugin, PLUGIN_ID, default } from './plugin.js';
 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 { buildStateHint, renderStateForHint, ADVERTISED_TOOLS, DRIFT_NOTICE_AFTER_TURNS, MAX_INLINE_STATE_CHARS, } from './system-hint.js';
 export { registerTools, normalizePatch, MAX_PATCH_BYTES } from './tools.js';
+/**
+ * Paper mode — the A.4 context replacement. Pure functions plus the two
+ * halves of the write (`buildPaperPrompt` reads, `applyPaperContext`
+ * writes); the plugin composes them in `plugin.ts`.
+ */
+export { PAPER_MESSAGE_ID, applyPaperContext, HOST_ACTION_NOTE, buildPaperPrompt, currentInstruction, latestObservation, proceduralSpecWithTask, } from './paper-mode.js';
+/** The Σₜ sink that closes the paper transition in the OpenCode host. */
+export { DEFAULT_DEDUPE_CAPACITY, PaperStateSink, isTextEnded } from './response-sink.js';
+/** Corrective feedback for a rejected patch, carried in the A.4 observation. */
+export { FeedbackQueue, applyFeedback, applyObservation, feedbackFor } from './feedback.js';
+/** `SKILLSTATE_DEBUG_PROMPT` diagnostic — what the host actually handed us. */
+export { dumpPromptShape, dumpDrift } from './plugin.js';
+/** `SKILLSTATE_DEBUG_STEPS` diagnostic — what the paper step loop did, per step. */
+export { dumpStepTrace } from './plugin.js';
+/** `SKILLSTATE_MAX_STEPS` — the runtime-driven step ceiling, or the default. */
+export { maxStepsFromEnv } from './plugin.js';
+/** The runtime that owns the paper-mode step loop. */
+export { RuntimeDriver, DEFAULT_MAX_STEPS, DEFAULT_VALIDATION_RETRIES, INVALID_PATCH, } from './runtime.js';
+/** §5.1's one-observation-per-step boundary, enforced by withholding tools. */
+export { StepBoundary, isTerminalAction } from './step-boundary.js';
+/** Mode resolution — `SKILLSTATE_MODE` over `skillstate.json` over default. */
+export { DEFAULT_PLUGIN_MODE, MODE_ENV_VAR, PLUGIN_MODES, asPluginMode, resolvePluginMode, } from './mode.js';
+/** Resolving P for paper mode. */
+export { SPEC_FILE_NAME, SpecResolver, parseSpec } from './spec-loader.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;;;;;;;;;;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"}
+{"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,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAU5E;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AASzB,yEAAyE;AACzE,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE1F,gFAAgF;AAChF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5F,+EAA+E;AAC/E,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,oFAAoF;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,gFAAgF;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,sDAAsD;AACtD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,0BAA0B,EAC1B,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,+EAA+E;AAC/E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEpE,+EAA+E;AAC/E,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAEnB,kCAAkC;AAClC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/mode.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Which integration the plugin runs as.
+ *
+ * ── Why this is a first-class, resolved value ─────────────────────────────
+ *
+ * The two modes are not variants of one behaviour; they are different
+ * contracts with the model, and picking the wrong one is a defect:
+ *
+ * - **`notes`** (default) contributes one additive, bounded fragment to
+ *   `event.system` and never touches `event.messages`. The transcript is the
+ *   host's; the agent sees its own history the way the host intends. This is
+ *   the mode that fixed the v1 failure, and it is the default for exactly
+ *   that reason.
+ * - **`paper`** replaces the model-facing context with Aₜ = (P, Σₜ, Oₜ) and
+ *   applies the `state_patch` the model emits. That is the paper's
+ *   specification, and it is a real behavioural change: the model stops
+ *   seeing its own transcript. It is opt-in.
+ *
+ * The default therefore has to be `notes`, and resolving it must be
+ * deterministic and inspectable — a plugin that silently picks paper mode
+ * because of a stray environment variable in a CI image would reproduce the
+ * exact failure this package exists to prevent.
+ *
+ * ── Precedence ───────────────────────────────────────────────────────────
+ *
+ * `SKILLSTATE_MODE` (environment) > `mode` in `<project>/skillstate.json`
+ * (file) > {@link DEFAULT_PLUGIN_MODE}. Environment wins, matching every
+ * other `SKILLSTATE_*` variable in `packages/core/src/config.ts`.
+ *
+ * ── Invalid values are reported, not swallowed ────────────────────────────
+ *
+ * A typo must not quietly select a mode nobody asked for. An unrecognised
+ * value falls back to the default AND is recorded in
+ * {@link ModeResolution.rejected}, so a caller (or a test) can see that the
+ * request was not honoured. Nothing throws: a bad config file must never
+ * stop the agent loop.
+ */
+/** The integration modes the plugin can run as. */
+export type PluginMode = 'notes' | 'paper';
+/** Every accepted mode value, in documentation order. */
+export declare const PLUGIN_MODES: readonly PluginMode[];
+/**
+ * The mode used when nothing valid selects one.
+ *
+ * `notes`, deliberately. Paper mode discards the transcript, and a
+ * default that discards the user's task is the v1 bug with a new name.
+ */
+export declare const DEFAULT_PLUGIN_MODE: PluginMode;
+/** The environment variable that selects the mode. */
+export declare const MODE_ENV_VAR = "SKILLSTATE_MODE";
+/** Where the resolved value came from. */
+export type ModeSource = 'default' | 'file' | 'env';
+/** The outcome of {@link resolvePluginMode}. */
+export interface ModeResolution {
+    /** The mode to run. Always a valid {@link PluginMode}. */
+    readonly mode: PluginMode;
+    /** Which input won. */
+    readonly source: ModeSource;
+    /** The winning input verbatim, for diagnostics. Absent for the default. */
+    readonly raw?: string;
+    /**
+     * A value that was present but not understood, and therefore ignored.
+     * Set when a higher-precedence input was invalid — the fallback is
+     * reported here rather than applied silently.
+     */
+    readonly rejected?: string;
+    /** True when `rejected` came from a higher-precedence input than `raw`. */
+    readonly rejectedOverridesValid?: boolean;
+}
+/** Narrow an arbitrary value to a {@link PluginMode}. */
+export declare function asPluginMode(value: unknown): PluginMode | undefined;
+/** Options for {@link resolvePluginMode}. */
+export interface ResolveModeOptions {
+    /** The project directory holding `skillstate.json`. */
+    readonly directory: string;
+    /**
+     * Environment to read. Defaults to `process.env`; tests pass their own so
+     * resolution is deterministic and never leaks between test cases.
+     */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+/**
+ * Resolve the plugin mode for one project.
+ *
+ * Never throws: a missing file, a corrupt file, a non-string `mode`, an
+ * unknown mode and a non-string environment value all resolve to
+ * {@link DEFAULT_PLUGIN_MODE}, and every rejected value is reported in the
+ * result so a caller can surface it.
+ *
+ * An invalid environment value does NOT fall through to the file. The
+ * environment is the higher-precedence input; if it says something
+ * unrecognised, quietly honouring a lower-precedence source instead would
+ * make the effective mode depend on a value the operator did not set. The
+ * default is used and the rejection is recorded.
+ */
+export declare function resolvePluginMode(options: ResolveModeOptions): ModeResolution;
+//# sourceMappingURL=mode.d.ts.map

package/dist/mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.d.ts","sourceRoot":"","sources":["../src/mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAKH,mDAAmD;AACnD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3C,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAAuB,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAAoB,CAAC;AAEvD,sDAAsD;AACtD,eAAO,MAAM,YAAY,oBAAoB,CAAC;AAE9C,0CAA0C;AAC1C,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC;AAEpD,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,uBAAuB;IACvB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAC3C;AAED,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAMnE;AAmBD,6CAA6C;AAC7C,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,cAAc,CAkB7E"}

package/dist/mode.js

@@ -0,0 +1,111 @@
+/**
+ * Which integration the plugin runs as.
+ *
+ * ── Why this is a first-class, resolved value ─────────────────────────────
+ *
+ * The two modes are not variants of one behaviour; they are different
+ * contracts with the model, and picking the wrong one is a defect:
+ *
+ * - **`notes`** (default) contributes one additive, bounded fragment to
+ *   `event.system` and never touches `event.messages`. The transcript is the
+ *   host's; the agent sees its own history the way the host intends. This is
+ *   the mode that fixed the v1 failure, and it is the default for exactly
+ *   that reason.
+ * - **`paper`** replaces the model-facing context with Aₜ = (P, Σₜ, Oₜ) and
+ *   applies the `state_patch` the model emits. That is the paper's
+ *   specification, and it is a real behavioural change: the model stops
+ *   seeing its own transcript. It is opt-in.
+ *
+ * The default therefore has to be `notes`, and resolving it must be
+ * deterministic and inspectable — a plugin that silently picks paper mode
+ * because of a stray environment variable in a CI image would reproduce the
+ * exact failure this package exists to prevent.
+ *
+ * ── Precedence ───────────────────────────────────────────────────────────
+ *
+ * `SKILLSTATE_MODE` (environment) > `mode` in `<project>/skillstate.json`
+ * (file) > {@link DEFAULT_PLUGIN_MODE}. Environment wins, matching every
+ * other `SKILLSTATE_*` variable in `packages/core/src/config.ts`.
+ *
+ * ── Invalid values are reported, not swallowed ────────────────────────────
+ *
+ * A typo must not quietly select a mode nobody asked for. An unrecognised
+ * value falls back to the default AND is recorded in
+ * {@link ModeResolution.rejected}, so a caller (or a test) can see that the
+ * request was not honoured. Nothing throws: a bad config file must never
+ * stop the agent loop.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Every accepted mode value, in documentation order. */
+export const PLUGIN_MODES = ['notes', 'paper'];
+/**
+ * The mode used when nothing valid selects one.
+ *
+ * `notes`, deliberately. Paper mode discards the transcript, and a
+ * default that discards the user's task is the v1 bug with a new name.
+ */
+export const DEFAULT_PLUGIN_MODE = 'notes';
+/** The environment variable that selects the mode. */
+export const MODE_ENV_VAR = 'SKILLSTATE_MODE';
+/** Narrow an arbitrary value to a {@link PluginMode}. */
+export function asPluginMode(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    return PLUGIN_MODES.includes(normalized)
+        ? normalized
+        : undefined;
+}
+function readModeFromFile(directory) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path.join(directory, 'skillstate.json'), 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return undefined;
+        const mode = parsed.mode;
+        return typeof mode === 'string' ? mode : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve the plugin mode for one project.
+ *
+ * Never throws: a missing file, a corrupt file, a non-string `mode`, an
+ * unknown mode and a non-string environment value all resolve to
+ * {@link DEFAULT_PLUGIN_MODE}, and every rejected value is reported in the
+ * result so a caller can surface it.
+ *
+ * An invalid environment value does NOT fall through to the file. The
+ * environment is the higher-precedence input; if it says something
+ * unrecognised, quietly honouring a lower-precedence source instead would
+ * make the effective mode depend on a value the operator did not set. The
+ * default is used and the rejection is recorded.
+ */
+export function resolvePluginMode(options) {
+    const { directory, env = process.env } = options;
+    const fromEnv = env[MODE_ENV_VAR];
+    if (typeof fromEnv === 'string') {
+        const mode = asPluginMode(fromEnv);
+        if (mode !== undefined)
+            return { mode, source: 'env', raw: fromEnv };
+        return { mode: DEFAULT_PLUGIN_MODE, source: 'env', rejected: fromEnv };
+    }
+    const fromFile = readModeFromFile(directory);
+    if (fromFile !== undefined) {
+        const mode = asPluginMode(fromFile);
+        if (mode !== undefined)
+            return { mode, source: 'file', raw: fromFile };
+        return { mode: DEFAULT_PLUGIN_MODE, source: 'file', rejected: fromFile };
+    }
+    return { mode: DEFAULT_PLUGIN_MODE, source: 'default' };
+}
+//# sourceMappingURL=mode.js.map

package/dist/mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.js","sourceRoot":"","sources":["../src/mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAKlC,yDAAyD;AACzD,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAe,OAAO,CAAC;AAEvD,sDAAsD;AACtD,MAAM,CAAC,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAuB9C,yDAAyD;AACzD,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChD,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC9C,OAAQ,YAAkC,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC7D,CAAC,CAAE,UAAyB;QAC5B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,SAAS,gBAAgB,CAAC,SAAiB;IACzC,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,SAAS,CAAC;QACpE,MAAM,IAAI,GAAI,MAA6B,CAAC,IAAI,CAAC;QACjD,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAaD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAA2B;IAC3D,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC;IAEjD,MAAM,OAAO,GAAG,GAAG,CAAC,YAAY,CAAC,CAAC;IAClC,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;QACrE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACzE,CAAC;IAED,MAAM,QAAQ,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;IAC7C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;QACpC,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;QACvE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAC3E,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;AAC1D,CAAC"}

package/dist/opencode-adapter.d.ts

@@ -8,9 +8,10 @@
  * 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);
+ *   `"plugins": ["@skillstate/opencode"]` (see `SkillStatePlugin` in
+ *   `src/plugin.ts` — project-local and inert when the project has no
+ *   skillstate state). NOTE: this adapter is the PAPER surface only; it is
+ *   not the host integration, and the v2 plugin does not call it;
  * - skill markdown (SKILL.md) generation is host-neutral and lives in the
  *   CLI, not in the platform adapters.
  */

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;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"opencode-adapter.d.ts","sourceRoot":"","sources":["../src/opencode-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;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.map

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