@coool/opencode-adaptive 0.0.0-stage → 1.0.1

package/dist/core/tier-policy/tier-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * User-configured tier lists (ADP-005): each tier is an ordered list of
+ * resources; list order is user policy and is never reordered by Adaptive.
+ * Normalization only removes unusable entries and exact duplicates — it
+ * never reorders and never merges look-alike names (ADP-006: similar model
+ * names across providers are never equivalent unless the user configures
+ * both, and full-reference equality below is deliberately provider-scoped).
+ */
+import { type ModelRef } from "../work-unit/types.js";
+export declare function normalizeTierList(resources: readonly ModelRef[]): ModelRef[];

package/dist/core/tier-policy/tier-list.js

@@ -0,0 +1,23 @@
+/**
+ * User-configured tier lists (ADP-005): each tier is an ordered list of
+ * resources; list order is user policy and is never reordered by Adaptive.
+ * Normalization only removes unusable entries and exact duplicates — it
+ * never reorders and never merges look-alike names (ADP-006: similar model
+ * names across providers are never equivalent unless the user configures
+ * both, and full-reference equality below is deliberately provider-scoped).
+ */
+import { sameModelRef } from "../work-unit/types.js";
+export function normalizeTierList(resources) {
+    const kept = [];
+    for (const resource of resources) {
+        if (resource.providerID.length === 0 || resource.id.length === 0) {
+            continue;
+        }
+        if (kept.some((existing) => sameModelRef(existing, resource))) {
+            continue;
+        }
+        kept.push(resource);
+    }
+    return kept;
+}
+//# sourceMappingURL=tier-list.js.map

package/dist/core/tier-policy/tier-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-list.js","sourceRoot":"","sources":["../../../src/core/tier-policy/tier-list.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAiB,MAAM,uBAAuB,CAAA;AAEnE,MAAM,UAAU,iBAAiB,CAAC,SAA8B;IAC9D,MAAM,IAAI,GAAe,EAAE,CAAA;IAC3B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjE,SAAQ;QACV,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC9D,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACrB,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["/**\n * User-configured tier lists (ADP-005): each tier is an ordered list of\n * resources; list order is user policy and is never reordered by Adaptive.\n * Normalization only removes unusable entries and exact duplicates — it\n * never reorders and never merges look-alike names (ADP-006: similar model\n * names across providers are never equivalent unless the user configures\n * both, and full-reference equality below is deliberately provider-scoped).\n */\nimport { sameModelRef, type ModelRef } from \"../work-unit/types.js\"\n\nexport function normalizeTierList(resources: readonly ModelRef[]): ModelRef[] {\n  const kept: ModelRef[] = []\n  for (const resource of resources) {\n    if (resource.providerID.length === 0 || resource.id.length === 0) {\n      continue\n    }\n    if (kept.some((existing) => sameModelRef(existing, resource))) {\n      continue\n    }\n    kept.push(resource)\n  }\n  return kept\n}\n"]}

package/dist/core/tier-policy/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Tier-policy types (ADP-002..006). Tier names are an ecosystem proposal —
+ * OpenCode has no native capability-tier API — so every tier semantic lives
+ * in this module and nowhere else.
+ */
+import type { ModelRef } from "../work-unit/types.js";
+export declare const TIERS: readonly ["quick", "standard", "advanced"];
+export type TierName = (typeof TIERS)[number];
+/** Vocabulary guard without a cast: strict member equality. */
+export declare function isTierName(tier: string): tier is TierName;
+/**
+ * Request kinds the OpenCode `context` hook exposes for the executing
+ * request. Auxiliary kinds are trivial host-internal requests (title,
+ * compaction, generate) that must not consume an unnecessarily expensive
+ * tier — this is structured host evidence, not prompt keyword matching
+ * (ADP-004).
+ */
+export declare const AUXILIARY_KINDS: readonly ["compaction", "title", "generate"];
+export type AuxiliaryKind = (typeof AUXILIARY_KINDS)[number];
+export type RequestKind = "primary" | AuxiliaryKind;
+/** Auxiliary requests route to `quick`. */
+export declare const AUXILIARY_TIER: TierName;
+/** Unambiguous fallback tier (ADP-002). */
+export declare const DEFAULT_TIER: TierName;
+/** How an explicit tier request reached the plugin (provenance for receipts). */
+export declare const TIER_REQUEST_VIAS: readonly ["manual-command", "session-setting"];
+export type TierRequestVia = (typeof TIER_REQUEST_VIAS)[number];
+export interface TierRequest {
+    readonly tier: TierName;
+    readonly via: TierRequestVia;
+}
+/**
+ * Everything the ladder may look at, all optional except the configuration
+ * view. Every signal is a structured field supplied by the adapter — never
+ * text mined from a prompt.
+ */
+export interface RoutingInput {
+    /** Explicit user/model pin (manual control); always wins (ADP-002). */
+    readonly pin?: ModelRef | undefined;
+    /** Explicit tier request (manual command or session setting). */
+    readonly tierRequest?: TierRequest | undefined;
+    /** OpenCode agent name of the executing request, when the host supplies one. */
+    readonly agent?: string | undefined;
+    /** Request kind from the `context` hook, when known. */
+    readonly requestKind?: RequestKind | undefined;
+    /** User-configured agent-name → tier mapping (role hints are user policy). */
+    readonly agentTiers?: Readonly<Record<string, TierName>> | undefined;
+    /**
+     * Tiers that currently have at least one configured resource (ADP-005).
+     * A tier without resources can never be honored — Adaptive does not
+     * invent resources and never borrows across tiers (GOAL tenet 4).
+     */
+    readonly configuredTiers: readonly TierName[];
+}
+/** Why the ladder produced a tier decision (receipt provenance). */
+export declare const ROUTING_SOURCES: readonly ["pin", "tier-request", "agent-role", "auxiliary-request", "ambiguity", "default"];
+export type RoutingSource = (typeof ROUTING_SOURCES)[number];
+export declare const DEFER_REASONS: readonly ["tier-not-configured"];
+export type DeferReason = (typeof DEFER_REASONS)[number];
+/**
+ * Routing outcome (ADP-002/003):
+ * - `pin` — route to the pinned resource.
+ * - `tier` — route within the named tier.
+ * - `defer` — Adaptive has no reason to override ordinary OpenCode behavior;
+ *   the unit keeps OpenCode's model choice. `tier` records which tier the
+ *   ladder resolved to before the configuration gate blocked it.
+ */
+export type RoutingDecision = {
+    readonly kind: "pin";
+    readonly model: ModelRef;
+} | {
+    readonly kind: "tier";
+    readonly tier: TierName;
+    readonly source: RoutingSource;
+} | {
+    readonly kind: "defer";
+    readonly tier: TierName;
+    readonly reason: DeferReason;
+};
+/** True only for the trivial auxiliary request kinds. */
+export declare function isAuxiliary(kind: RequestKind): boolean;
+/**
+ * Escalation ladder order (GOAL capability escalation): `quick` → `standard`
+ * → `advanced`. `advanced` is the last tier — there is no next.
+ */
+export declare function nextTier(tier: TierName): TierName | undefined;

