@coool/opencode-adaptive 0.0.0-stage → 1.0.1

package/dist/adapters/opencode/session-ops.js

@@ -0,0 +1,32 @@
+/** Build the supervisor's continuation ops on top of the host session domain. */
+export function sessionOps(session, hooks) {
+    return {
+        settle: (sessionID) => session.wait({ sessionID }),
+        switchModel: (sessionID, model) => {
+            hooks?.beforeSwitch?.(sessionID, model);
+            return session.switchModel({
+                sessionID,
+                model: {
+                    providerID: model.providerID,
+                    id: model.id,
+                    ...(model.variant !== undefined ? { variant: model.variant } : {}),
+                },
+            });
+        },
+        prompt: async (sessionID, text) => {
+            hooks?.beforePrompt?.(sessionID);
+            let delivered = false;
+            try {
+                await session.prompt({ sessionID, text });
+                delivered = true;
+            }
+            finally {
+                // The ownership mark is consumed by the prompt hook; if the prompt
+                // never reaches the hook (session gone, host error), the mark must
+                // not outlive the attempt and swallow a later user prompt.
+                hooks?.afterPrompt?.(sessionID, delivered);
+            }
+        },
+    };
+}
+//# sourceMappingURL=session-ops.js.map

package/dist/adapters/opencode/session-ops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-ops.js","sourceRoot":"","sources":["../../../src/adapters/opencode/session-ops.ts"],"names":[],"mappings":"AAwCA,iFAAiF;AACjF,MAAM,UAAU,UAAU,CAAC,OAAyB,EAAE,KAAuB;IAC3E,OAAO;QACL,MAAM,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;QAClD,WAAW,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE;YAChC,KAAK,EAAE,YAAY,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;YACvC,OAAO,OAAO,CAAC,WAAW,CAAC;gBACzB,SAAS;gBACT,KAAK,EAAE;oBACL,UAAU,EAAE,KAAK,CAAC,UAAU;oBAC5B,EAAE,EAAE,KAAK,CAAC,EAAE;oBACZ,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBACnE;aACF,CAAC,CAAA;QACJ,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE;YAChC,KAAK,EAAE,YAAY,EAAE,CAAC,SAAS,CAAC,CAAA;YAChC,IAAI,SAAS,GAAG,KAAK,CAAA;YACrB,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;gBACzC,SAAS,GAAG,IAAI,CAAA;YAClB,CAAC;oBAAS,CAAC;gBACT,mEAAmE;gBACnE,mEAAmE;gBACnE,2DAA2D;gBAC3D,KAAK,EAAE,WAAW,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;YAC5C,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["/**\n * Session operations seam (ADP-013/ADP-014/ADP-023/ADP-028). Implements the\n * supervisor's `ContinuationOps` on the host session domain: settle on the\n * host's experimental wait, switch model, deliver a prompt. Never replays a\n * failed request — prompting after a failure starts a NEW execution that\n * continues from session state (prompt strategy chosen by the supervisor).\n *\n * Switch self-tagging (verified limitation: `session.model.selected` fires for\n * manual AND plugin switches): `beforeSwitch` is invoked BEFORE the host\n * switch so the supervisor can record its own pending attribution note; the\n * resulting selection event is then attributed to Adaptive, never to the user.\n */\nimport type { SessionDomain } from \"@opencode/plugin/promise/session\"\n\n/** The session surface the ops actually use (structural — fixture-friendly). */\nexport type SessionOpsSource = Pick<SessionDomain, \"wait\" | \"switchModel\" | \"prompt\">\nimport type { ContinuationOps } from \"../../execution/continuation/types.js\"\nimport type { ModelRef } from \"../../core/work-unit/types.js\"\n\nexport interface SessionOpsHooks {\n  /**\n   * Called before every host `switchModel` this adapter performs, so wiring\n   * can tag the switch as Adaptive's own (`noteOwnSwitch`).\n   */\n  readonly beforeSwitch?: (sessionID: string, model: ModelRef) => void\n  /**\n   * Called before the adapter prompts a continuation, so wiring can mark the\n   * upcoming prompt-hook admission as owned (the continuation belongs to the\n   * active unit and must not re-admit).\n   */\n  readonly beforePrompt?: (sessionID: string) => void\n  /**\n   * Called when the prompted call settles (success or failure), whether or\n   * not the prompt hook fired — the counterpart that bounds the ownership\n   * mark's lifetime. `delivered` is false exactly when the host prompt\n   * rejected, so the hook can never fire for it.\n   */\n  readonly afterPrompt?: (sessionID: string, delivered: boolean) => void\n}\n\n/** Build the supervisor's continuation ops on top of the host session domain. */\nexport function sessionOps(session: SessionOpsSource, hooks?: SessionOpsHooks): ContinuationOps {\n  return {\n    settle: (sessionID) => session.wait({ sessionID }),\n    switchModel: (sessionID, model) => {\n      hooks?.beforeSwitch?.(sessionID, model)\n      return session.switchModel({\n        sessionID,\n        model: {\n          providerID: model.providerID,\n          id: model.id,\n          ...(model.variant !== undefined ? { variant: model.variant } : {}),\n        },\n      })\n    },\n    prompt: async (sessionID, text) => {\n      hooks?.beforePrompt?.(sessionID)\n      let delivered = false\n      try {\n        await session.prompt({ sessionID, text })\n        delivered = true\n      } finally {\n        // The ownership mark is consumed by the prompt hook; if the prompt\n        // never reaches the hook (session gone, host error), the mark must\n        // not outlive the attempt and swallow a later user prompt.\n        hooks?.afterPrompt?.(sessionID, delivered)\n      }\n    },\n  }\n}\n"]}

