@coool/opencode-adaptive 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,45 @@
+export const TIERS = ["quick", "standard", "advanced"];
+/**
+ * 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;;;;;;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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/work-unit/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}

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"}

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

@@ -0,0 +1,8 @@
+/**
+ * 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];
+//# sourceMappingURL=interruption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interruption.d.ts","sourceRoot":"","sources":["../../../src/core/work-unit/interruption.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,2DAKQ,CAAA;AAEtC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA"}

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"}

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

@@ -0,0 +1,46 @@
+/**
+ * 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 WorkUnitEvent } from "./types.js";
+export declare class WorkUnitTracker {
+    #private;
+    /**
+     * 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: WorkUnitEvent): ApplyResult;
+    /** The open unit for a session, if any. */
+    active(sessionID: string): ActiveUnit | undefined;
+    /** All currently open units, in insertion order. */
+    activeAll(): ActiveUnit[];
+    /** Last model known to be in effect for a session, across episodes. */
+    lastModel(sessionID: string): ModelTransition | undefined;
+}
+//# sourceMappingURL=tracker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../../../src/core/work-unit/tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,WAAW,EAEhB,KAAK,QAAQ,EAEb,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EACnB,MAAM,YAAY,CAAA;AAEnB,qBAAa,eAAe;;IAM1B;;;OAGG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAIvD;;;;;;OAMG;IACH,YAAY,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAMtD,yEAAyE;IACzE,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,IAAI,EAAE,mBAAmB,CAAA;KAAE,CAAC,GAAG,YAAY;IACjF,KAAK,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW;IA6DxC,2CAA2C;IAC3C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIjD,oDAAoD;IACpD,SAAS,IAAI,UAAU,EAAE;IAIzB,uEAAuE;IACvE,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;CA4B1D"}

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