package/dist/core/tier-policy/types.js

@@ -0,0 +1,49 @@
+export const TIERS = ["quick", "standard", "advanced"];
+/** Vocabulary guard without a cast: strict member equality. */
+export function isTierName(tier) {
+    return TIERS.some((name) => name === tier);
+}
+/**
+ * Request kinds the OpenCode `context` hook exposes for the executing
+ * request. Auxiliary kinds are trivial host-internal requests (title,
+ * compaction, generate) that must not consume an unnecessarily expensive
+ * tier — this is structured host evidence, not prompt keyword matching
+ * (ADP-004).
+ */
+export const AUXILIARY_KINDS = [
+    "compaction",
+    "title",
+    "generate",
+];
+/** Auxiliary requests route to `quick`. */
+export const AUXILIARY_TIER = "quick";
+/** Unambiguous fallback tier (ADP-002). */
+export const DEFAULT_TIER = "standard";
+/** How an explicit tier request reached the plugin (provenance for receipts). */
+export const TIER_REQUEST_VIAS = [
+    "manual-command",
+    "session-setting",
+];
+/** Why the ladder produced a tier decision (receipt provenance). */
+export const ROUTING_SOURCES = [
+    "pin",
+    "tier-request",
+    "agent-role",
+    "auxiliary-request",
+    "ambiguity",
+    "default",
+];
+export const DEFER_REASONS = ["tier-not-configured"];
+/** True only for the trivial auxiliary request kinds. */
+export function isAuxiliary(kind) {
+    return kind !== "primary";
+}
+/**
+ * Escalation ladder order (GOAL capability escalation): `quick` → `standard`
+ * → `advanced`. `advanced` is the last tier — there is no next.
+ */
+export function nextTier(tier) {
+    const index = TIERS.indexOf(tier);
+    return TIERS[index + 1];
+}
+//# sourceMappingURL=types.js.map

