@coool/opencode-adaptive 0.0.0-stage → 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAE3E;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,kBAAkB,CAOjF"}

package/dist/execution/continuation/plan.js

@@ -0,0 +1,20 @@
+/**
+ * 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 function planContinuation(input) {
+    if (input.recovery.kind === "none")
+        return { kind: "allow-native" };
+    if (input.continuationPossible)
+        return input.recovery.probeId === undefined
+            ? { kind: "in-session", model: input.recovery.model }
+            : { kind: "in-session", model: input.recovery.model, probeId: input.recovery.probeId };
+    return { kind: "clean-continuation" };
+}
+//# sourceMappingURL=plan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../src/execution/continuation/plan.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA4B;IAC3D,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;IACnE,IAAI,KAAK,CAAC,oBAAoB;QAC5B,OAAO,KAAK,CAAC,QAAQ,CAAC,OAAO,KAAK,SAAS;YACzC,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE;YACrD,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;IAC1F,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAA;AACvC,CAAC"}

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

@@ -0,0 +1,8 @@
+/**
+ * Continuation prompt for owned recovery and parked-work resume (ADP-023).
+ * Continues from session state; never replays the original instruction once
+ * tool side effects may exist. The executor sends exactly this prompt — the
+ * never-replay invariant is structural, not a caller responsibility.
+ */
+export declare const CONTINUATION_PROMPT = "Continue the interrupted work from the current session state. Do not repeat completed work; resume from what the session already produced.";
+//# sourceMappingURL=prompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,+IAC8G,CAAA"}

package/dist/execution/continuation/prompts.js

@@ -0,0 +1,8 @@
+/**
+ * Continuation prompt for owned recovery and parked-work resume (ADP-023).
+ * Continues from session state; never replays the original instruction once
+ * tool side effects may exist. The executor sends exactly this prompt — the
+ * never-replay invariant is structural, not a caller responsibility.
+ */
+export const CONTINUATION_PROMPT = "Continue the interrupted work from the current session state. Do not repeat completed work; resume from what the session already produced.";
+//# sourceMappingURL=prompts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/execution/continuation/prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B,4IAA4I,CAAA"}

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