package/dist/adapters/opencode/storage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Storage seam binding (ADP-030/ADP-031). The supervisor's state stores depend
+ * on a minimal `{ read, write }` seam; this module binds that seam to the
+ * host's `ctx.storage` under the fixed `coool.adaptive/...` keys. Values are
+ * JSON-serializable state payloads (settings/receipts/parked work).
+ */
+import type { StorageDomain } from "@opencode/plugin/promise/storage";
+/** The storage surface the seam actually uses (structural — fixture-friendly). */
+export type StorageSource = Pick<StorageDomain, "get" | "set">;
+export interface JsonSeam {
+    read(): Promise<unknown>;
+    write(value: unknown): Promise<void>;
+}
+/** Bind a storage key to the supervisor seam shape. */
+export declare function storageSeam(key: string, storage: StorageSource): JsonSeam;

package/dist/adapters/opencode/storage.js

@@ -0,0 +1,8 @@
+/** Bind a storage key to the supervisor seam shape. */
+export function storageSeam(key, storage) {
+    return {
+        read: () => storage.get(key),
+        write: (value) => storage.set(key, value),
+    };
+}
+//# sourceMappingURL=storage.js.map

package/dist/adapters/opencode/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../src/adapters/opencode/storage.ts"],"names":[],"mappings":"AAgBA,uDAAuD;AACvD,MAAM,UAAU,WAAW,CAAC,GAAW,EAAE,OAAsB;IAC7D,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;QAC5B,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAA0C,CAAC;KAC/E,CAAA;AACH,CAAC","sourcesContent":["/**\n * Storage seam binding (ADP-030/ADP-031). The supervisor's state stores depend\n * on a minimal `{ read, write }` seam; this module binds that seam to the\n * host's `ctx.storage` under the fixed `coool.adaptive/...` keys. Values are\n * JSON-serializable state payloads (settings/receipts/parked work).\n */\nimport type { StorageDomain } from \"@opencode/plugin/promise/storage\"\n\n/** The storage surface the seam actually uses (structural — fixture-friendly). */\nexport type StorageSource = Pick<StorageDomain, \"get\" | \"set\">\n\nexport interface JsonSeam {\n  read(): Promise<unknown>\n  write(value: unknown): Promise<void>\n}\n\n/** Bind a storage key to the supervisor seam shape. */\nexport function storageSeam(key: string, storage: StorageSource): JsonSeam {\n  return {\n    read: () => storage.get(key),\n    write: (value) => storage.set(key, value as Parameters<typeof storage.set>[1]),\n  }\n}\n"]}

package/dist/adapters/opencode/tier-tool.d.ts