package/dist/core/tier-policy/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/tier-policy/types.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,CAAsC,CAAA;AAI3F,+DAA+D;AAC/D,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,YAAY;IACZ,OAAO;IACP,UAAU;CAC0B,CAAA;AAMtC,2CAA2C;AAC3C,MAAM,CAAC,MAAM,cAAc,GAAa,OAAO,CAAA;AAE/C,2CAA2C;AAC3C,MAAM,CAAC,MAAM,YAAY,GAAa,UAAU,CAAA;AAEhD,iFAAiF;AACjF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,gBAAgB;IAChB,iBAAiB;CACmB,CAAA;AAiCtC,oEAAoE;AACpE,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,KAAK;IACL,cAAc;IACd,YAAY;IACZ,mBAAmB;IACnB,WAAW;IACX,SAAS;CAC2B,CAAA;AAItC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,qBAAqB,CAAsC,CAAA;AAiBzF,yDAAyD;AACzD,MAAM,UAAU,WAAW,CAAC,IAAiB;IAC3C,OAAO,IAAI,KAAK,SAAS,CAAA;AAC3B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAc;IACrC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,OAAO,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;AACzB,CAAC","sourcesContent":["/**\n * Tier-policy types (ADP-002..006). Tier names are an ecosystem proposal —\n * OpenCode has no native capability-tier API — so every tier semantic lives\n * in this module and nowhere else.\n */\nimport type { ModelRef } from \"../work-unit/types.js\"\n\nexport const TIERS = [\"quick\", \"standard\", \"advanced\"] as const satisfies readonly string[]\n\nexport type TierName = (typeof TIERS)[number]\n\n/** Vocabulary guard without a cast: strict member equality. */\nexport function isTierName(tier: string): tier is TierName {\n  return TIERS.some((name) => name === tier)\n}\n\n/**\n * Request kinds the OpenCode `context` hook exposes for the executing\n * request. Auxiliary kinds are trivial host-internal requests (title,\n * compaction, generate) that must not consume an unnecessarily expensive\n * tier — this is structured host evidence, not prompt keyword matching\n * (ADP-004).\n */\nexport const AUXILIARY_KINDS = [\n  \"compaction\",\n  \"title\",\n  \"generate\",\n] as const satisfies readonly string[]\n\nexport type AuxiliaryKind = (typeof AUXILIARY_KINDS)[number]\n\nexport type RequestKind = \"primary\" | AuxiliaryKind\n\n/** Auxiliary requests route to `quick`. */\nexport const AUXILIARY_TIER: TierName = \"quick\"\n\n/** Unambiguous fallback tier (ADP-002). */\nexport const DEFAULT_TIER: TierName = \"standard\"\n\n/** How an explicit tier request reached the plugin (provenance for receipts). */\nexport const TIER_REQUEST_VIAS = [\n  \"manual-command\",\n  \"session-setting\",\n] as const satisfies readonly string[]\n\nexport type TierRequestVia = (typeof TIER_REQUEST_VIAS)[number]\n\nexport interface TierRequest {\n  readonly tier: TierName\n  readonly via: TierRequestVia\n}\n\n/**\n * Everything the ladder may look at, all optional except the configuration\n * view. Every signal is a structured field supplied by the adapter — never\n * text mined from a prompt.\n */\nexport interface RoutingInput {\n  /** Explicit user/model pin (manual control); always wins (ADP-002). */\n  readonly pin?: ModelRef | undefined\n  /** Explicit tier request (manual command or session setting). */\n  readonly tierRequest?: TierRequest | undefined\n  /** OpenCode agent name of the executing request, when the host supplies one. */\n  readonly agent?: string | undefined\n  /** Request kind from the `context` hook, when known. */\n  readonly requestKind?: RequestKind | undefined\n  /** User-configured agent-name → tier mapping (role hints are user policy). */\n  readonly agentTiers?: Readonly<Record<string, TierName>> | undefined\n  /**\n   * Tiers that currently have at least one configured resource (ADP-005).\n   * A tier without resources can never be honored — Adaptive does not\n   * invent resources and never borrows across tiers (GOAL tenet 4).\n   */\n  readonly configuredTiers: readonly TierName[]\n}\n\n/** Why the ladder produced a tier decision (receipt provenance). */\nexport const ROUTING_SOURCES = [\n  \"pin\",\n  \"tier-request\",\n  \"agent-role\",\n  \"auxiliary-request\",\n  \"ambiguity\",\n  \"default\",\n] as const satisfies readonly string[]\n\nexport type RoutingSource = (typeof ROUTING_SOURCES)[number]\n\nexport const DEFER_REASONS = [\"tier-not-configured\"] as const satisfies readonly string[]\n\nexport type DeferReason = (typeof DEFER_REASONS)[number]\n\n/**\n * Routing outcome (ADP-002/003):\n * - `pin` — route to the pinned resource.\n * - `tier` — route within the named tier.\n * - `defer` — Adaptive has no reason to override ordinary OpenCode behavior;\n *   the unit keeps OpenCode's model choice. `tier` records which tier the\n *   ladder resolved to before the configuration gate blocked it.\n */\nexport type RoutingDecision =\n  | { readonly kind: \"pin\"; readonly model: ModelRef }\n  | { readonly kind: \"tier\"; readonly tier: TierName; readonly source: RoutingSource }\n  | { readonly kind: \"defer\"; readonly tier: TierName; readonly reason: DeferReason }\n\n/** True only for the trivial auxiliary request kinds. */\nexport function isAuxiliary(kind: RequestKind): boolean {\n  return kind !== \"primary\"\n}\n\n/**\n * Escalation ladder order (GOAL capability escalation): `quick` → `standard`\n * → `advanced`. `advanced` is the last tier — there is no next.\n */\nexport function nextTier(tier: TierName): TierName | undefined {\n  const index = TIERS.indexOf(tier)\n  return TIERS[index + 1]\n}\n"]}

package/dist/core/work-unit/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./interruption.js";
+export * from "./types.js";
+export * from "./tracker.js";

package/dist/core/work-unit/index.js

@@ -0,0 +1,4 @@
+export * from "./interruption.js";
+export * from "./types.js";
+export * from "./tracker.js";
+//# sourceMappingURL=index.js.map

package/dist/core/work-unit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/work-unit/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA","sourcesContent":["export * from \"./interruption.js\"\nexport * from \"./types.js\"\nexport * from \"./tracker.js\"\n"]}