@@ -0,0 +1,70 @@
+import type { ModelRef } from "../../core/work-unit/types.js";
+import type { RecoveryOption } from "../retry/types.js";
+/**
+ * What Adaptive does for a failed work unit's recovery (ADP-013/ADP-014).
+ * - `allow-native`: Adaptive did not take ownership (no veto) — OpenCode's
+ *   native retry lifecycle is the preferred recovery and stays untouched.
+ * - `in-session`: Adaptive vetoed native retry and continues the same
+ *   session on a recovered candidate (settle → switch → resume).
+ * - `clean-continuation`: the in-session path is not possible; start a
+ *   clean continuation work unit from existing durable session state.
+ *
+ * The union has no "replay" variant by construction: every owned path
+ * continues from session state, so "Adaptive replays the original
+ * instruction after side effects" is unrepresentable, not merely avoided.
+ */
+export declare const CONTINUATION_ACTIONS: readonly ["allow-native", "in-session", "clean-continuation"];
+export type ContinuationActionKind = (typeof CONTINUATION_ACTIONS)[number];
+export type ContinuationAction = {
+    kind: "allow-native";
+} | {
+    kind: "in-session";
+    model: ModelRef;
+    probeId?: string | undefined;
+} | {
+    kind: "clean-continuation";
+};
+export interface ContinuationPlanInput {
+    /**
+     * Recovery option computed by the wiring for the failing unit: `none`
+     * means Adaptive did not veto (OpenCode's native retry is the preferred
+     * recovery); `switch` means Adaptive vetoed and owns the recovery.
+     */
+    readonly recovery: RecoveryOption;
+    /**
+     * True when the in-session owned path is possible (session alive, settle
+     * + switch + resume available). Only consulted for `switch` recovery.
+     */
+    readonly continuationPossible: boolean;
+}
+/**
+ * Narrow seam over the host session operations the owned continuation
+ * needs. Implemented by the OpenCode adapter (which tags its own model
+ * switches for attribution before calling the host); tests use fakes that
+ * record call order. Never imports `@opencode/plugin`.
+ */
+export interface ContinuationOps {
+    /**
+     * Wait until the session's failed execution has settled. Every owned
+     * path settles first — Adaptive never switches or prompts while a failed
+     * execution is still settling.
+     */
+    settle(sessionID: string): Promise<void>;
+    /** Switch the session's model (own-switch attribution handled by the adapter). */
+    switchModel(sessionID: string, model: ModelRef): Promise<void>;
+    /** Deliver a prompt to the session; starts/continues execution. */
+    prompt(sessionID: string, text: string): Promise<void>;
+}
+export interface ContinuationExecuteInput {
+    readonly sessionID: string;
+    readonly action: ContinuationAction;
+    readonly ops: ContinuationOps;
+}
+export type ContinuationOutcome = {
+    kind: "left-native";
+} | {
+    kind: "resumed";
+} | {
+    kind: "continuation-started";
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/execution/continuation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,+DAAgE,CAAA;AACjG,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE1E,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,oBAAoB,CAAA;CAAE,CAAA;AAElC,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;CACvC;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxC,kFAAkF;IAClF,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9D,mEAAmE;IACnE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACvD;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAA;CAC9B;AAED,MAAM,MAAM,mBAAmB,GAC7B;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAAA"}

package/dist/execution/continuation/types.js

@@ -0,0 +1,15 @@
+/**
+ * What Adaptive does for a failed work unit's recovery (ADP-013/ADP-014).
+ * - `allow-native`: Adaptive did not take ownership (no veto) — OpenCode's
+ *   native retry lifecycle is the preferred recovery and stays untouched.
+ * - `in-session`: Adaptive vetoed native retry and continues the same
+ *   session on a recovered candidate (settle → switch → resume).
+ * - `clean-continuation`: the in-session path is not possible; start a
+ *   clean continuation work unit from existing durable session state.
+ *
+ * The union has no "replay" variant by construction: every owned path
+ * continues from session state, so "Adaptive replays the original
+ * instruction after side effects" is unrepresentable, not merely avoided.
+ */
+export const CONTINUATION_ACTIONS = ["allow-native", "in-session", "clean-continuation"];
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/execution/continuation/types.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,YAAY,EAAE,oBAAoB,CAAU,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/escalation/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/execution/escalation/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/escalation/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/execution/escalation/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The Adaptive-owned escalation request surface (T-18, ADP-015..017). The
+ * schema requires a reason and evidence — it is deliberately the smallest
+ * typed mechanism for an agent to request stronger capability, and it is not
+ * a planning or task-management API. The request is recorded against the
+ * current work unit and applies at the next safe boundary within the finite
+ * per-unit budget; a completing unit discards it (routing re-runs fresh).
+ */
+/** The tool name as registered with the host. */
+export declare const ESCALATION_TOOL_NAME = "adaptive_escalate";
+/** Each field is bounded — the request never carries unbounded prose. */
+export declare const MAX_ESCALATION_FIELD_LENGTH = 256;
+export interface EscalationRequest {
+    readonly reason: string;
+    readonly evidence: string;
+}
+/**
+ * Truncates to `max` UTF-16 code units without splitting a surrogate pair:
+ * a trailing high surrogate whose low half was cut is dropped, so the
+ * persisted evidence never carries a lone surrogate.
+ */
+export declare function truncateBounded(text: string, max: number): string;
+/**
+ * Total parser for the tool input (the host forwards model-produced JSON, so
+ * the runtime shape is untrusted even though the standard schema describes
+ * it). Both fields are required, non-empty, and bounded.
+ */
+export declare function parseEscalationRequest(input: unknown): EscalationRequest | undefined;
+/** One-line summary recorded as escalation evidence (bounded). */
+export declare function escalationDetail(request: EscalationRequest): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/execution/escalation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/execution/escalation/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,iDAAiD;AACjD,eAAO,MAAM,oBAAoB,sBAAsB,CAAA;AAEvD,yEAAyE;AACzE,eAAO,MAAM,2BAA2B,MAAM,CAAA;AAE9C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAWpF;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAEnE"}

package/dist/execution/escalation/types.js

@@ -0,0 +1,49 @@
+/**
+ * The Adaptive-owned escalation request surface (T-18, ADP-015..017). The
+ * schema requires a reason and evidence — it is deliberately the smallest
+ * typed mechanism for an agent to request stronger capability, and it is not
+ * a planning or task-management API. The request is recorded against the
+ * current work unit and applies at the next safe boundary within the finite
+ * per-unit budget; a completing unit discards it (routing re-runs fresh).
+ */
+/** The tool name as registered with the host. */
+export const ESCALATION_TOOL_NAME = "adaptive_escalate";
+/** Each field is bounded — the request never carries unbounded prose. */
+export const MAX_ESCALATION_FIELD_LENGTH = 256;
+/**
+ * Truncates to `max` UTF-16 code units without splitting a surrogate pair:
+ * a trailing high surrogate whose low half was cut is dropped, so the
+ * persisted evidence never carries a lone surrogate.
+ */
+export function truncateBounded(text, max) {
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max);
+    const last = cut.charCodeAt(cut.length - 1);
+    return last >= 0xd800 && last <= 0xdbff ? cut.slice(0, -1) : cut;
+}
+/**
+ * Total parser for the tool input (the host forwards model-produced JSON, so
+ * the runtime shape is untrusted even though the standard schema describes
+ * it). Both fields are required, non-empty, and bounded.
+ */
+export function parseEscalationRequest(input) {
+    if (typeof input !== "object" || input === null)
+        return undefined;
+    const record = input;
+    const reason = record["reason"];
+    const evidence = record["evidence"];
+    if (typeof reason !== "string" || reason.length === 0)
+        return undefined;
+    if (typeof evidence !== "string" || evidence.length === 0)
+        return undefined;
+    return {
+        reason: truncateBounded(reason, MAX_ESCALATION_FIELD_LENGTH),
+        evidence: truncateBounded(evidence, MAX_ESCALATION_FIELD_LENGTH),
+    };
+}
+/** One-line summary recorded as escalation evidence (bounded). */
+export function escalationDetail(request) {
+    return truncateBounded(`${request.reason}: ${request.evidence}`, MAX_ESCALATION_FIELD_LENGTH);
+}
+//# sourceMappingURL=types.js.map