@@ -0,0 +1,37 @@
+import type { TierName } from "../../core/tier-policy/types.js";
+/** Records the agent's tier declaration; false = not accepted. */
+export type TierRequestRecorder = (sessionID: string, tier: TierName) => boolean;
+/**
+ * The agent-declared tier tool: a typed sibling of adaptive_escalate. The
+ * agent declares the tier of the task it is starting ("this task is quick")
+ * and the declaration steers the session's next admissions until cleared —
+ * one tier per task, not per unit. Plain JSON Schema: the host converts it,
+ * and a Standard Schema vendor is silently dropped on 2.2.5.
+ */
+export declare function tierTool(record: TierRequestRecorder): {
+    name: string;
+    description: string;
+    input: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly type: "object";
+        readonly properties: {
+            readonly tier: {
+                readonly description: "The tier the current task needs.";
+                readonly enum: readonly ["quick", "standard", "advanced"];
+            };
+        };
+        readonly required: readonly ["tier"];
+        readonly additionalProperties: false;
+    };
+    options: {
+        readonly codemode: false;
+    };
+    execute: (input: unknown, context: {
+        sessionID: string;
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/adapters/opencode/tier-tool.js

@@ -0,0 +1,72 @@
+/**
+ * The agent-declared tier tool: a typed sibling of adaptive_escalate. The
+ * agent declares the tier of the task it is starting ("this task is quick")
+ * and the declaration steers the session's next admissions until cleared —
+ * one tier per task, not per unit. Plain JSON Schema: the host converts it,
+ * and a Standard Schema vendor is silently dropped on 2.2.5.
+ */
+export function tierTool(record) {
+    return {
+        name: "adaptive_tier",
+        description: "Declare the capability tier of the task you are starting: quick " +
+            "(routine edits, mechanical steps), standard (the default), or " +
+            "advanced (multi-step design, broad refactors, hard debugging). " +
+            "The declaration stays in force for this session until you declare " +
+            "a different tier. Only declare when the task's tier differs from " +
+            "the default; never use this to work around unavailability.",
+        input: {
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            type: "object",
+            properties: {
+                tier: {
+                    description: "The tier the current task needs.",
+                    enum: ["quick", "standard", "advanced"],
+                },
+            },
+            required: ["tier"],
+            additionalProperties: false,
+        },
+        options: { codemode: false },
+        execute: (input, context) => {
+            const tier = readTier(input);
+            if (tier === null) {
+                return Promise.resolve({
+                    content: [
+                        {
+                            type: "text",
+                            text: "adaptive_tier rejected: tier must be quick, standard, or advanced.",
+                        },
+                    ],
+                });
+            }
+            const accepted = record(context.sessionID, tier);
+            if (!accepted) {
+                return Promise.resolve({
+                    content: [
+                        {
+                            type: "text",
+                            text: "adaptive_tier rejected: the tier request was not accepted.",
+                        },
+                    ],
+                });
+            }
+            return Promise.resolve({
+                content: [
+                    {
+                        type: "text",
+                        text: `Tier request recorded: ${tier}. It steers this session's next admissions until cleared.`,
+                    },
+                ],
+            });
+        },
+    };
+}
+function readTier(input) {
+    if (typeof input !== "object" || input === null)
+        return null;
+    const tier = input.tier;
+    if (tier !== "quick" && tier !== "standard" && tier !== "advanced")
+        return null;
+    return tier;
+}
+//# sourceMappingURL=tier-tool.js.map

package/dist/adapters/opencode/tier-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-tool.js","sourceRoot":"","sources":["../../../src/adapters/opencode/tier-tool.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,MAA2B;IAClD,OAAO;QACL,IAAI,EAAE,eAAe;QACrB,WAAW,EACT,kEAAkE;YAClE,gEAAgE;YAChE,iEAAiE;YACjE,oEAAoE;YACpE,mEAAmE;YACnE,4DAA4D;QAC9D,KAAK,EAAE;YACL,OAAO,EAAE,8CAA8C;YACvD,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,IAAI,EAAE;oBACJ,WAAW,EAAE,kCAAkC;oBAC/C,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC;iBACxC;aACF;YACD,QAAQ,EAAE,CAAC,MAAM,CAAC;YAClB,oBAAoB,EAAE,KAAK;SACnB;QACV,OAAO,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAW;QACrC,OAAO,EAAE,CACP,KAAc,EACd,OAA8B,EAC0B,EAAE;YAC1D,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;YAC5B,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBAClB,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,OAAO,EAAE;wBACP;4BACE,IAAI,EAAE,MAAe;4BACrB,IAAI,EAAE,oEAAoE;yBAC3E;qBACF;iBACF,CAAC,CAAA;YACJ,CAAC;YACD,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;YAChD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,OAAO,EAAE;wBACP;4BACE,IAAI,EAAE,MAAe;4BACrB,IAAI,EAAE,4DAA4D;yBACnE;qBACF;iBACF,CAAC,CAAA;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,OAAO,EAAE;oBACP;wBACE,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE,0BAA0B,IAAI,2DAA2D;qBAChG;iBACF;aACF,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAC5D,MAAM,IAAI,GAAI,KAA4B,CAAC,IAAI,CAAA;IAC/C,IAAI,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,UAAU;QAAE,OAAO,IAAI,CAAA;IAC/E,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["import type { TierName } from \"../../core/tier-policy/types.js\"\n\n/** Records the agent's tier declaration; false = not accepted. */\nexport type TierRequestRecorder = (sessionID: string, tier: TierName) => boolean\n\n/**\n * The agent-declared tier tool: a typed sibling of adaptive_escalate. The\n * agent declares the tier of the task it is starting (\"this task is quick\")\n * and the declaration steers the session's next admissions until cleared —\n * one tier per task, not per unit. Plain JSON Schema: the host converts it,\n * and a Standard Schema vendor is silently dropped on 2.2.5.\n */\nexport function tierTool(record: TierRequestRecorder) {\n  return {\n    name: \"adaptive_tier\",\n    description:\n      \"Declare the capability tier of the task you are starting: quick \" +\n      \"(routine edits, mechanical steps), standard (the default), or \" +\n      \"advanced (multi-step design, broad refactors, hard debugging). \" +\n      \"The declaration stays in force for this session until you declare \" +\n      \"a different tier. Only declare when the task's tier differs from \" +\n      \"the default; never use this to work around unavailability.\",\n    input: {\n      $schema: \"https://json-schema.org/draft/2020-12/schema\",\n      type: \"object\",\n      properties: {\n        tier: {\n          description: \"The tier the current task needs.\",\n          enum: [\"quick\", \"standard\", \"advanced\"],\n        },\n      },\n      required: [\"tier\"],\n      additionalProperties: false,\n    } as const,\n    options: { codemode: false } as const,\n    execute: (\n      input: unknown,\n      context: { sessionID: string },\n    ): Promise<{ content: { type: \"text\"; text: string }[] }> => {\n      const tier = readTier(input)\n      if (tier === null) {\n        return Promise.resolve({\n          content: [\n            {\n              type: \"text\" as const,\n              text: \"adaptive_tier rejected: tier must be quick, standard, or advanced.\",\n            },\n          ],\n        })\n      }\n      const accepted = record(context.sessionID, tier)\n      if (!accepted) {\n        return Promise.resolve({\n          content: [\n            {\n              type: \"text\" as const,\n              text: \"adaptive_tier rejected: the tier request was not accepted.\",\n            },\n          ],\n        })\n      }\n      return Promise.resolve({\n        content: [\n          {\n            type: \"text\" as const,\n            text: `Tier request recorded: ${tier}. It steers this session's next admissions until cleared.`,\n          },\n        ],\n      })\n    },\n  }\n}\n\nfunction readTier(input: unknown): TierName | null {\n  if (typeof input !== \"object\" || input === null) return null\n  const tier = (input as { tier?: unknown }).tier\n  if (tier !== \"quick\" && tier !== \"standard\" && tier !== \"advanced\") return null\n  return tier\n}\n"]}

package/dist/adapters/opencode/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Adapter report types (ADP-025..ADP-031). The OpenCode adapter's only job is
+ * to observe host events and hooks and forward them as plain reports; every
+ * policy decision lives in the supervisor wiring. Report shapes mirror the
+ * verified `@opencode/plugin@2.2.5` surfaces structurally, so the adapter
+ * stays testable against typed fixtures without importing host internals
+ * beyond types.
+ */
+import type { ModelRef } from "../../core/work-unit/types.js";
+import type { RequestKind } from "../../core/tier-policy/types.js";
+/**
+ * Structural mirror of the wire `Session.StructuredError` (also the classifier
+ * evidence source). Declared locally because `SessionError.Error` is not
+ * re-exported by `@opencode/plugin` — the host payloads are assignable to
+ * this shape.
+ */
+export interface AdapterStructuredError {
+    readonly type: string;
+    readonly message: string;
+    readonly status?: number | undefined;
+    readonly response?: {
+        readonly body: string;
+    } | undefined;
+    readonly retryAfterMs?: number | undefined;
+}
+/** Work-unit lifecycle reports forwarded from `session.execution.*` events. */
+export type ExecutionReport = {
+    kind: "execution-started";
+    sessionID: string;
+    at: number;
+} | {
+    kind: "execution-succeeded";
+    sessionID: string;
+    at: number;
+} | {
+    kind: "execution-failed";
+    sessionID: string;
+    at: number;
+    error: AdapterStructuredError;
+} | {
+    kind: "execution-interrupted";
+    sessionID: string;
+    at: number;
+    reason: string;
+} | {
+    kind: "model-selected";
+    sessionID: string;
+    at: number;
+    model: ModelRef;
+};
+/**
+ * Model request reports from the `context` hook (the agent loop, always
+ * `primary`) and the `model.request` hook (which carries the request kind for
+ * auxiliary requests — ADP-027).
+ */
+export interface ModelRequestReport {
+    kind: "model-request";
+    sessionID: string;
+    model: ModelRef;
+    requestKind: RequestKind;
+    /** The agent the request runs under (ADP-002 role-hint routing evidence). */
+    agent?: string;
+}
+/**
+ * HTTP response evidence from the `http.response` hook. The response body is
+ * cloned exactly once and only a bounded excerpt is kept — the original body
+ * stays untouched for the host. WebSocket-backed providers bypass this hook
+ * entirely (verified limitation), so this evidence is never load-bearing.
+ */
+export interface HttpResponseReport {
+    kind: "http-response";
+    sessionID: string;
+    status: number;
+    /** Raw `Retry-After` header value; the supervisor parses it, not the adapter. */
+    retryAfterHeader?: string | undefined;
+    bodyExcerpt?: string | undefined;
+    /**
+     * Captured quota-telemetry headers selected by the wiring-supplied capture
+     * predicate (an allowlist — no other header ever leaves the response, so
+     * credentials and cookies cannot leak). Bounded in count and value length.
+     */
+    capturedHeaders?: Readonly<Record<string, string>> | undefined;
+}
+/** Idle-boundary report from the `experimental.idle` hook (safe boundary). */
+export interface IdleReport {
+    kind: "idle";
+    sessionID: string;
+}
+/**
+ * User-prompt report from the `session.hook("prompt")` hook. The hook is
+ * awaited BEFORE the turn's model resolution, so admission performed here
+ * lands on the very turn that triggered it — the event pump's
+ * execution-started report is asynchronous and races the turn (empirically
+ * verified on opencode 2.2.5).
+ */
+export interface PromptReport {
+    kind: "prompt";
+    sessionID: string;
+}
+/** Everything the adapter forwards to the supervisor. */
+export type EventReport = ExecutionReport | ModelRequestReport | HttpResponseReport | IdleReport | PromptReport;

package/dist/adapters/opencode/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/adapters/opencode/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/adapters/opencode/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Adapter report types (ADP-025..ADP-031). The OpenCode adapter's only job is\n * to observe host events and hooks and forward them as plain reports; every\n * policy decision lives in the supervisor wiring. Report shapes mirror the\n * verified `@opencode/plugin@2.2.5` surfaces structurally, so the adapter\n * stays testable against typed fixtures without importing host internals\n * beyond types.\n */\nimport type { ModelRef } from \"../../core/work-unit/types.js\"\nimport type { RequestKind } from \"../../core/tier-policy/types.js\"\n\n/**\n * Structural mirror of the wire `Session.StructuredError` (also the classifier\n * evidence source). Declared locally because `SessionError.Error` is not\n * re-exported by `@opencode/plugin` — the host payloads are assignable to\n * this shape.\n */\nexport interface AdapterStructuredError {\n  readonly type: string\n  readonly message: string\n  readonly status?: number | undefined\n  readonly response?: { readonly body: string } | undefined\n  readonly retryAfterMs?: number | undefined\n}\n\n/** Work-unit lifecycle reports forwarded from `session.execution.*` events. */\nexport type ExecutionReport =\n  | { kind: \"execution-started\"; sessionID: string; at: number }\n  | { kind: \"execution-succeeded\"; sessionID: string; at: number }\n  | { kind: \"execution-failed\"; sessionID: string; at: number; error: AdapterStructuredError }\n  | { kind: \"execution-interrupted\"; sessionID: string; at: number; reason: string }\n  | { kind: \"model-selected\"; sessionID: string; at: number; model: ModelRef }\n\n/**\n * Model request reports from the `context` hook (the agent loop, always\n * `primary`) and the `model.request` hook (which carries the request kind for\n * auxiliary requests — ADP-027).\n */\nexport interface ModelRequestReport {\n  kind: \"model-request\"\n  sessionID: string\n  model: ModelRef\n  requestKind: RequestKind\n  /** The agent the request runs under (ADP-002 role-hint routing evidence). */\n  agent?: string\n}\n\n/**\n * HTTP response evidence from the `http.response` hook. The response body is\n * cloned exactly once and only a bounded excerpt is kept — the original body\n * stays untouched for the host. WebSocket-backed providers bypass this hook\n * entirely (verified limitation), so this evidence is never load-bearing.\n */\nexport interface HttpResponseReport {\n  kind: \"http-response\"\n  sessionID: string\n  status: number\n  /** Raw `Retry-After` header value; the supervisor parses it, not the adapter. */\n  retryAfterHeader?: string | undefined\n  bodyExcerpt?: string | undefined\n  /**\n   * Captured quota-telemetry headers selected by the wiring-supplied capture\n   * predicate (an allowlist — no other header ever leaves the response, so\n   * credentials and cookies cannot leak). Bounded in count and value length.\n   */\n  capturedHeaders?: Readonly<Record<string, string>> | undefined\n}\n\n/** Idle-boundary report from the `experimental.idle` hook (safe boundary). */\nexport interface IdleReport {\n  kind: \"idle\"\n  sessionID: string\n}\n\n/**\n * User-prompt report from the `session.hook(\"prompt\")` hook. The hook is\n * awaited BEFORE the turn's model resolution, so admission performed here\n * lands on the very turn that triggered it — the event pump's\n * execution-started report is asynchronous and races the turn (empirically\n * verified on opencode 2.2.5).\n */\nexport interface PromptReport {\n  kind: \"prompt\"\n  sessionID: string\n}\n\n/** Everything the adapter forwards to the supervisor. */\nexport type EventReport =\n  ExecutionReport | ModelRequestReport | HttpResponseReport | IdleReport | PromptReport\n"]}

package/dist/core/compatibility/gate.d.ts

@@ -0,0 +1,7 @@
+import type { CandidateModel, Demand, Verdict } from "./types.js";
+/**
+ * Run every check and accumulate reasons in fixed order. A candidate is
+ * compatible only when no reason applies; unknown candidate metadata never
+ * satisfies a stated requirement.
+ */
+export declare function checkCompatibility(candidate: CandidateModel, demand: Demand): Verdict;

package/dist/core/compatibility/gate.js

@@ -0,0 +1,51 @@
+/** A finite, non-negative token count is assessable; anything else is unknown demand. */
+function assessableTokens(value) {
+    return value !== undefined && Number.isFinite(value) && value >= 0;
+}
+function supportsModalities(supported, demanded) {
+    if (supported === undefined) {
+        return false;
+    }
+    return demanded.every((modality) => supported.includes(modality));
+}
+/**
+ * Run every check and accumulate reasons in fixed order. A candidate is
+ * compatible only when no reason applies; unknown candidate metadata never
+ * satisfies a stated requirement.
+ */
+export function checkCompatibility(candidate, demand) {
+    const reasons = [];
+    if (candidate.providerEnabled !== true) {
+        reasons.push("provider-unavailable");
+    }
+    if (candidate.enabled !== true) {
+        reasons.push("model-unavailable");
+    }
+    if (candidate.variant !== undefined && candidate.variantAvailable !== true) {
+        reasons.push("variant-unavailable");
+    }
+    if (demand.tools === true && candidate.capabilities?.tools !== true) {
+        reasons.push("tool-use-unsupported");
+    }
+    if (demand.input !== undefined &&
+        demand.input.length > 0 &&
+        !supportsModalities(candidate.capabilities?.input, demand.input)) {
+        reasons.push("input-modality-unsupported");
+    }
+    if (demand.output !== undefined &&
+        demand.output.length > 0 &&
+        !supportsModalities(candidate.capabilities?.output, demand.output)) {
+        reasons.push("output-modality-unsupported");
+    }
+    if (assessableTokens(demand.contextTokens)) {
+        const contextLimit = candidate.limit?.context;
+        if (!assessableTokens(contextLimit)) {
+            reasons.push("context-capacity-unknown");
+        }
+        else if (contextLimit < demand.contextTokens) {
+            reasons.push("context-capacity-insufficient");
+        }
+    }
+    return { compatible: reasons.length === 0, reasons };
+}
+//# sourceMappingURL=gate.js.map

package/dist/core/compatibility/gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../../src/core/compatibility/gate.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,SAAS,gBAAgB,CAAC,KAAyB;IACjD,OAAO,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;AACpE,CAAC;AAED,SAAS,kBAAkB,CACzB,SAAwC,EACxC,QAA2B;IAE3B,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,KAAK,CAAA;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAA;AACnE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAyB,EAAE,MAAc;IAC1E,MAAM,OAAO,GAA4B,EAAE,CAAA;IAE3C,IAAI,SAAS,CAAC,eAAe,KAAK,IAAI,EAAE,CAAC;QACvC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAA;IACtC,CAAC;IACD,IAAI,SAAS,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC/B,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAA;IACnC,CAAC;IACD,IAAI,SAAS,CAAC,OAAO,KAAK,SAAS,IAAI,SAAS,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;QAC3E,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAA;IACrC,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,IAAI,SAAS,CAAC,YAAY,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;QACpE,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAA;IACtC,CAAC;IACD,IACE,MAAM,CAAC,KAAK,KAAK,SAAS;QAC1B,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;QACvB,CAAC,kBAAkB,CAAC,SAAS,CAAC,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAChE,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAA;IAC5C,CAAC;IACD,IACE,MAAM,CAAC,MAAM,KAAK,SAAS;QAC3B,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;QACxB,CAAC,kBAAkB,CAAC,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAClE,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAA;IAC7C,CAAC;IAED,IAAI,gBAAgB,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;QAC3C,MAAM,YAAY,GAAG,SAAS,CAAC,KAAK,EAAE,OAAO,CAAA;QAC7C,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAAE,CAAC;YACpC,OAAO,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAA;QAC1C,CAAC;aAAM,IAAI,YAAY,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;YAC/C,OAAO,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAA;QAC/C,CAAC;IACH,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;AACtD,CAAC","sourcesContent":["import type { CandidateModel, Demand, IncompatibilityReason, Verdict } from \"./types.js\"\n\n/** A finite, non-negative token count is assessable; anything else is unknown demand. */\nfunction assessableTokens(value: number | undefined): value is number {\n  return value !== undefined && Number.isFinite(value) && value >= 0\n}\n\nfunction supportsModalities(\n  supported: readonly string[] | undefined,\n  demanded: readonly string[],\n): boolean {\n  if (supported === undefined) {\n    return false\n  }\n  return demanded.every((modality) => supported.includes(modality))\n}\n\n/**\n * Run every check and accumulate reasons in fixed order. A candidate is\n * compatible only when no reason applies; unknown candidate metadata never\n * satisfies a stated requirement.\n */\nexport function checkCompatibility(candidate: CandidateModel, demand: Demand): Verdict {\n  const reasons: IncompatibilityReason[] = []\n\n  if (candidate.providerEnabled !== true) {\n    reasons.push(\"provider-unavailable\")\n  }\n  if (candidate.enabled !== true) {\n    reasons.push(\"model-unavailable\")\n  }\n  if (candidate.variant !== undefined && candidate.variantAvailable !== true) {\n    reasons.push(\"variant-unavailable\")\n  }\n\n  if (demand.tools === true && candidate.capabilities?.tools !== true) {\n    reasons.push(\"tool-use-unsupported\")\n  }\n  if (\n    demand.input !== undefined &&\n    demand.input.length > 0 &&\n    !supportsModalities(candidate.capabilities?.input, demand.input)\n  ) {\n    reasons.push(\"input-modality-unsupported\")\n  }\n  if (\n    demand.output !== undefined &&\n    demand.output.length > 0 &&\n    !supportsModalities(candidate.capabilities?.output, demand.output)\n  ) {\n    reasons.push(\"output-modality-unsupported\")\n  }\n\n  if (assessableTokens(demand.contextTokens)) {\n    const contextLimit = candidate.limit?.context\n    if (!assessableTokens(contextLimit)) {\n      reasons.push(\"context-capacity-unknown\")\n    } else if (contextLimit < demand.contextTokens) {\n      reasons.push(\"context-capacity-insufficient\")\n    }\n  }\n\n  return { compatible: reasons.length === 0, reasons }\n}\n"]}