package/dist/core/work-unit/interruption.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Why an OpenCode execution was interrupted. Values mirror the verified
+ * `session.execution.interrupted` event payload (`reason`), which OpenCode
+ * guarantees to be one of these four.
+ */
+export declare const INTERRUPT_REASONS: readonly ["user", "shutdown", "superseded", "inactivity"];
+export type InterruptReason = (typeof INTERRUPT_REASONS)[number];

package/dist/core/work-unit/interruption.js

@@ -0,0 +1,12 @@
+/**
+ * Why an OpenCode execution was interrupted. Values mirror the verified
+ * `session.execution.interrupted` event payload (`reason`), which OpenCode
+ * guarantees to be one of these four.
+ */
+export const INTERRUPT_REASONS = [
+    "user",
+    "shutdown",
+    "superseded",
+    "inactivity",
+];
+//# sourceMappingURL=interruption.js.map

package/dist/core/work-unit/interruption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interruption.js","sourceRoot":"","sources":["../../../src/core/work-unit/interruption.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,MAAM;IACN,UAAU;IACV,YAAY;IACZ,YAAY;CACwB,CAAA","sourcesContent":["/**\n * Why an OpenCode execution was interrupted. Values mirror the verified\n * `session.execution.interrupted` event payload (`reason`), which OpenCode\n * guarantees to be one of these four.\n */\nexport const INTERRUPT_REASONS = [\n  \"user\",\n  \"shutdown\",\n  \"superseded\",\n  \"inactivity\",\n] as const satisfies readonly string[]\n\nexport type InterruptReason = (typeof INTERRUPT_REASONS)[number]\n"]}

package/dist/core/work-unit/tracker.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Episode tracker (ADP-001): a deterministic, clock-free state machine over
+ * normalized work-unit events, keyed by session. All timestamps come from the
+ * events themselves, so behavior is fully reproducible.
+ *
+ * Self-switch attribution: `session.model.selected` fires for both manual and
+ * plugin-made switches. Before performing `session.switchModel` our adapter
+ * calls `noteOwnSwitch`; the next `model-selected` event for that session
+ * matching the noted reference is attributed `selected-adaptive` and consumes
+ * the note. A non-matching selection clears the note, so a stale note can
+ * never claim a later user pick — the failure direction is always
+ * "our switch looks external" (treated as a manual pick, left alone), never
+ * the reverse. At most one note per session is kept: a newer note replaces an
+ * unconsumed older one, and the older switch's event (if it ever arrives) is
+ * then attributed external — again the safe direction, since the adapter
+ * serializes per-session switches.
+ */
+import { type ActiveUnit, type ApplyResult, type ModelRef, type ModelTransition, type OpenedResult, type SelectionResult, type WorkUnitEvent } from "./types.js";
+export declare class WorkUnitTracker {
+    #private;
+    /**
+     * Bounded per-session maps (last model, pending own-switch note): a
+     * long-lived host meets unbounded short-lived sessions, and the model
+     * knowledge of a long-gone session is worthless. Insertion order gives the
+     * eviction (oldest session first).
+     */
+    static readonly MAX_TRACKED_SESSIONS = 1024;
+    /**
+     * Arms the pending own-switch note consumed by the next matching
+     * `model-selected` event for this session.
+     */
+    noteOwnSwitch(sessionID: string, model: ModelRef): void;
+    /**
+     * Raises each session's episode floor. Used at startup: unit ids are
+     * durable keys (`${sessionID}#${episode}`) persisted in receipts and
+     * parked work, so after a restart the counters must never re-mint an id
+     * a persisted record already carries — a collision would replace parked
+     * work and misattribute receipt outcomes.
+     */
+    seedEpisodes(seeds: ReadonlyMap<string, number>): void;
+    /** Apply an execution-started event; the tracker always opens a unit. */
+    apply(event: Extract<WorkUnitEvent, {
+        kind: "execution-started";
+    }>): OpenedResult;
+    apply(event: Extract<WorkUnitEvent, {
+        kind: "model-selected" | "model-request";
+    }>): SelectionResult;
+    apply(event: WorkUnitEvent): ApplyResult;
+    /** The open unit for a session, if any. */
+    active(sessionID: string): ActiveUnit | undefined;
+    /** Last model known to be in effect for a session, across episodes. */
+    lastModel(sessionID: string): ModelTransition | undefined;
+}

package/dist/core/work-unit/tracker.js