package/dist/execution/escalation/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/execution/escalation/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,iDAAiD;AACjD,MAAM,CAAC,MAAM,oBAAoB,GAAG,mBAAmB,CAAA;AAEvD,yEAAyE;AACzE,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,CAAA;AAO9C;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,GAAW;IACvD,IAAI,IAAI,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,IAAI,CAAA;IACnC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IAC9B,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAC3C,OAAO,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;AAClE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAA;IACjE,MAAM,MAAM,GAAG,KAAgC,CAAA;IAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC/B,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;IACnC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IACvE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IAC3E,OAAO;QACL,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,2BAA2B,CAAC;QAC5D,QAAQ,EAAE,eAAe,CAAC,QAAQ,EAAE,2BAA2B,CAAC;KACjE,CAAA;AACH,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,gBAAgB,CAAC,OAA0B;IACzD,OAAO,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,QAAQ,EAAE,EAAE,2BAA2B,CAAC,CAAA;AAC/F,CAAC"}

package/dist/execution/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./retry/index.js";
+export * from "./continuation/index.js";
+export * from "./parking/index.js";
+export * from "./escalation/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA"}

package/dist/execution/index.js

@@ -0,0 +1,5 @@
+export * from "./retry/index.js";
+export * from "./continuation/index.js";
+export * from "./parking/index.js";
+export * from "./escalation/index.js";
+//# sourceMappingURL=index.js.map

package/dist/execution/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA"}

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

@@ -0,0 +1,3 @@
+export { selectResumable } from "./plan.js";
+export type { ResumeContext, ResumePlan } from "./plan.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/parking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA"}

package/dist/execution/parking/index.js

@@ -0,0 +1,2 @@
+export { selectResumable } from "./plan.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/parking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

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