package/dist/core/compatibility/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./gate.js";

package/dist/core/compatibility/index.js

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

package/dist/core/compatibility/index.js.map

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

package/dist/core/compatibility/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Compatibility gate (ADP-017): filters candidates on context capacity,
+ * tool use, modalities, and model/variant/provider availability BEFORE
+ * health/preference ranking. Pure — adapters map OpenCode `Model.Info` /
+ * `Provider.Info` into `CandidateModel`, this module never touches
+ * `@opencode/plugin` types.
+ *
+ * Conservative rule: metadata the gate needs but cannot see is treated as
+ * NOT satisfying the requirement (e.g. unknown `enabled`, unknown tool
+ * support, unknown context limit). Only demand-side quantities that are
+ * themselves unknown are skipped — there is nothing to check against.
+ */
+/** What the executing work needs from a resource. All demand fields are optional. */
+export interface Demand {
+    /** The unit needs tool use. `undefined`/`false` imposes no tool requirement. */
+    readonly tools?: boolean | undefined;
+    /** Input modalities the unit carries (e.g. `"text"`, `"image"`). */
+    readonly input?: readonly string[] | undefined;
+    /** Output modalities the unit must produce. */
+    readonly output?: readonly string[] | undefined;
+    /** Known or estimated context need in tokens; `undefined` skips the capacity check. */
+    readonly contextTokens?: number | undefined;
+}
+/** Adapter-normalized view of one candidate resource. */
+export interface CandidateModel {
+    readonly providerID: string;
+    readonly modelID: string;
+    readonly variant?: string | undefined;
+    /** Model is enabled in the host inventory. Unknown ⇒ conservative reject. */
+    readonly enabled?: boolean | undefined;
+    /** Provider is available in the host inventory. Unknown ⇒ conservative reject. */
+    readonly providerEnabled?: boolean | undefined;
+    /** The requested variant exists for this model. Unknown ⇒ conservative reject. */
+    readonly variantAvailable?: boolean | undefined;
+    readonly capabilities?: {
+        readonly tools?: boolean | undefined;
+        readonly input?: readonly string[] | undefined;
+        readonly output?: readonly string[] | undefined;
+    } | undefined;
+    readonly limit?: {
+        readonly context?: number | undefined;
+    } | undefined;
+}
+/**
+ * Why a candidate failed the gate, in the fixed order the checks run:
+ * availability → tools → input modalities → output modalities → context.
+ */
+export declare const INCOMPATIBILITY_REASONS: readonly ["provider-unavailable", "model-unavailable", "variant-unavailable", "tool-use-unsupported", "input-modality-unsupported", "output-modality-unsupported", "context-capacity-insufficient", "context-capacity-unknown"];
+export type IncompatibilityReason = (typeof INCOMPATIBILITY_REASONS)[number];
+export interface Verdict {
+    readonly compatible: boolean;
+    readonly reasons: readonly IncompatibilityReason[];
+}