@@ -0,0 +1,156 @@
+var _a;
+/**
+ * Episode tracker (ADP-001): a deterministic, clock-free state machine over
+ * normalized work-unit events, keyed by session. All timestamps come from the
+ * events themselves, so behavior is fully reproducible.
+ *
+ * Self-switch attribution: `session.model.selected` fires for both manual and
+ * plugin-made switches. Before performing `session.switchModel` our adapter
+ * calls `noteOwnSwitch`; the next `model-selected` event for that session
+ * matching the noted reference is attributed `selected-adaptive` and consumes
+ * the note. A non-matching selection clears the note, so a stale note can
+ * never claim a later user pick — the failure direction is always
+ * "our switch looks external" (treated as a manual pick, left alone), never
+ * the reverse. At most one note per session is kept: a newer note replaces an
+ * unconsumed older one, and the older switch's event (if it ever arrives) is
+ * then attributed external — again the safe direction, since the adapter
+ * serializes per-session switches.
+ */
+import { sameModelRef, } from "./types.js";
+/** Insert into a bounded map, evicting the oldest (first) entry past the cap. */
+function setBounded(map, key, value, cap) {
+    if (!map.has(key) && map.size >= cap) {
+        for (const oldest of map.keys()) {
+            map.delete(oldest);
+            break;
+        }
+    }
+    map.set(key, value);
+}
+export class WorkUnitTracker {
+    #active = new Map();
+    // Intentionally unbounded: evicting an episode counter could re-mint a unit
+    // id (`${sessionID}#${episode}`) that a persisted receipt or parked record
+    // already carries — a collision replaces parked work. The map holds one
+    // number per session ever seen; that growth is bounded by session churn,
+    // not by episodes.
+    #episodes = new Map();
+    /**
+     * Bounded per-session maps (last model, pending own-switch note): a
+     * long-lived host meets unbounded short-lived sessions, and the model
+     * knowledge of a long-gone session is worthless. Insertion order gives the
+     * eviction (oldest session first).
+     */
+    static MAX_TRACKED_SESSIONS = 1024;
+    #lastModel = new Map();
+    #pendingOwn = new Map();
+    /**
+     * Arms the pending own-switch note consumed by the next matching
+     * `model-selected` event for this session.
+     */
+    noteOwnSwitch(sessionID, model) {
+        setBounded(this.#pendingOwn, sessionID, model, _a.MAX_TRACKED_SESSIONS);
+    }
+    /**
+     * Raises each session's episode floor. Used at startup: unit ids are
+     * durable keys (`${sessionID}#${episode}`) persisted in receipts and
+     * parked work, so after a restart the counters must never re-mint an id
+     * a persisted record already carries — a collision would replace parked
+     * work and misattribute receipt outcomes.
+     */
+    seedEpisodes(seeds) {
+        for (const [sessionID, episode] of seeds) {
+            if (episode > (this.#episodes.get(sessionID) ?? 0))
+                this.#episodes.set(sessionID, episode);
+        }
+    }
+    apply(event) {
+        switch (event.kind) {
+            case "execution-started": {
+                const previous = this.#active.get(event.sessionID);
+                if (previous !== undefined)
+                    this.#active.delete(event.sessionID);
+                // A new execution on a session that still has an active unit means
+                // the previous execution was superseded (matches OpenCode's
+                // `interrupted{reason:"superseded"}` semantics).
+                const superseded = previous && {
+                    ...previous,
+                    kind: "interrupted",
+                    closedAt: event.at,
+                    reason: "superseded",
+                };
+                const episode = (this.#episodes.get(event.sessionID) ?? 0) + 1;
+                this.#episodes.set(event.sessionID, episode);
+                const unit = {
+                    kind: "active",
+                    id: `${event.sessionID}#${String(episode)}`,
+                    sessionID: event.sessionID,
+                    episode,
+                    startedAt: event.at,
+                    model: this.#lastModel.get(event.sessionID)?.model,
+                    transitions: [],
+                };
+                this.#active.set(event.sessionID, unit);
+                return superseded ? { kind: "opened", unit, superseded } : { kind: "opened", unit };
+            }
+            case "execution-succeeded":
+            case "execution-failed":
+            case "execution-interrupted": {
+                const current = this.#active.get(event.sessionID);
+                if (current === undefined)
+                    return { kind: "ignored", reason: "terminal-without-active-unit" };
+                this.#active.delete(event.sessionID);
+                const base = { ...current, closedAt: event.at };
+                if (event.kind === "execution-succeeded") {
+                    return { kind: "closed", unit: { ...base, kind: "succeeded" } };
+                }
+                if (event.kind === "execution-failed") {
+                    return { kind: "closed", unit: { ...base, kind: "failed", error: event.error } };
+                }
+                return { kind: "closed", unit: { ...base, kind: "interrupted", reason: event.reason } };
+            }
+            case "model-selected": {
+                const adaptive = this.#consumePendingOwn(event.sessionID, event.model);
+                return this.#trackModel(event.sessionID, event.at, event.model, adaptive ? "selected-adaptive" : "selected-external");
+            }
+            case "model-request":
+                // Context-hook observations never consume the pending note: only
+                // actual selection events resolve it.
+                return this.#trackModel(event.sessionID, event.at, event.model, "request");
+        }
+    }
+    /** The open unit for a session, if any. */
+    active(sessionID) {
+        return this.#active.get(sessionID);
+    }
+    /** Last model known to be in effect for a session, across episodes. */
+    lastModel(sessionID) {
+        return this.#lastModel.get(sessionID);
+    }
+    /**
+     * Returns whether the pending note matched. The note is consumed on any
+     * selection event: matched → `selected-adaptive`; unmatched (or absent) →
+     * `selected-external` with the note dropped.
+     */
+    #consumePendingOwn(sessionID, model) {
+        const pending = this.#pendingOwn.get(sessionID);
+        this.#pendingOwn.delete(sessionID);
+        return pending !== undefined && sameModelRef(pending, model);
+    }
+    #trackModel(sessionID, at, model, source) {
+        const transition = { at, model, source };
+        setBounded(this.#lastModel, sessionID, transition, _a.MAX_TRACKED_SESSIONS);
+        const current = this.#active.get(sessionID);
+        if (current === undefined)
+            return { kind: "model-noted", transition };
+        const unit = {
+            ...current,
+            model,
+            transitions: [...current.transitions, transition],
+        };
+        this.#active.set(sessionID, unit);
+        return { kind: "model-tracked", unit, transition };
+    }
+}
+_a = WorkUnitTracker;
+//# sourceMappingURL=tracker.js.map

package/dist/core/work-unit/tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.js","sourceRoot":"","sources":["../../../src/core/work-unit/tracker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Episode tracker (ADP-001): a deterministic, clock-free state machine over\n * normalized work-unit events, keyed by session. All timestamps come from the\n * events themselves, so behavior is fully reproducible.\n *\n * Self-switch attribution: `session.model.selected` fires for both manual and\n * plugin-made switches. Before performing `session.switchModel` our adapter\n * calls `noteOwnSwitch`; the next `model-selected` event for that session\n * matching the noted reference is attributed `selected-adaptive` and consumes\n * the note. A non-matching selection clears the note, so a stale note can\n * never claim a later user pick — the failure direction is always\n * \"our switch looks external\" (treated as a manual pick, left alone), never\n * the reverse. At most one note per session is kept: a newer note replaces an\n * unconsumed older one, and the older switch's event (if it ever arrives) is\n * then attributed external — again the safe direction, since the adapter\n * serializes per-session switches.\n */\nimport {\n  sameModelRef,\n  type ActiveUnit,\n  type ApplyResult,\n  type ClosedUnit,\n  type ModelRef,\n  type ModelSource,\n  type ModelTransition,\n  type OpenedResult,\n  type SelectionResult,\n  type WorkUnitEvent,\n} from \"./types.js\"\n\n/** Insert into a bounded map, evicting the oldest (first) entry past the cap. */\nfunction setBounded<K, V>(map: Map<K, V>, key: K, value: V, cap: number): void {\n  if (!map.has(key) && map.size >= cap) {\n    for (const oldest of map.keys()) {\n      map.delete(oldest)\n      break\n    }\n  }\n  map.set(key, value)\n}\n\nexport class WorkUnitTracker {\n  readonly #active = new Map<string, ActiveUnit>()\n  // Intentionally unbounded: evicting an episode counter could re-mint a unit\n  // id (`${sessionID}#${episode}`) that a persisted receipt or parked record\n  // already carries — a collision replaces parked work. The map holds one\n  // number per session ever seen; that growth is bounded by session churn,\n  // not by episodes.\n  readonly #episodes = new Map<string, number>()\n  /**\n   * Bounded per-session maps (last model, pending own-switch note): a\n   * long-lived host meets unbounded short-lived sessions, and the model\n   * knowledge of a long-gone session is worthless. Insertion order gives the\n   * eviction (oldest session first).\n   */\n  static readonly MAX_TRACKED_SESSIONS = 1024\n  readonly #lastModel = new Map<string, ModelTransition>()\n  readonly #pendingOwn = new Map<string, ModelRef>()\n\n  /**\n   * Arms the pending own-switch note consumed by the next matching\n   * `model-selected` event for this session.\n   */\n  noteOwnSwitch(sessionID: string, model: ModelRef): void {\n    setBounded(this.#pendingOwn, sessionID, model, WorkUnitTracker.MAX_TRACKED_SESSIONS)\n  }\n\n  /**\n   * Raises each session's episode floor. Used at startup: unit ids are\n   * durable keys (`${sessionID}#${episode}`) persisted in receipts and\n   * parked work, so after a restart the counters must never re-mint an id\n   * a persisted record already carries — a collision would replace parked\n   * work and misattribute receipt outcomes.\n   */\n  seedEpisodes(seeds: ReadonlyMap<string, number>): void {\n    for (const [sessionID, episode] of seeds) {\n      if (episode > (this.#episodes.get(sessionID) ?? 0)) this.#episodes.set(sessionID, episode)\n    }\n  }\n\n  /** Apply an execution-started event; the tracker always opens a unit. */\n  apply(event: Extract<WorkUnitEvent, { kind: \"execution-started\" }>): OpenedResult\n  apply(\n    event: Extract<WorkUnitEvent, { kind: \"model-selected\" | \"model-request\" }>,\n  ): SelectionResult\n  apply(event: WorkUnitEvent): ApplyResult\n  apply(event: WorkUnitEvent): ApplyResult {\n    switch (event.kind) {\n      case \"execution-started\": {\n        const previous = this.#active.get(event.sessionID)\n        if (previous !== undefined) this.#active.delete(event.sessionID)\n        // A new execution on a session that still has an active unit means\n        // the previous execution was superseded (matches OpenCode's\n        // `interrupted{reason:\"superseded\"}` semantics).\n        const superseded: ClosedUnit | undefined = previous && {\n          ...previous,\n          kind: \"interrupted\",\n          closedAt: event.at,\n          reason: \"superseded\",\n        }\n        const episode = (this.#episodes.get(event.sessionID) ?? 0) + 1\n        this.#episodes.set(event.sessionID, episode)\n        const unit: ActiveUnit = {\n          kind: \"active\",\n          id: `${event.sessionID}#${String(episode)}`,\n          sessionID: event.sessionID,\n          episode,\n          startedAt: event.at,\n          model: this.#lastModel.get(event.sessionID)?.model,\n          transitions: [],\n        }\n        this.#active.set(event.sessionID, unit)\n        return superseded ? { kind: \"opened\", unit, superseded } : { kind: \"opened\", unit }\n      }\n      case \"execution-succeeded\":\n      case \"execution-failed\":\n      case \"execution-interrupted\": {\n        const current = this.#active.get(event.sessionID)\n        if (current === undefined)\n          return { kind: \"ignored\", reason: \"terminal-without-active-unit\" }\n        this.#active.delete(event.sessionID)\n        const base = { ...current, closedAt: event.at }\n        if (event.kind === \"execution-succeeded\") {\n          return { kind: \"closed\", unit: { ...base, kind: \"succeeded\" } }\n        }\n        if (event.kind === \"execution-failed\") {\n          return { kind: \"closed\", unit: { ...base, kind: \"failed\", error: event.error } }\n        }\n        return { kind: \"closed\", unit: { ...base, kind: \"interrupted\", reason: event.reason } }\n      }\n      case \"model-selected\": {\n        const adaptive = this.#consumePendingOwn(event.sessionID, event.model)\n        return this.#trackModel(\n          event.sessionID,\n          event.at,\n          event.model,\n          adaptive ? \"selected-adaptive\" : \"selected-external\",\n        )\n      }\n      case \"model-request\":\n        // Context-hook observations never consume the pending note: only\n        // actual selection events resolve it.\n        return this.#trackModel(event.sessionID, event.at, event.model, \"request\")\n    }\n  }\n\n  /** The open unit for a session, if any. */\n  active(sessionID: string): ActiveUnit | undefined {\n    return this.#active.get(sessionID)\n  }\n\n  /** Last model known to be in effect for a session, across episodes. */\n  lastModel(sessionID: string): ModelTransition | undefined {\n    return this.#lastModel.get(sessionID)\n  }\n\n  /**\n   * Returns whether the pending note matched. The note is consumed on any\n   * selection event: matched → `selected-adaptive`; unmatched (or absent) →\n   * `selected-external` with the note dropped.\n   */\n  #consumePendingOwn(sessionID: string, model: ModelRef): boolean {\n    const pending = this.#pendingOwn.get(sessionID)\n    this.#pendingOwn.delete(sessionID)\n    return pending !== undefined && sameModelRef(pending, model)\n  }\n\n  #trackModel(sessionID: string, at: number, model: ModelRef, source: ModelSource): ApplyResult {\n    const transition: ModelTransition = { at, model, source }\n    setBounded(this.#lastModel, sessionID, transition, WorkUnitTracker.MAX_TRACKED_SESSIONS)\n    const current = this.#active.get(sessionID)\n    if (current === undefined) return { kind: \"model-noted\", transition }\n    const unit: ActiveUnit = {\n      ...current,\n      model,\n      transitions: [...current.transitions, transition],\n    }\n    this.#active.set(sessionID, unit)\n    return { kind: \"model-tracked\", unit, transition }\n  }\n}\n"]}

package/dist/core/work-unit/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Work-unit model (ADP-001): one unit is exactly one OpenCode execution
+ * episode — `session.execution.started` → `succeeded`/`failed`/`interrupted`.
+ * Tool/step/text continuations never open, close, or split a unit (only the
+ * execution events do); a subagent runs in its own session and therefore gets
+ * its own units; a later continuation on the same session (e.g. a new /goal
+ * round) is a new episode of that session.
+ */
+import type { InterruptReason } from "./interruption.js";
+/** OpenCode model reference (`Model.Ref`): provider, model, optional variant. */
+export interface ModelRef {
+    readonly providerID: string;
+    readonly id: string;
+    readonly variant?: string | undefined;
+}
+/** Full-field equality; a variant change is a different reference. */
+export declare function sameModelRef(a: ModelRef, b: ModelRef): boolean;
+/**
+ * How the model in effect became known. `selected-*` comes from the
+ * `session.model.selected` event (which fires for both manual and
+ * plugin-made switches — the tracker resolves which via pending own-switch
+ * notes, see `WorkUnitTracker.noteOwnSwitch`); `request` comes from the
+ * `context` hook and reports the model actually executing.
+ */
+export declare const MODEL_SOURCES: readonly ["selected-adaptive", "selected-external", "request"];
+export type ModelSource = (typeof MODEL_SOURCES)[number];
+export interface ModelTransition {
+    readonly at: number;
+    readonly model: ModelRef;
+    readonly source: ModelSource;
+}
+/**
+ * Minimal shape of the wire `Session.StructuredError` carried by
+ * `session.execution.failed` (`response.body` is deliberately dropped here —
+ * the adapter folds it into bounded `ErrorEvidence` for the classifier).
+ */
+export interface ExecutionError {
+    readonly type: string;
+    readonly message: string;
+    readonly status?: number | undefined;
+    readonly retryAfterMs?: number | undefined;
+}
+/**
+ * The episode lifecycle. `kind` doubles as status: `"active"` while the
+ * execution runs, then the terminal kind it closed with.
+ */
+interface UnitBase {
+    /** Stable per-episode identifier: `${sessionID}#${episode}`. */
+    readonly id: string;
+    readonly sessionID: string;
+    /** 1-based count of episodes started for this session (tracker lifetime). */
+    readonly episode: number;
+    readonly startedAt: number;
+    /**
+     * Model in effect for the unit: seeded from the last known selection when
+     * the unit opens, then updated by transitions.
+     */
+    readonly model?: ModelRef | undefined;
+    readonly transitions: readonly ModelTransition[];
+}
+export interface ActiveUnit extends UnitBase {
+    readonly kind: "active";
+}
+export interface SucceededUnit extends UnitBase {
+    readonly kind: "succeeded";
+    readonly closedAt: number;
+}
+export interface FailedUnit extends UnitBase {
+    readonly kind: "failed";
+    readonly closedAt: number;
+    readonly error: ExecutionError;
+}
+export interface InterruptedUnit extends UnitBase {
+    readonly kind: "interrupted";
+    readonly closedAt: number;
+    readonly reason: InterruptReason;
+}
+export type ClosedUnit = SucceededUnit | FailedUnit | InterruptedUnit;
+export type WorkUnit = ActiveUnit | ClosedUnit;
+/**
+ * Normalized episode events. The OpenCode adapter unwraps host event payloads
+ * (`event.data.*`) and forwards them here; `model-request` is fed from the
+ * `context` session hook.
+ */
+export type WorkUnitEvent = {
+    readonly kind: "execution-started";
+    readonly sessionID: string;
+    readonly at: number;
+} | {
+    readonly kind: "execution-succeeded";
+    readonly sessionID: string;
+    readonly at: number;
+} | {
+    readonly kind: "execution-failed";
+    readonly sessionID: string;
+    readonly at: number;
+    readonly error: ExecutionError;
+} | {
+    readonly kind: "execution-interrupted";
+    readonly sessionID: string;
+    readonly at: number;
+    readonly reason: InterruptReason;
+} | {
+    readonly kind: "model-selected";
+    readonly sessionID: string;
+    readonly at: number;
+    readonly model: ModelRef;
+} | {
+    readonly kind: "model-request";
+    readonly sessionID: string;
+    readonly at: number;
+    readonly model: ModelRef;
+};
+/**
+ * Why an event produced no state change. Only terminal events can be ignored
+ * — they arrive without an active unit when the terminal was already handled
+ * (duplicate delivery) or never preceded by `execution-started`.
+ */
+export declare const IGNORED_REASONS: readonly ["terminal-without-active-unit"];
+export type IgnoredReason = (typeof IGNORED_REASONS)[number];
+/** Result of an execution-started event: the tracker always opens (possibly superseding). */
+export type OpenedResult = Extract<ApplyResult, {
+    kind: "opened";
+}>;
+/** Result of a selection event: the tracker always records model knowledge. */
+export type SelectionResult = Extract<ApplyResult, {
+    kind: "model-noted";
+} | {
+    kind: "model-tracked";
+}>;
+export type ApplyResult = {
+    readonly kind: "opened";
+    readonly unit: ActiveUnit;
+    readonly superseded?: ClosedUnit | undefined;
+} | {
+    readonly kind: "closed";
+    readonly unit: ClosedUnit;
+} | {
+    readonly kind: "model-tracked";
+    readonly unit: ActiveUnit;
+    readonly transition: ModelTransition;
+}
+/** Model knowledge recorded with no active unit; remembered for the next admission. */
+ | {
+    readonly kind: "model-noted";
+    readonly transition: ModelTransition;
+} | {
+    readonly kind: "ignored";
+    readonly reason: IgnoredReason;
+};
+export {};

package/dist/core/work-unit/types.js

@@ -0,0 +1,23 @@
+/** Full-field equality; a variant change is a different reference. */
+export function sameModelRef(a, b) {
+    return a.providerID === b.providerID && a.id === b.id && a.variant === b.variant;
+}
+/**
+ * How the model in effect became known. `selected-*` comes from the
+ * `session.model.selected` event (which fires for both manual and
+ * plugin-made switches — the tracker resolves which via pending own-switch
+ * notes, see `WorkUnitTracker.noteOwnSwitch`); `request` comes from the
+ * `context` hook and reports the model actually executing.
+ */
+export const MODEL_SOURCES = [
+    "selected-adaptive",
+    "selected-external",
+    "request",
+];
+/**
+ * Why an event produced no state change. Only terminal events can be ignored
+ * — they arrive without an active unit when the terminal was already handled
+ * (duplicate delivery) or never preceded by `execution-started`.
+ */
+export const IGNORED_REASONS = ["terminal-without-active-unit"];
+//# sourceMappingURL=types.js.map