@@ -0,0 +1,40 @@
+import type { ParkedRecord } from "../../state/parked-work/types.js";
+/**
+ * Resume-attempt budget (ADP-011): a record whose continuation prompt kept
+ * failing is dropped once its attempts reach this count — the idle loop
+ * must be provably bounded, not "as long as idle events keep firing".
+ */
+export declare const MAX_PARKED_ATTEMPTS = 5;
+/**
+ * Predicates supplied by the wiring at each safe boundary. Kept as
+ * injected predicates so this module stays host-agnostic and fully
+ * unit-testable with fakes.
+ */
+export interface ResumeContext {
+    /** Whether the parked record's tier still has configured resources. */
+    tierConfigured(tier: ParkedRecord["tier"]): boolean;
+    /** Whether the session the record belongs to still exists. */
+    sessionAlive(sessionID: string): boolean;
+}
+export interface ResumePlan {
+    /**
+     * Records worth a fresh routing attempt now, oldest parked first (ties
+     * keep park order). The wiring re-runs routing for each; a successful
+     * route pops the record via the store and starts a clean continuation.
+     */
+    readonly attempt: readonly ParkedRecord[];
+    /** Tier no longer configured — keep parked until the user configures it. */
+    readonly hold: readonly ParkedRecord[];
+    /**
+     * Session gone, or the record exhausted its resume-attempt budget — the
+     * record can never (or may no longer) resume; the wiring drops it.
+     */
+    readonly drop: readonly ParkedRecord[];
+}
+/**
+ * Parked-work resume selection at a safe boundary (ADP-024). Total,
+ * deterministic, pure: partitions the parked list by resumability without
+ * consulting health (routing re-decides with fresh health per attempt).
+ */
+export declare function selectResumable(records: readonly ParkedRecord[], context: ResumeContext): ResumePlan;
+//# sourceMappingURL=plan.d.ts.map

package/dist/execution/parking/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/execution/parking/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,OAAO,CAAA;IACnD,8DAA8D;IAC9D,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;CACzC;AAED,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;IACzC,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAA;IACtC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAA;CACvC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,aAAa,GACrB,UAAU,CAqBZ"}

package/dist/execution/parking/plan.js

@@ -0,0 +1,34 @@
+/**
+ * Resume-attempt budget (ADP-011): a record whose continuation prompt kept
+ * failing is dropped once its attempts reach this count — the idle loop
+ * must be provably bounded, not "as long as idle events keep firing".
+ */
+export const MAX_PARKED_ATTEMPTS = 5;
+/**
+ * Parked-work resume selection at a safe boundary (ADP-024). Total,
+ * deterministic, pure: partitions the parked list by resumability without
+ * consulting health (routing re-decides with fresh health per attempt).
+ */
+export function selectResumable(records, context) {
+    const attempt = [];
+    const hold = [];
+    const drop = [];
+    const byAge = [...records].sort((a, b) => a.parkedAt - b.parkedAt);
+    for (const record of byAge) {
+        if (!context.sessionAlive(record.sessionID)) {
+            drop.push(record);
+            continue;
+        }
+        if ((record.attempts ?? 0) >= MAX_PARKED_ATTEMPTS) {
+            drop.push(record);
+            continue;
+        }
+        if (!context.tierConfigured(record.tier)) {
+            hold.push(record);
+            continue;
+        }
+        attempt.push(record);
+    }
+    return { attempt, hold, drop };
+}
+//# sourceMappingURL=plan.js.map

package/dist/execution/parking/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../src/execution/parking/plan.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAA;AA8BpC;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAgC,EAChC,OAAsB;IAEtB,MAAM,OAAO,GAAmB,EAAE,CAAA;IAClC,MAAM,IAAI,GAAmB,EAAE,CAAA;IAC/B,MAAM,IAAI,GAAmB,EAAE,CAAA;IAC/B,MAAM,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAA;IAClE,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAC5C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YACjB,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,mBAAmB,EAAE,CAAC;YAClD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YACjB,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YACjB,SAAQ;QACV,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IACtB,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;AAChC,CAAC"}

package/dist/execution/recovery/gate.d.ts

@@ -0,0 +1,20 @@
+export declare const UNIT_PHASES: readonly ["admission", "busy", "settling", "idle"];
+export type UnitPhase = (typeof UNIT_PHASES)[number];
+export type RecoveryWindow = {
+    kind: "open";
+} | {
+    kind: "closed";
+    reason: "busy" | "settling";
+};
+/**
+ * Safe-boundary gate for applying a recovered preferred resource (ADP-016/
+ * ADP-018). A unit's model is only ever changed at a safe boundary:
+ * - `admission`: the unit is starting; routing decides fresh.
+ * - `idle`: between episodes; parked resumes and re-routes may proceed.
+ * - `busy`: mid-work — running work is never pulled to another resource.
+ * - `settling`: a failed execution has not settled yet — Adaptive never
+ *    switches or prompts while the session is settling (settle-first is
+ *    enforced by the continuation executor; this gate is the second guard).
+ */
+export declare function recoveryWindow(phase: UnitPhase): RecoveryWindow;
+//# sourceMappingURL=gate.d.ts.map

package/dist/execution/recovery/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../src/execution/recovery/gate.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,oDAAqD,CAAA;AAC7E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpD,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAA;AAE/F;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAU/D"}