package/dist/core/compatibility/types.js

@@ -0,0 +1,27 @@
+/**
+ * Compatibility gate (ADP-017): filters candidates on context capacity,
+ * tool use, modalities, and model/variant/provider availability BEFORE
+ * health/preference ranking. Pure — adapters map OpenCode `Model.Info` /
+ * `Provider.Info` into `CandidateModel`, this module never touches
+ * `@opencode/plugin` types.
+ *
+ * Conservative rule: metadata the gate needs but cannot see is treated as
+ * NOT satisfying the requirement (e.g. unknown `enabled`, unknown tool
+ * support, unknown context limit). Only demand-side quantities that are
+ * themselves unknown are skipped — there is nothing to check against.
+ */
+/**
+ * Why a candidate failed the gate, in the fixed order the checks run:
+ * availability → tools → input modalities → output modalities → context.
+ */
+export const INCOMPATIBILITY_REASONS = [
+    "provider-unavailable",
+    "model-unavailable",
+    "variant-unavailable",
+    "tool-use-unsupported",
+    "input-modality-unsupported",
+    "output-modality-unsupported",
+    "context-capacity-insufficient",
+    "context-capacity-unknown",
+];
+//# sourceMappingURL=types.js.map

package/dist/core/compatibility/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/compatibility/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAmCH;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,sBAAsB;IACtB,mBAAmB;IACnB,qBAAqB;IACrB,sBAAsB;IACtB,4BAA4B;IAC5B,6BAA6B;IAC7B,+BAA+B;IAC/B,0BAA0B;CACU,CAAA","sourcesContent":["/**\n * Compatibility gate (ADP-017): filters candidates on context capacity,\n * tool use, modalities, and model/variant/provider availability BEFORE\n * health/preference ranking. Pure — adapters map OpenCode `Model.Info` /\n * `Provider.Info` into `CandidateModel`, this module never touches\n * `@opencode/plugin` types.\n *\n * Conservative rule: metadata the gate needs but cannot see is treated as\n * NOT satisfying the requirement (e.g. unknown `enabled`, unknown tool\n * support, unknown context limit). Only demand-side quantities that are\n * themselves unknown are skipped — there is nothing to check against.\n */\n\n/** What the executing work needs from a resource. All demand fields are optional. */\nexport interface Demand {\n  /** The unit needs tool use. `undefined`/`false` imposes no tool requirement. */\n  readonly tools?: boolean | undefined\n  /** Input modalities the unit carries (e.g. `\"text\"`, `\"image\"`). */\n  readonly input?: readonly string[] | undefined\n  /** Output modalities the unit must produce. */\n  readonly output?: readonly string[] | undefined\n  /** Known or estimated context need in tokens; `undefined` skips the capacity check. */\n  readonly contextTokens?: number | undefined\n}\n\n/** Adapter-normalized view of one candidate resource. */\nexport interface CandidateModel {\n  readonly providerID: string\n  readonly modelID: string\n  readonly variant?: string | undefined\n  /** Model is enabled in the host inventory. Unknown ⇒ conservative reject. */\n  readonly enabled?: boolean | undefined\n  /** Provider is available in the host inventory. Unknown ⇒ conservative reject. */\n  readonly providerEnabled?: boolean | undefined\n  /** The requested variant exists for this model. Unknown ⇒ conservative reject. */\n  readonly variantAvailable?: boolean | undefined\n  readonly capabilities?:\n    | {\n        readonly tools?: boolean | undefined\n        readonly input?: readonly string[] | undefined\n        readonly output?: readonly string[] | undefined\n      }\n    | undefined\n  readonly limit?: { readonly context?: number | undefined } | undefined\n}\n\n/**\n * Why a candidate failed the gate, in the fixed order the checks run:\n * availability → tools → input modalities → output modalities → context.\n */\nexport const INCOMPATIBILITY_REASONS = [\n  \"provider-unavailable\",\n  \"model-unavailable\",\n  \"variant-unavailable\",\n  \"tool-use-unsupported\",\n  \"input-modality-unsupported\",\n  \"output-modality-unsupported\",\n  \"context-capacity-insufficient\",\n  \"context-capacity-unknown\",\n] as const satisfies readonly string[]\n\nexport type IncompatibilityReason = (typeof INCOMPATIBILITY_REASONS)[number]\n\nexport interface Verdict {\n  readonly compatible: boolean\n  readonly reasons: readonly IncompatibilityReason[]\n}\n"]}

package/dist/core/scheduler/admit.d.ts

@@ -0,0 +1,6 @@
+import type { AdmissionDecision, SchedulerInput } from "./types.js";
+/**
+ * Decide the model for a fresh work unit. Total and deterministic: the same
+ * input always yields the same decision, and the function has no effects.
+ */
+export declare function admit(input: SchedulerInput): AdmissionDecision;