@@ -0,0 +1,136 @@
+/**
+ * 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";
+export class WorkUnitTracker {
+    #active = new Map();
+    #episodes = new Map();
+    #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) {
+        this.#pendingOwn.set(sessionID, model);
+    }
+    /**
+     * 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);
+    }
+    /** All currently open units, in insertion order. */
+    activeAll() {
+        return [...this.#active.values()];
+    }
+    /** 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 };
+        this.#lastModel.set(sessionID, transition);
+        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 };
+    }
+}
+//# 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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"}

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

@@ -0,0 +1,146 @@
+/**
+ * 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";
+}>;
+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 {};
+//# sourceMappingURL=types.d.ts.map

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/work-unit/types.ts"],"names":[],"mappings":"AAiBA,sEAAsE;AACtE,MAAM,UAAU,YAAY,CAAC,CAAW,EAAE,CAAW;IACnD,OAAO,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,CAAA;AAClF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,mBAAmB;IACnB,mBAAmB;IACnB,SAAS;CAC2B,CAAA;AAmGtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,8BAA8B,CAAsC,CAAA"}

package/dist/execution/continuation/execute.d.ts

@@ -0,0 +1,19 @@
+import type { ContinuationOutcome } from "./types.js";
+import type { ContinuationExecuteInput } from "./types.js";
+/**
+ * Executes a planned continuation through the narrow ops seam, enforcing
+ * the partial-work invariants in one place (ADP-014/ADP-023):
+ *
+ * 1. Every owned path settles the session FIRST — Adaptive never switches
+ *    or prompts while a failed execution is still settling.
+ * 2. The delivered prompt is always the fixed continuation prompt over the
+ *    existing session/workspace state — the original instruction is never
+ *    re-sent, so the never-replay invariant holds by construction.
+ * 3. `allow-native` performs no host operations at all.
+ *
+ * Ops failures propagate to the caller (the wiring's fail-open wrapper
+ * decides degradation); the ordering guarantee holds up to the first
+ * failure because each step awaits the previous one.
+ */
+export declare function executeContinuation(input: ContinuationExecuteInput): Promise<ContinuationOutcome>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/execution/continuation/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/execute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,mBAAmB,CAAC,CAY9B"}

package/dist/execution/continuation/execute.js

@@ -0,0 +1,31 @@
+import { CONTINUATION_PROMPT } from "./prompts.js";
+/**
+ * Executes a planned continuation through the narrow ops seam, enforcing
+ * the partial-work invariants in one place (ADP-014/ADP-023):
+ *
+ * 1. Every owned path settles the session FIRST — Adaptive never switches
+ *    or prompts while a failed execution is still settling.
+ * 2. The delivered prompt is always the fixed continuation prompt over the
+ *    existing session/workspace state — the original instruction is never
+ *    re-sent, so the never-replay invariant holds by construction.
+ * 3. `allow-native` performs no host operations at all.
+ *
+ * Ops failures propagate to the caller (the wiring's fail-open wrapper
+ * decides degradation); the ordering guarantee holds up to the first
+ * failure because each step awaits the previous one.
+ */
+export async function executeContinuation(input) {
+    const { action, ops, sessionID } = input;
+    if (action.kind === "allow-native")
+        return { kind: "left-native" };
+    if (action.kind === "in-session") {
+        await ops.settle(sessionID);
+        await ops.switchModel(sessionID, action.model);
+        await ops.prompt(sessionID, CONTINUATION_PROMPT);
+        return { kind: "resumed" };
+    }
+    await ops.settle(sessionID);
+    await ops.prompt(sessionID, CONTINUATION_PROMPT);
+    return { kind: "continuation-started" };
+}
+//# sourceMappingURL=execute.js.map

package/dist/execution/continuation/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../../src/execution/continuation/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAIlD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,KAA+B;IAE/B,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,CAAA;IACxC,IAAI,MAAM,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAA;IAClE,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QACjC,MAAM,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QAC3B,MAAM,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;QAC9C,MAAM,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAA;QAChD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;IAC5B,CAAC;IACD,MAAM,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC3B,MAAM,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAA;IAChD,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAA;AACzC,CAAC"}

package/dist/execution/continuation/index.d.ts

@@ -0,0 +1,6 @@
+export { CONTINUATION_ACTIONS } from "./types.js";
+export type { ContinuationAction, ContinuationActionKind, ContinuationExecuteInput, ContinuationOps, ContinuationOutcome, ContinuationPlanInput, } from "./types.js";
+export { CONTINUATION_PROMPT } from "./prompts.js";
+export { planContinuation } from "./plan.js";
+export { executeContinuation } from "./execute.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/continuation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/dist/execution/continuation/index.js

@@ -0,0 +1,5 @@
+export { CONTINUATION_ACTIONS } from "./types.js";
+export { CONTINUATION_PROMPT } from "./prompts.js";
+export { planContinuation } from "./plan.js";
+export { executeContinuation } from "./execute.js";
+//# sourceMappingURL=index.js.map

package/dist/execution/continuation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/continuation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AASjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/dist/execution/continuation/ledger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tracks which work units have accumulated tool side effects (ADP-014).
+ * The adapter marks units as tool events stream through; the continuation
+ * planner and executor consult the ledger to pick the prompt strategy and
+ * to prove the never-replay invariant. The wiring forgets a unit's entry
+ * when the unit closes, so the ledger stays bounded by live units — the
+ * same memory model as the work-unit tracker (leaked units are memory-only
+ * and bounded by host sessions).
+ */
+export declare class SideEffectLedger {
+    #private;
+    /** Record that the unit has tool side effects. Idempotent. */
+    mark(unitID: string): void;
+    had(unitID: string): boolean;
+    /** Drop the unit's entry (call when the unit closes and is evaluated). */
+    forget(unitID: string): void;
+    /** Drop every entry for a session (unit IDs are `${sessionID}#episode`). */
+    forgetSession(sessionID: string): void;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/execution/continuation/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;;IAG3B,8DAA8D;IAC9D,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI1B,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,0EAA0E;IAC1E,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI5B,4EAA4E;IAC5E,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAKvC"}

package/dist/execution/continuation/ledger.js

@@ -0,0 +1,31 @@
+/**
+ * Tracks which work units have accumulated tool side effects (ADP-014).
+ * The adapter marks units as tool events stream through; the continuation
+ * planner and executor consult the ledger to pick the prompt strategy and
+ * to prove the never-replay invariant. The wiring forgets a unit's entry
+ * when the unit closes, so the ledger stays bounded by live units — the
+ * same memory model as the work-unit tracker (leaked units are memory-only
+ * and bounded by host sessions).
+ */
+export class SideEffectLedger {
+    #marked = new Map();
+    /** Record that the unit has tool side effects. Idempotent. */
+    mark(unitID) {
+        this.#marked.set(unitID, true);
+    }
+    had(unitID) {
+        return this.#marked.has(unitID);
+    }
+    /** Drop the unit's entry (call when the unit closes and is evaluated). */
+    forget(unitID) {
+        this.#marked.delete(unitID);
+    }
+    /** Drop every entry for a session (unit IDs are `${sessionID}#episode`). */
+    forgetSession(sessionID) {
+        for (const unitID of this.#marked.keys()) {
+            if (unitID.startsWith(`${sessionID}#`))
+                this.#marked.delete(unitID);
+        }
+    }
+}
+//# sourceMappingURL=ledger.js.map

package/dist/execution/continuation/ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.js","sourceRoot":"","sources":["../../../src/execution/continuation/ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,OAAO,gBAAgB;IAClB,OAAO,GAAG,IAAI,GAAG,EAAgB,CAAA;IAE1C,8DAA8D;IAC9D,IAAI,CAAC,MAAc;QACjB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAChC,CAAC;IAED,GAAG,CAAC,MAAc;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACjC,CAAC;IAED,0EAA0E;IAC1E,MAAM,CAAC,MAAc;QACnB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;IAED,4EAA4E;IAC5E,aAAa,CAAC,SAAiB;QAC7B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YACzC,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,SAAS,GAAG,CAAC;gBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QACrE,CAAC;IACH,CAAC;CACF"}

package/dist/execution/continuation/plan.d.ts

@@ -0,0 +1,13 @@
+import type { ContinuationAction, ContinuationPlanInput } from "./types.js";
+/**
+ * Partial-work safety planner (ADP-023). Total, deterministic, pure.
+ *
+ * - No owned recovery: OpenCode's native retry is the preferred recovery;
+ *   Adaptive leaves it alone.
+ * - Owned recovery and the in-session path is possible: continue the same
+ *   session on the recovered candidate (settle → switch → resume).
+ * - Owned recovery and the in-session path is impossible: start a clean
+ *   continuation work unit from existing durable session state.
+ */
+export declare function planContinuation(input: ContinuationPlanInput): ContinuationAction;
+//# sourceMappingURL=plan.d.ts.map