package/dist/execution/recovery/gate.js

@@ -0,0 +1,23 @@
+export const UNIT_PHASES = ["admission", "busy", "settling", "idle"];
+/**
+ * Safe-boundary gate for applying a recovered preferred resource (ADP-016/
+ * ADP-018). A unit's model is only ever changed at a safe boundary:
+ * - `admission`: the unit is starting; routing decides fresh.
+ * - `idle`: between episodes; parked resumes and re-routes may proceed.
+ * - `busy`: mid-work — running work is never pulled to another resource.
+ * - `settling`: a failed execution has not settled yet — Adaptive never
+ *    switches or prompts while the session is settling (settle-first is
+ *    enforced by the continuation executor; this gate is the second guard).
+ */
+export function recoveryWindow(phase) {
+    switch (phase) {
+        case "busy":
+            return { kind: "closed", reason: "busy" };
+        case "settling":
+            return { kind: "closed", reason: "settling" };
+        case "admission":
+        case "idle":
+            return { kind: "open" };
+    }
+}
+//# sourceMappingURL=gate.js.map

package/dist/execution/recovery/gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../../src/execution/recovery/gate.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAU,CAAA;AAK7E;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,KAAgB;IAC7C,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,MAAM;YACT,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;QAC3C,KAAK,UAAU;YACb,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,CAAA;QAC/C,KAAK,WAAW,CAAC;QACjB,KAAK,MAAM;YACT,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IAC3B,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,3 @@
+export { UNIT_PHASES, recoveryWindow } from "./gate.js";
+export type { RecoveryWindow, UnitPhase } from "./gate.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/recovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AACvD,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA"}

package/dist/execution/recovery/index.js

@@ -0,0 +1,2 @@
+export { UNIT_PHASES, recoveryWindow } from "./gate.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/recovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA"}

package/dist/execution/retry/decide.d.ts

@@ -0,0 +1,30 @@
+import type { OperatingMode } from "../../core/scheduler/types.js";
+import type { RetryCoreDecision, RetryInput, RetryDecision } from "./types.js";
+/**
+ * Retry-hook policy (ADP-013/014). Total, deterministic, side-effect free.
+ *
+ * Veto (take ownership of horizontal recovery) only when ALL hold:
+ * - the classification is failover-eligible (infrastructure failure —
+ *   capability problems and host decisions never veto);
+ * - the evidence is definitive — ambiguous evidence (Retry-After headers
+ *   alone, bounded-textual matches) conservatively leaves OpenCode's native
+ *   retry, which the host schedules with its parsed `retryAfterMs` (ADP-012);
+ * - a same-tier recovery candidate exists AND differs from the resource that
+ *   just failed — without one, the native retry of the same resource IS the
+ *   preferred horizontal recovery (vetoing onto the failed resource would
+ *   discard the host's backoff and re-prompt it immediately). A breaker-probe
+ *   recovery is exempt: its target IS the failed resource by design, and the
+ *   veto is what starts the probe episode;
+ * - the host still wants to retry (`retry: true`) — an already-vetoed or
+ *   exhausted lifecycle is never resurrected; recovery defers to the next
+ *   safe boundary (ADP-014, ADP-023);
+ * - the per-unit veto budget has room left.
+ */
+export declare function decideRetry(input: RetryInput): RetryCoreDecision;
+/**
+ * Mode wrapper — the same core decision for Observe and Control; Observe
+ * wraps it for receipt recording without intervening; OFF never touches
+ * execution (the hook is not even registered, this keeps the union closed).
+ */
+export declare function forMode(decision: RetryCoreDecision, mode: OperatingMode): RetryDecision;
+//# sourceMappingURL=decide.d.ts.map

package/dist/execution/retry/decide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide.d.ts","sourceRoot":"","sources":["../../../src/execution/retry/decide.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAGV,iBAAiB,EACjB,UAAU,EACV,aAAa,EACd,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,iBAAiB,CAyChE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,aAAa,GAAG,aAAa,CASvF"}

package/dist/execution/retry/decide.js

@@ -0,0 +1,76 @@
+import { MAX_VETOES_PER_UNIT } from "./types.js";
+import { sameModelRef } from "../../core/work-unit/types.js";
+/**
+ * Retry-hook policy (ADP-013/014). Total, deterministic, side-effect free.
+ *
+ * Veto (take ownership of horizontal recovery) only when ALL hold:
+ * - the classification is failover-eligible (infrastructure failure —
+ *   capability problems and host decisions never veto);
+ * - the evidence is definitive — ambiguous evidence (Retry-After headers
+ *   alone, bounded-textual matches) conservatively leaves OpenCode's native
+ *   retry, which the host schedules with its parsed `retryAfterMs` (ADP-012);
+ * - a same-tier recovery candidate exists AND differs from the resource that
+ *   just failed — without one, the native retry of the same resource IS the
+ *   preferred horizontal recovery (vetoing onto the failed resource would
+ *   discard the host's backoff and re-prompt it immediately). A breaker-probe
+ *   recovery is exempt: its target IS the failed resource by design, and the
+ *   veto is what starts the probe episode;
+ * - the host still wants to retry (`retry: true`) — an already-vetoed or
+ *   exhausted lifecycle is never resurrected; recovery defers to the next
+ *   safe boundary (ADP-014, ADP-023);
+ * - the per-unit veto budget has room left.
+ */
+export function decideRetry(input) {
+    if (!input.classification.failoverEligible) {
+        return { kind: "leave" };
+    }
+    if (!input.classification.definitive) {
+        return { kind: "leave" };
+    }
+    const recovery = input.recovery;
+    if (recovery.kind === "none") {
+        return { kind: "leave" };
+    }
+    // A probe recovery targets the very resource that just failed (the
+    // half-open probe re-admits it); the veto is what starts the probe episode,
+    // so the same-resource exemption below must not swallow it.
+    // The host reports base-model calls with variant "default" (verified on
+    // 2.2.5, same fact refKey normalizes in the supervisor), so the sameness
+    // check must not treat that spelling as a different resource.
+    const sameResource = recovery.probeId === undefined &&
+        sameModelRef({
+            ...recovery.model,
+            variant: recovery.model.variant === "default" ? undefined : recovery.model.variant,
+        }, {
+            ...input.failingModel,
+            variant: input.failingModel.variant === "default" ? undefined : input.failingModel.variant,
+        });
+    if (sameResource) {
+        return { kind: "leave" };
+    }
+    const native = input.native;
+    if (!native.retry) {
+        return { kind: "leave" };
+    }
+    if (input.vetoesUsed >= MAX_VETOES_PER_UNIT) {
+        return { kind: "leave" };
+    }
+    const { model, probeId } = recovery;
+    return probeId === undefined ? { kind: "veto", model } : { kind: "veto", model, probeId };
+}
+/**
+ * Mode wrapper — the same core decision for Observe and Control; Observe
+ * wraps it for receipt recording without intervening; OFF never touches
+ * execution (the hook is not even registered, this keeps the union closed).
+ */
+export function forMode(decision, mode) {
+    switch (mode) {
+        case "active":
+            return decision;
+        case "observe":
+            return { kind: "observe-only", would: decision };
+        case "off":
+            return { kind: "leave" };
+    }
+}
+//# sourceMappingURL=decide.js.map

package/dist/execution/retry/decide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide.js","sourceRoot":"","sources":["../../../src/execution/retry/decide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAU5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CAAC,KAAiB;IAC3C,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC;QAC3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC;QACrC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,MAAM,QAAQ,GAAmB,KAAK,CAAC,QAAQ,CAAA;IAC/C,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC7B,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,mEAAmE;IACnE,4EAA4E;IAC5E,4DAA4D;IAC5D,wEAAwE;IACxE,yEAAyE;IACzE,8DAA8D;IAC9D,MAAM,YAAY,GAChB,QAAQ,CAAC,OAAO,KAAK,SAAS;QAC9B,YAAY,CACV;YACE,GAAG,QAAQ,CAAC,KAAK;YACjB,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO;SACnF,EACD;YACE,GAAG,KAAK,CAAC,YAAY;YACrB,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO;SAC3F,CACF,CAAA;IACH,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,MAAM,MAAM,GAAwB,KAAK,CAAC,MAAM,CAAA;IAChD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAClB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,IAAI,mBAAmB,EAAE,CAAC;QAC5C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC1B,CAAC;IACD,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAA;IACnC,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;AAC3F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,QAA2B,EAAE,IAAmB;IACtE,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,QAAQ,CAAA;QACjB,KAAK,SAAS;YACZ,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAA;QAClD,KAAK,KAAK;YACR,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;IAC5B,CAAC;AACH,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/retry/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/dist/execution/retry/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/retry/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}