@coool/opencode-adaptive 0.0.0-stage → 1.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-tool.js","sourceRoot":"","sources":["../../../src/adapters/opencode/escalation-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AAElG,OAAO,EAAE,oBAAoB,EAAE,CAAA;AAK/B,MAAM,gBAAgB,GACpB,0FAA0F;IAC1F,sFAAsF;IACtF,2FAA2F;IAC3F,wFAAwF;IACxF,0FAA0F;IAC1F,0BAA0B,CAAA;AAE5B,sEAAsE;AACtE,MAAM,qBAAqB,GAAG;IAC5B,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,CAAC;YACZ,WAAW,EAAE,mEAAmE;SACjF;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,CAAC;YACZ,WAAW,EAAE,sEAAsE;SACpF;KACF;IACD,QAAQ,EAAE,CAAC,QAAQ,EAAE,UAAU,CAAC;IAChC,oBAAoB,EAAE,KAAK;CAC5B,CAAA;AAED,6EAA6E;AAC7E,MAAM,qBAAqB,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAW,CAAA;AAE1D,6EAA6E;AAC7E,MAAM,UAAU,cAAc,CAAC,MAA0B;IAOvD,OAAO;QACL,IAAI,EAAE,oBAAoB;QAC1B,WAAW,EAAE,gBAAgB;QAC7B,KAAK,EAAE,qBAAqB;QAC5B,OAAO,EAAE,qBAAqB;QAC9B,OAAO,EAAE,CAAC,KAAc,EAAE,OAA8B,EAAE,EAAE;YAC1D,MAAM,OAAO,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAA;YAC7C,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,oDAAoD,EAAE,CAAC,CAAA;YAC3F,CAAC;YACD,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;YAC5E,OAAO,OAAO,CAAC,OAAO,CACpB,QAAQ;gBACN,CAAC,CAAC,EAAE,OAAO,EAAE,uDAAuD,EAAE;gBACtE,CAAC,CAAC,EAAE,OAAO,EAAE,mDAAmD,EAAE,CACrE,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["/**\n * The typed escalation tool (T-18, ADP-015): the smallest Adaptive-owned\n * mechanism for an agent to request stronger capability. The input schema is\n * a plain JSON Schema — the host builds the model-facing tool definition by\n * converting the schema, and a Standard Schema implementation is silently\n * dropped (\"Schema vendor does not support JSON Schema conversion\", observed\n * on 2.2.5). The tool also opts out of the host's code-mode bundling: with\n * code mode enabled the host routes codemode-bundled tools through the\n * `execute` tool only, and a direct call fails with \"No tool named ... is\n * currently available\" (observed on 2.2.5). `execute` still re-validates\n * defensively: model-produced JSON is untrusted. The tool is deliberately\n * not a planning or task-management API.\n */\nimport { ESCALATION_TOOL_NAME, parseEscalationRequest } from \"../../execution/escalation/index.js\"\n\nexport { ESCALATION_TOOL_NAME }\n\n/** Records the request against the session's current work unit. */\nexport type EscalationRecorder = (sessionID: string, reason: string, evidence: string) => boolean\n\nconst TOOL_DESCRIPTION =\n  \"Request stronger model capability for the current work unit. Provide a short reason and \" +\n  \"the concrete evidence (what failed or was blocked). Adaptive records the request as \" +\n  \"structured evidence and weighs it when a failure on this unit is already classified as a \" +\n  \"capability gap (for example context overflow or a content-policy rejection), within a \" +\n  \"finite budget; recording alone does not force a tier escalation. This is not a planning \" +\n  \"or task-management tool.\"\n\n/** The tool's input schema in JSON Schema form (host-convertible). */\nconst escalationInputSchema = {\n  type: \"object\",\n  properties: {\n    reason: {\n      type: \"string\",\n      minLength: 1,\n      description: \"Short reason why the current work unit needs stronger capability.\",\n    },\n    evidence: {\n      type: \"string\",\n      minLength: 1,\n      description: \"Concrete evidence of the capability gap: what failed or was blocked.\",\n    },\n  },\n  required: [\"reason\", \"evidence\"],\n  additionalProperties: false,\n}\n\n/** Keeps the tool directly callable when the host's code mode is enabled. */\nconst escalationToolOptions = { codemode: false } as const\n\n/** Build the plugin tool registration for the escalation request surface. */\nexport function escalationTool(record: EscalationRecorder): {\n  name: typeof ESCALATION_TOOL_NAME\n  description: string\n  input: typeof escalationInputSchema\n  options: typeof escalationToolOptions\n  execute: (input: unknown, context: { sessionID: string }) => Promise<{ content: string }>\n} {\n  return {\n    name: ESCALATION_TOOL_NAME,\n    description: TOOL_DESCRIPTION,\n    input: escalationInputSchema,\n    options: escalationToolOptions,\n    execute: (input: unknown, context: { sessionID: string }) => {\n      const request = parseEscalationRequest(input)\n      if (request === undefined) {\n        return Promise.resolve({ content: \"reason and evidence are required non-empty strings\" })\n      }\n      const recorded = record(context.sessionID, request.reason, request.evidence)\n      return Promise.resolve(\n        recorded\n          ? { content: \"escalation request recorded for the current work unit\" }\n          : { content: \"no active work unit; the request was not recorded\" },\n      )\n    },\n  }\n}\n"]}

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

@@ -0,0 +1,23 @@
+/**
+ * Session event subscription (ADP-001). Subscribes to the lifecycle/
+ * selection events, maps them into reports, and pumps them to the supervisor.
+ * The pump runs until disposed. A stream error (SSE hiccup, host reconnect)
+ * must not permanently silence observation — the pump resubscribes with a
+ * bounded backoff and reports each failure to `onError` (wiring decides
+ * fail-open behavior — ADP-031). Abort-induced termination is quiet.
+ */
+import type { EventDomain } from "@opencode/plugin/promise/event";
+/** The event surface the subscription actually uses (structural — fixture-friendly). */
+export type EventSource = Pick<EventDomain, "subscribe">;
+import type { ExecutionReport } from "./types.js";
+export declare const SESSION_EVENT_TYPES: readonly ["session.execution.started", "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.model.selected"];
+export interface SessionSubscription {
+    /** Abort the stream; the pump settles quietly. */
+    dispose(): void;
+    /** Settles when the pump ends (disposed or errored). */
+    done: Promise<void>;
+}
+/** Subscribe and pump session lifecycle reports to `onReport`, resubscribing after stream errors. */
+export declare function subscribeSessions(events: EventSource, onReport: (report: ExecutionReport) => void, onError: (error: unknown) => void, 
+/** Injectable so tests never wait on real timers. */
+pause?: (ms: number) => Promise<void>): SessionSubscription;

package/dist/adapters/opencode/events.js

@@ -0,0 +1,68 @@
+import { mapSessionEvent } from "./report.js";
+export const SESSION_EVENT_TYPES = [
+    "session.execution.started",
+    "session.execution.succeeded",
+    "session.execution.failed",
+    "session.execution.interrupted",
+    "session.model.selected",
+];
+const RETRY_BASE_MS = 1_000;
+const RETRY_MAX_MS = 30_000;
+const defaultPause = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+/** Subscribe and pump session lifecycle reports to `onReport`, resubscribing after stream errors. */
+export function subscribeSessions(events, onReport, onError, 
+/** Injectable so tests never wait on real timers. */
+pause = defaultPause) {
+    const controller = new AbortController();
+    // Checked through a function on purpose: TS narrows the `controller.signal`
+    // property after the first guard, but `dispose()` flips `aborted` from
+    // another context mid-pump, so every re-check below is load-bearing.
+    const aborted = () => controller.signal.aborted;
+    const done = (async () => {
+        let backoff = RETRY_BASE_MS;
+        for (;;) {
+            if (aborted())
+                return;
+            // Events delivered since the last failure prove the stream itself
+            // works; a fresh failure then starts the backoff climb again.
+            let delivered = 0;
+            try {
+                const stream = events.subscribe({
+                    types: [...SESSION_EVENT_TYPES],
+                    signal: controller.signal,
+                });
+                for await (const event of stream) {
+                    const report = mapSessionEvent(event);
+                    if (report !== null) {
+                        delivered += 1;
+                        onReport(report);
+                    }
+                }
+                // A clean stream end is still an observation outage: the host closed
+                // the subscription, so fall through to the resubscribe path.
+                if (!aborted())
+                    onError(new Error("session event stream ended"));
+            }
+            catch (error) {
+                if (aborted())
+                    return;
+                onError(error);
+            }
+            if (aborted())
+                return;
+            if (delivered > 0)
+                backoff = RETRY_BASE_MS;
+            await pause(backoff);
+            backoff = Math.min(backoff * 2, RETRY_MAX_MS);
+        }
+    })();
+    return {
+        dispose: () => {
+            controller.abort();
+        },
+        done,
+    };
+}
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../src/adapters/opencode/events.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,eAAe,EAAqB,MAAM,aAAa,CAAA;AAGhE,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,2BAA2B;IAC3B,6BAA6B;IAC7B,0BAA0B;IAC1B,+BAA+B;IAC/B,wBAAwB;CACY,CAAA;AAStC,MAAM,aAAa,GAAG,KAAK,CAAA;AAC3B,MAAM,YAAY,GAAG,MAAM,CAAA;AAE3B,MAAM,YAAY,GAAG,CAAC,EAAU,EAAiB,EAAE,CACjD,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;IAC5B,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;AACzB,CAAC,CAAC,CAAA;AAEJ,qGAAqG;AACrG,MAAM,UAAU,iBAAiB,CAC/B,MAAmB,EACnB,QAA2C,EAC3C,OAAiC;AACjC,qDAAqD;AACrD,QAAuC,YAAY;IAEnD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAA;IACxC,4EAA4E;IAC5E,uEAAuE;IACvE,qEAAqE;IACrE,MAAM,OAAO,GAAG,GAAY,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAA;IACxD,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE;QACvB,IAAI,OAAO,GAAG,aAAa,CAAA;QAC3B,SAAS,CAAC;YACR,IAAI,OAAO,EAAE;gBAAE,OAAM;YACrB,kEAAkE;YAClE,8DAA8D;YAC9D,IAAI,SAAS,GAAG,CAAC,CAAA;YACjB,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC;oBAC9B,KAAK,EAAE,CAAC,GAAG,mBAAmB,CAAC;oBAC/B,MAAM,EAAE,UAAU,CAAC,MAAM;iBAC1B,CAAC,CAAA;gBACF,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAqC,EAAE,CAAC;oBAChE,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,CAAA;oBACrC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;wBACpB,SAAS,IAAI,CAAC,CAAA;wBACd,QAAQ,CAAC,MAAM,CAAC,CAAA;oBAClB,CAAC;gBACH,CAAC;gBACD,qEAAqE;gBACrE,6DAA6D;gBAC7D,IAAI,CAAC,OAAO,EAAE;oBAAE,OAAO,CAAC,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAA;YAClE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,OAAO,EAAE;oBAAE,OAAM;gBACrB,OAAO,CAAC,KAAK,CAAC,CAAA;YAChB,CAAC;YACD,IAAI,OAAO,EAAE;gBAAE,OAAM;YACrB,IAAI,SAAS,GAAG,CAAC;gBAAE,OAAO,GAAG,aAAa,CAAA;YAC1C,MAAM,KAAK,CAAC,OAAO,CAAC,CAAA;YACpB,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,EAAE,YAAY,CAAC,CAAA;QAC/C,CAAC;IACH,CAAC,CAAC,EAAE,CAAA;IACJ,OAAO;QACL,OAAO,EAAE,GAAG,EAAE;YACZ,UAAU,CAAC,KAAK,EAAE,CAAA;QACpB,CAAC;QACD,IAAI;KACL,CAAA;AACH,CAAC","sourcesContent":["/**\n * Session event subscription (ADP-001). Subscribes to the lifecycle/\n * selection events, maps them into reports, and pumps them to the supervisor.\n * The pump runs until disposed. A stream error (SSE hiccup, host reconnect)\n * must not permanently silence observation — the pump resubscribes with a\n * bounded backoff and reports each failure to `onError` (wiring decides\n * fail-open behavior — ADP-031). Abort-induced termination is quiet.\n */\nimport type { EventDomain } from \"@opencode/plugin/promise/event\"\n\n/** The event surface the subscription actually uses (structural — fixture-friendly). */\nexport type EventSource = Pick<EventDomain, \"subscribe\">\nimport { mapSessionEvent, type SessionEvent } from \"./report.js\"\nimport type { ExecutionReport } from \"./types.js\"\n\nexport const SESSION_EVENT_TYPES = [\n  \"session.execution.started\",\n  \"session.execution.succeeded\",\n  \"session.execution.failed\",\n  \"session.execution.interrupted\",\n  \"session.model.selected\",\n] as const satisfies readonly string[]\n\nexport interface SessionSubscription {\n  /** Abort the stream; the pump settles quietly. */\n  dispose(): void\n  /** Settles when the pump ends (disposed or errored). */\n  done: Promise<void>\n}\n\nconst RETRY_BASE_MS = 1_000\nconst RETRY_MAX_MS = 30_000\n\nconst defaultPause = (ms: number): Promise<void> =>\n  new Promise<void>((resolve) => {\n    setTimeout(resolve, ms)\n  })\n\n/** Subscribe and pump session lifecycle reports to `onReport`, resubscribing after stream errors. */\nexport function subscribeSessions(\n  events: EventSource,\n  onReport: (report: ExecutionReport) => void,\n  onError: (error: unknown) => void,\n  /** Injectable so tests never wait on real timers. */\n  pause: (ms: number) => Promise<void> = defaultPause,\n): SessionSubscription {\n  const controller = new AbortController()\n  // Checked through a function on purpose: TS narrows the `controller.signal`\n  // property after the first guard, but `dispose()` flips `aborted` from\n  // another context mid-pump, so every re-check below is load-bearing.\n  const aborted = (): boolean => controller.signal.aborted\n  const done = (async () => {\n    let backoff = RETRY_BASE_MS\n    for (;;) {\n      if (aborted()) return\n      // Events delivered since the last failure prove the stream itself\n      // works; a fresh failure then starts the backoff climb again.\n      let delivered = 0\n      try {\n        const stream = events.subscribe({\n          types: [...SESSION_EVENT_TYPES],\n          signal: controller.signal,\n        })\n        for await (const event of stream as AsyncIterable<SessionEvent>) {\n          const report = mapSessionEvent(event)\n          if (report !== null) {\n            delivered += 1\n            onReport(report)\n          }\n        }\n        // A clean stream end is still an observation outage: the host closed\n        // the subscription, so fall through to the resubscribe path.\n        if (!aborted()) onError(new Error(\"session event stream ended\"))\n      } catch (error) {\n        if (aborted()) return\n        onError(error)\n      }\n      if (aborted()) return\n      if (delivered > 0) backoff = RETRY_BASE_MS\n      await pause(backoff)\n      backoff = Math.min(backoff * 2, RETRY_MAX_MS)\n    }\n  })()\n  return {\n    dispose: () => {\n      controller.abort()\n    },\n    done,\n  }\n}\n"]}

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

@@ -0,0 +1,34 @@
+/**
+ * Session hook registration (ADP-012/ADP-013/ADP-027). Registers the hooks the
+ * supervisor needs on the host session domain and returns their registrations
+ * for cleanup. Hooks MUTATE their inputs on the host — the retry handler owns
+ * `input.decision`; the adapter passes the raw input through so wiring can
+ * veto (`{ retry: false }`) or leave OpenCode's native retry untouched.
+ *
+ * Fail-open behavior (ADP-031) is applied by the wiring around these handlers;
+ * the adapter itself never swallows errors, so wiring sees every failure.
+ */
+import type { Registration } from "@opencode/plugin/promise/registration";
+import type { SessionDomain, SessionRetry } from "@opencode/plugin/promise/session";
+/** The session surface the hooks actually use (structural — fixture-friendly). */
+export type SessionHookSource = Pick<SessionDomain, "hook">;
+import type { HttpResponseReport, IdleReport, ModelRequestReport, PromptReport } from "./types.js";
+export interface SessionHookHandlers {
+    /** Raw retry hook input; wiring decides and mutates `input.decision`. */
+    readonly onRetry: (input: SessionRetry) => Promise<void> | void;
+    readonly onModelRequest: (report: ModelRequestReport) => Promise<void> | void;
+    readonly onHttpResponse: (report: HttpResponseReport) => Promise<void> | void;
+    readonly onIdle: (report: IdleReport) => Promise<void> | void;
+    /** Awaited before the turn's model resolution — the admission boundary. */
+    readonly onPrompt: (report: PromptReport) => Promise<void> | void;
+}
+/** Optional hook behavior supplied by the wiring. */
+export interface SessionHookOptions {
+    /**
+     * Allowlist predicate over lowercase response header names selecting the
+     * quota telemetry to capture (no other header ever leaves the response).
+     */
+    readonly capture?: (lowercaseName: string) => boolean;
+}
+/** Register supervisor hooks; resolves to all registrations (dispose in order). */
+export declare function registerSessionHooks(session: SessionHookSource, handlers: SessionHookHandlers, options?: SessionHookOptions): Promise<Registration[]>;

package/dist/adapters/opencode/hooks.js

@@ -0,0 +1,29 @@
+import { contextModelRequest, hookModelRequest, mapHttpResponse } from "./report.js";
+/** Register supervisor hooks; resolves to all registrations (dispose in order). */
+export async function registerSessionHooks(session, handlers, options) {
+    const acquired = [];
+    try {
+        acquired.push(await session.hook("retry", (input) => handlers.onRetry(input)));
+        acquired.push(await session.hook("context", (input) => handlers.onModelRequest(contextModelRequest(input))));
+        acquired.push(await session.hook("model.request", (input) => handlers.onModelRequest(hookModelRequest(input))));
+        acquired.push(await session.hook("http.response", async (input) => handlers.onHttpResponse(await mapHttpResponse(input, options))));
+        acquired.push(await session.hook("experimental.idle", (input) => handlers.onIdle({ kind: "idle", sessionID: input.sessionID })));
+        acquired.push(await session.hook("prompt", (input) => handlers.onPrompt({ kind: "prompt", sessionID: input.sessionID })));
+        return acquired;
+    }
+    catch (error) {
+        // Partial-failure rollback: every hook already registered on the host must
+        // be disposed so a failed setup leaves no half-wired supervisor behind.
+        // Disposal failures are swallowed — the registration failure is the cause.
+        for (const registration of acquired) {
+            try {
+                await registration.dispose();
+            }
+            catch {
+                // Disposal failure must not mask the original registration error.
+            }
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=hooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/adapters/opencode/hooks.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAsBpF,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,OAA0B,EAC1B,QAA6B,EAC7B,OAA4B;IAE5B,MAAM,QAAQ,GAAmB,EAAE,CAAA;IACnC,IAAI,CAAC;QACH,QAAQ,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAC9E,QAAQ,CAAC,IAAI,CACX,MAAM,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC,CAC9F,CAAA;QACD,QAAQ,CAAC,IAAI,CACX,MAAM,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,EAAE,CAC5C,QAAQ,CAAC,cAAc,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CACjD,CACF,CAAA;QACD,QAAQ,CAAC,IAAI,CACX,MAAM,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAClD,QAAQ,CAAC,cAAc,CAAC,MAAM,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAC/D,CACF,CAAA;QACD,QAAQ,CAAC,IAAI,CACX,MAAM,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,KAAK,EAAE,EAAE,CAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAC9D,CACF,CAAA;QACD,QAAQ,CAAC,IAAI,CACX,MAAM,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAClE,CACF,CAAA;QACD,OAAO,QAAQ,CAAA;IACjB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,2EAA2E;QAC3E,wEAAwE;QACxE,2EAA2E;QAC3E,KAAK,MAAM,YAAY,IAAI,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC;gBACH,MAAM,YAAY,CAAC,OAAO,EAAE,CAAA;YAC9B,CAAC;YAAC,MAAM,CAAC;gBACP,kEAAkE;YACpE,CAAC;QACH,CAAC;QACD,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC","sourcesContent":["/**\n * Session hook registration (ADP-012/ADP-013/ADP-027). Registers the hooks the\n * supervisor needs on the host session domain and returns their registrations\n * for cleanup. Hooks MUTATE their inputs on the host — the retry handler owns\n * `input.decision`; the adapter passes the raw input through so wiring can\n * veto (`{ retry: false }`) or leave OpenCode's native retry untouched.\n *\n * Fail-open behavior (ADP-031) is applied by the wiring around these handlers;\n * the adapter itself never swallows errors, so wiring sees every failure.\n */\nimport type { Registration } from \"@opencode/plugin/promise/registration\"\nimport type { SessionDomain, SessionRetry } from \"@opencode/plugin/promise/session\"\n\n/** The session surface the hooks actually use (structural — fixture-friendly). */\nexport type SessionHookSource = Pick<SessionDomain, \"hook\">\nimport { contextModelRequest, hookModelRequest, mapHttpResponse } from \"./report.js\"\nimport type { HttpResponseReport, IdleReport, ModelRequestReport, PromptReport } from \"./types.js\"\n\nexport interface SessionHookHandlers {\n  /** Raw retry hook input; wiring decides and mutates `input.decision`. */\n  readonly onRetry: (input: SessionRetry) => Promise<void> | void\n  readonly onModelRequest: (report: ModelRequestReport) => Promise<void> | void\n  readonly onHttpResponse: (report: HttpResponseReport) => Promise<void> | void\n  readonly onIdle: (report: IdleReport) => Promise<void> | void\n  /** Awaited before the turn's model resolution — the admission boundary. */\n  readonly onPrompt: (report: PromptReport) => Promise<void> | void\n}\n\n/** Optional hook behavior supplied by the wiring. */\nexport interface SessionHookOptions {\n  /**\n   * Allowlist predicate over lowercase response header names selecting the\n   * quota telemetry to capture (no other header ever leaves the response).\n   */\n  readonly capture?: (lowercaseName: string) => boolean\n}\n\n/** Register supervisor hooks; resolves to all registrations (dispose in order). */\nexport async function registerSessionHooks(\n  session: SessionHookSource,\n  handlers: SessionHookHandlers,\n  options?: SessionHookOptions,\n): Promise<Registration[]> {\n  const acquired: Registration[] = []\n  try {\n    acquired.push(await session.hook(\"retry\", (input) => handlers.onRetry(input)))\n    acquired.push(\n      await session.hook(\"context\", (input) => handlers.onModelRequest(contextModelRequest(input))),\n    )\n    acquired.push(\n      await session.hook(\"model.request\", (input) =>\n        handlers.onModelRequest(hookModelRequest(input)),\n      ),\n    )\n    acquired.push(\n      await session.hook(\"http.response\", async (input) =>\n        handlers.onHttpResponse(await mapHttpResponse(input, options)),\n      ),\n    )\n    acquired.push(\n      await session.hook(\"experimental.idle\", (input) =>\n        handlers.onIdle({ kind: \"idle\", sessionID: input.sessionID }),\n      ),\n    )\n    acquired.push(\n      await session.hook(\"prompt\", (input) =>\n        handlers.onPrompt({ kind: \"prompt\", sessionID: input.sessionID }),\n      ),\n    )\n    return acquired\n  } catch (error) {\n    // Partial-failure rollback: every hook already registered on the host must\n    // be disposed so a failed setup leaves no half-wired supervisor behind.\n    // Disposal failures are swallowed — the registration failure is the cause.\n    for (const registration of acquired) {\n      try {\n        await registration.dispose()\n      } catch {\n        // Disposal failure must not mask the original registration error.\n      }\n    }\n    throw error\n  }\n}\n"]}

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

@@ -0,0 +1,16 @@
+export { BODY_EXCERPT_LENGTH, mapHttpResponse, mapSessionEvent, modelRefOf } from "./report.js";
+export type { SessionEvent } from "./report.js";
+export type { AdapterStructuredError, EventReport, ExecutionReport, HttpResponseReport, IdleReport, ModelRequestReport, } from "./types.js";
+export { candidateFor, listCandidates, mapModelInfo } from "./inventory.js";
+export type { ModelSource } from "./inventory.js";
+export { sessionOps } from "./session-ops.js";
+export type { SessionOpsHooks, SessionOpsSource } from "./session-ops.js";
+export { storageSeam } from "./storage.js";
+export type { JsonSeam, StorageSource } from "./storage.js";
+export { SESSION_EVENT_TYPES, subscribeSessions } from "./events.js";
+export type { EventSource, SessionSubscription } from "./events.js";
+export { registerSessionHooks } from "./hooks.js";
+export type { SessionHookHandlers, SessionHookSource } from "./hooks.js";
+export { ESCALATION_TOOL_NAME, escalationTool } from "./escalation-tool.js";
+export { tierTool } from "./tier-tool.js";
+export type { EscalationRecorder } from "./escalation-tool.js";

package/dist/adapters/opencode/index.js

@@ -0,0 +1,9 @@
+export { BODY_EXCERPT_LENGTH, mapHttpResponse, mapSessionEvent, modelRefOf } from "./report.js";
+export { candidateFor, listCandidates, mapModelInfo } from "./inventory.js";
+export { sessionOps } from "./session-ops.js";
+export { storageSeam } from "./storage.js";
+export { SESSION_EVENT_TYPES, subscribeSessions } from "./events.js";
+export { registerSessionHooks } from "./hooks.js";
+export { ESCALATION_TOOL_NAME, escalationTool } from "./escalation-tool.js";
+export { tierTool } from "./tier-tool.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/opencode/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAU/F,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE3E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE1C,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA","sourcesContent":["export { BODY_EXCERPT_LENGTH, mapHttpResponse, mapSessionEvent, modelRefOf } from \"./report.js\"\nexport type { SessionEvent } from \"./report.js\"\nexport type {\n  AdapterStructuredError,\n  EventReport,\n  ExecutionReport,\n  HttpResponseReport,\n  IdleReport,\n  ModelRequestReport,\n} from \"./types.js\"\nexport { candidateFor, listCandidates, mapModelInfo } from \"./inventory.js\"\nexport type { ModelSource } from \"./inventory.js\"\nexport { sessionOps } from \"./session-ops.js\"\nexport type { SessionOpsHooks, SessionOpsSource } from \"./session-ops.js\"\nexport { storageSeam } from \"./storage.js\"\nexport type { JsonSeam, StorageSource } from \"./storage.js\"\nexport { SESSION_EVENT_TYPES, subscribeSessions } from \"./events.js\"\nexport type { EventSource, SessionSubscription } from \"./events.js\"\nexport { registerSessionHooks } from \"./hooks.js\"\nexport type { SessionHookHandlers, SessionHookSource } from \"./hooks.js\"\nexport { ESCALATION_TOOL_NAME, escalationTool } from \"./escalation-tool.js\"\nexport { tierTool } from \"./tier-tool.js\"\nexport type { EscalationRecorder } from \"./escalation-tool.js\"\n"]}

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

@@ -0,0 +1,30 @@
+/**
+ * Model inventory mapping (ADP-005/ADP-006/ADP-017). Host `Model.Info` records
+ * become supervisor `CandidateModel` views for the compatibility gate.
+ *
+ * `providerEnabled: true` is honest for `editor.list()` output: the verified
+ * host contract is that `list()` returns candidates "from available providers"
+ * (including models disabled by earlier transforms — the per-model `enabled`
+ * flag distinguishes those). Pins are verified against the same editor via
+ * `candidateFor`, which additionally checks variant existence (a variant the
+ * model does not offer must not be switchable-to).
+ */
+import type { Model } from "@opencode/plugin";
+import type { ModelDomain } from "@opencode/plugin/promise/model";
+import type { CandidateModel } from "../../core/compatibility/types.js";
+import type { ModelRef } from "../../core/work-unit/types.js";
+/** The model surface the inventory actually uses (structural — fixture-friendly). */
+export type ModelSource = Pick<ModelDomain, "transform">;
+/** Map one host model record into a candidate view. */
+export declare function mapModelInfo(info: Model.Info): CandidateModel;
+/** All inventory candidates, in host order. Each offered variant is an
+ * additional explicit candidate so tier resources pinned to a variant
+ * (`provider/model@variant`) are matchable by the scheduler. */
+export declare function listCandidates(model: ModelSource): Promise<CandidateModel[]>;
+/**
+ * Resolve one exact resource reference (a pin) to its candidate, or `undefined`
+ * when the model is not in the host inventory or the requested variant does
+ * not exist. A resolved variant is reported as available so the compatibility
+ * gate does not reject the very resource the user pinned.
+ */
+export declare function candidateFor(model: ModelSource, ref: ModelRef): Promise<CandidateModel | undefined>;

package/dist/adapters/opencode/inventory.js

@@ -0,0 +1,53 @@
+/** Map one host model record into a candidate view. */
+export function mapModelInfo(info) {
+    return {
+        providerID: info.providerID,
+        modelID: info.id,
+        enabled: info.enabled,
+        providerEnabled: true,
+        capabilities: {
+            tools: info.capabilities.tools,
+            input: [...info.capabilities.input],
+            output: [...info.capabilities.output],
+        },
+        limit: { context: info.limit.context },
+    };
+}
+/** All inventory candidates, in host order. Each offered variant is an
+ * additional explicit candidate so tier resources pinned to a variant
+ * (`provider/model@variant`) are matchable by the scheduler. */
+export async function listCandidates(model) {
+    const out = [];
+    await model.transform((editor) => {
+        for (const info of editor.list()) {
+            out.push(mapModelInfo(info));
+            for (const variant of info.variants) {
+                out.push({ ...mapModelInfo(info), variant: variant.id, variantAvailable: true });
+            }
+        }
+    });
+    return out;
+}
+/**
+ * Resolve one exact resource reference (a pin) to its candidate, or `undefined`
+ * when the model is not in the host inventory or the requested variant does
+ * not exist. A resolved variant is reported as available so the compatibility
+ * gate does not reject the very resource the user pinned.
+ */
+export async function candidateFor(model, ref) {
+    let found;
+    await model.transform((editor) => {
+        const info = editor.get(ref.providerID, ref.id);
+        if (info === undefined) {
+            return;
+        }
+        if (ref.variant !== undefined && !info.variants.some((variant) => variant.id === ref.variant)) {
+            return;
+        }
+        const base = mapModelInfo(info);
+        found =
+            ref.variant !== undefined ? { ...base, variant: ref.variant, variantAvailable: true } : base;
+    });
+    return found;
+}
+//# sourceMappingURL=inventory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.js","sourceRoot":"","sources":["../../../src/adapters/opencode/inventory.ts"],"names":[],"mappings":"AAmBA,uDAAuD;AACvD,MAAM,UAAU,YAAY,CAAC,IAAgB;IAC3C,OAAO;QACL,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,OAAO,EAAE,IAAI,CAAC,EAAE;QAChB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,eAAe,EAAE,IAAI;QACrB,YAAY,EAAE;YACZ,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK;YAC9B,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;YACnC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;SACtC;QACD,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;KACvC,CAAA;AACH,CAAC;AAED;;gEAEgE;AAChE,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAAkB;IACrD,MAAM,GAAG,GAAqB,EAAE,CAAA;IAChC,MAAM,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;QAC/B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YACjC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAA;YAC5B,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACpC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAA;YAClF,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,KAAkB,EAClB,GAAa;IAEb,IAAI,KAAiC,CAAA;IACrC,MAAM,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;QAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA;QAC/C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAM;QACR,CAAC;QACD,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9F,OAAM;QACR,CAAC;QACD,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;QAC/B,KAAK;YACH,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IAChG,CAAC,CAAC,CAAA;IACF,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["/**\n * Model inventory mapping (ADP-005/ADP-006/ADP-017). Host `Model.Info` records\n * become supervisor `CandidateModel` views for the compatibility gate.\n *\n * `providerEnabled: true` is honest for `editor.list()` output: the verified\n * host contract is that `list()` returns candidates \"from available providers\"\n * (including models disabled by earlier transforms — the per-model `enabled`\n * flag distinguishes those). Pins are verified against the same editor via\n * `candidateFor`, which additionally checks variant existence (a variant the\n * model does not offer must not be switchable-to).\n */\nimport type { Model } from \"@opencode/plugin\"\nimport type { ModelDomain } from \"@opencode/plugin/promise/model\"\nimport type { CandidateModel } from \"../../core/compatibility/types.js\"\nimport type { ModelRef } from \"../../core/work-unit/types.js\"\n\n/** The model surface the inventory actually uses (structural — fixture-friendly). */\nexport type ModelSource = Pick<ModelDomain, \"transform\">\n\n/** Map one host model record into a candidate view. */\nexport function mapModelInfo(info: Model.Info): CandidateModel {\n  return {\n    providerID: info.providerID,\n    modelID: info.id,\n    enabled: info.enabled,\n    providerEnabled: true,\n    capabilities: {\n      tools: info.capabilities.tools,\n      input: [...info.capabilities.input],\n      output: [...info.capabilities.output],\n    },\n    limit: { context: info.limit.context },\n  }\n}\n\n/** All inventory candidates, in host order. Each offered variant is an\n * additional explicit candidate so tier resources pinned to a variant\n * (`provider/model@variant`) are matchable by the scheduler. */\nexport async function listCandidates(model: ModelSource): Promise<CandidateModel[]> {\n  const out: CandidateModel[] = []\n  await model.transform((editor) => {\n    for (const info of editor.list()) {\n      out.push(mapModelInfo(info))\n      for (const variant of info.variants) {\n        out.push({ ...mapModelInfo(info), variant: variant.id, variantAvailable: true })\n      }\n    }\n  })\n  return out\n}\n\n/**\n * Resolve one exact resource reference (a pin) to its candidate, or `undefined`\n * when the model is not in the host inventory or the requested variant does\n * not exist. A resolved variant is reported as available so the compatibility\n * gate does not reject the very resource the user pinned.\n */\nexport async function candidateFor(\n  model: ModelSource,\n  ref: ModelRef,\n): Promise<CandidateModel | undefined> {\n  let found: CandidateModel | undefined\n  await model.transform((editor) => {\n    const info = editor.get(ref.providerID, ref.id)\n    if (info === undefined) {\n      return\n    }\n    if (ref.variant !== undefined && !info.variants.some((variant) => variant.id === ref.variant)) {\n      return\n    }\n    const base = mapModelInfo(info)\n    found =\n      ref.variant !== undefined ? { ...base, variant: ref.variant, variantAvailable: true } : base\n  })\n  return found\n}\n"]}

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

@@ -0,0 +1,91 @@
+/**
+ * Event/hook → report mappers. Pure observation, no policy: the adapter
+ * normalizes verified host payloads into `EventReport` shapes the supervisor
+ * consumes. Timestamps come from the host event envelope (`created`, epoch
+ * milliseconds) — work units are clock-free.
+ */
+import type { Model } from "@opencode/plugin";
+import type { SessionHttpResponse } from "@opencode/plugin/promise/session";
+import type { ModelRef } from "../../core/work-unit/types.js";
+import type { AdapterStructuredError, ExecutionReport, HttpResponseReport, ModelRequestReport } from "./types.js";
+/**
+ * Response bodies are bounded here (and bounded again by the classifier) so a
+ * hostile provider payload can never inflate memory or receipts. The excerpt
+ * is read with a streaming reader and the stream is cancelled once the cap is
+ * reached — a multi-megabyte body never materializes in memory.
+ */
+export declare const BODY_EXCERPT_LENGTH = 512;
+/** Capture bounds for wiring-selected telemetry headers. */
+export declare const MAX_CAPTURED_HEADERS = 16;
+export declare const MAX_CAPTURED_VALUE_LENGTH = 64;
+/** Convert a host `Model.Ref` into the supervisor's `ModelRef` shape. */
+export declare function modelRefOf(ref: Model.Ref): ModelRef;
+/** Structural session event the mapper accepts (host payloads are assignable). */
+export type SessionEvent = {
+    type: "session.execution.started";
+    created: number;
+    data: {
+        sessionID: string;
+    };
+} | {
+    type: "session.execution.succeeded";
+    created: number;
+    data: {
+        sessionID: string;
+    };
+} | {
+    type: "session.execution.failed";
+    created: number;
+    data: {
+        sessionID: string;
+        error: AdapterStructuredError;
+    };
+} | {
+    type: "session.execution.interrupted";
+    created: number;
+    data: {
+        sessionID: string;
+        reason: string;
+    };
+} | {
+    type: "session.model.selected";
+    created: number;
+    data: {
+        sessionID: string;
+        model: Model.Ref;
+    };
+};
+/**
+ * Map one subscribed session event into its report. Returns `null` for event
+ * types the supervisor does not consume (defensive — the subscription filters
+ * types, so this branch only fires if the host ever widens the stream).
+ */
+export declare function mapSessionEvent(event: SessionEvent): ExecutionReport | null;
+/** Model request report from the `context` hook — the agent loop is `primary`. */
+export declare function contextModelRequest(input: {
+    sessionID: string;
+    model: Model.Ref;
+    agent?: string;
+}): ModelRequestReport;
+/** Model request report from the `model.request` hook (carries the request kind). */
+export declare function hookModelRequest(input: {
+    sessionID: string;
+    model: Model.Ref;
+    kind: "primary" | "compaction" | "title" | "generate";
+    agent?: string;
+}): ModelRequestReport;
+/**
+ * Map an `http.response` hook input. The response body is cloned EXACTLY ONCE
+ * and only the bounded excerpt of the clone is read — the original body stays
+ * untouched for the host (verified one-shot body limitation). If the body
+ * cannot be cloned (already consumed, streaming error), the report degrades
+ * to status/header evidence.
+ *
+ * `capture` is an optional allowlist predicate over lowercase header names
+ * (quota telemetry only — never `authorization`, cookies, or any other
+ * credential-bearing header). Captured entries are bounded in count and value
+ * length; capture never throws.
+ */
+export declare function mapHttpResponse(input: SessionHttpResponse, options?: {
+    capture?: (lowercaseName: string) => boolean;
+}): Promise<HttpResponseReport>;

package/dist/adapters/opencode/report.js

@@ -0,0 +1,145 @@
+/**
+ * Response bodies are bounded here (and bounded again by the classifier) so a
+ * hostile provider payload can never inflate memory or receipts. The excerpt
+ * is read with a streaming reader and the stream is cancelled once the cap is
+ * reached — a multi-megabyte body never materializes in memory.
+ */
+export const BODY_EXCERPT_LENGTH = 512;
+/**
+ * Reads at most `BODY_EXCERPT_LENGTH` characters from the response body via a
+ * streaming reader, cancelling the underlying stream when the cap is reached.
+ * Returns `undefined` for missing or empty bodies.
+ */
+async function readBodyExcerpt(response) {
+    const reader = response.body?.getReader();
+    if (reader === undefined)
+        return undefined;
+    const decoder = new TextDecoder();
+    let text = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        text += decoder.decode(value, { stream: true });
+        if (text.length >= BODY_EXCERPT_LENGTH) {
+            // Fire-and-forget: cancellation failure must not fail the observation.
+            void reader.cancel().catch(() => undefined);
+            break;
+        }
+    }
+    text = text.slice(0, BODY_EXCERPT_LENGTH);
+    return text === "" ? undefined : text;
+}
+/** Capture bounds for wiring-selected telemetry headers. */
+export const MAX_CAPTURED_HEADERS = 16;
+export const MAX_CAPTURED_VALUE_LENGTH = 64;
+/** Convert a host `Model.Ref` into the supervisor's `ModelRef` shape. */
+export function modelRefOf(ref) {
+    return {
+        providerID: ref.providerID,
+        id: ref.id,
+        ...(ref.variant !== undefined ? { variant: ref.variant } : {}),
+    };
+}
+/**
+ * Map one subscribed session event into its report. Returns `null` for event
+ * types the supervisor does not consume (defensive — the subscription filters
+ * types, so this branch only fires if the host ever widens the stream).
+ */
+export function mapSessionEvent(event) {
+    switch (event.type) {
+        case "session.execution.started":
+            return { kind: "execution-started", sessionID: event.data.sessionID, at: event.created };
+        case "session.execution.succeeded":
+            return { kind: "execution-succeeded", sessionID: event.data.sessionID, at: event.created };
+        case "session.execution.failed":
+            return {
+                kind: "execution-failed",
+                sessionID: event.data.sessionID,
+                at: event.created,
+                error: event.data.error,
+            };
+        case "session.execution.interrupted":
+            return {
+                kind: "execution-interrupted",
+                sessionID: event.data.sessionID,
+                at: event.created,
+                reason: event.data.reason,
+            };
+        case "session.model.selected":
+            return {
+                kind: "model-selected",
+                sessionID: event.data.sessionID,
+                at: event.created,
+                model: modelRefOf(event.data.model),
+            };
+        default:
+            return null;
+    }
+}
+/** Model request report from the `context` hook — the agent loop is `primary`. */
+export function contextModelRequest(input) {
+    return {
+        kind: "model-request",
+        sessionID: input.sessionID,
+        model: modelRefOf(input.model),
+        requestKind: "primary",
+        ...(input.agent !== undefined ? { agent: input.agent } : {}),
+    };
+}
+/** Model request report from the `model.request` hook (carries the request kind). */
+export function hookModelRequest(input) {
+    return {
+        kind: "model-request",
+        sessionID: input.sessionID,
+        model: modelRefOf(input.model),
+        requestKind: input.kind,
+        ...(input.agent !== undefined ? { agent: input.agent } : {}),
+    };
+}
+/**
+ * Map an `http.response` hook input. The response body is cloned EXACTLY ONCE
+ * and only the bounded excerpt of the clone is read — the original body stays
+ * untouched for the host (verified one-shot body limitation). If the body
+ * cannot be cloned (already consumed, streaming error), the report degrades
+ * to status/header evidence.
+ *
+ * `capture` is an optional allowlist predicate over lowercase header names
+ * (quota telemetry only — never `authorization`, cookies, or any other
+ * credential-bearing header). Captured entries are bounded in count and value
+ * length; capture never throws.
+ */
+export async function mapHttpResponse(input, options) {
+    const retryAfterHeader = input.response.headers.get("retry-after");
+    let bodyExcerpt;
+    try {
+        bodyExcerpt = await readBodyExcerpt(input.response.clone());
+    }
+    catch {
+        // Body unreadable — status + headers evidence remains available.
+    }
+    let capturedHeaders;
+    if (options?.capture !== undefined) {
+        const captured = {};
+        for (const [name, value] of input.response.headers) {
+            if (Object.keys(captured).length >= MAX_CAPTURED_HEADERS) {
+                break;
+            }
+            if (options.capture(name.toLowerCase())) {
+                captured[name] = value.slice(0, MAX_CAPTURED_VALUE_LENGTH);
+            }
+        }
+        if (Object.keys(captured).length > 0) {
+            capturedHeaders = captured;
+        }
+    }
+    return {
+        kind: "http-response",
+        sessionID: input.sessionID,
+        status: input.response.status,
+        ...(retryAfterHeader !== null ? { retryAfterHeader } : {}),
+        ...(bodyExcerpt !== undefined ? { bodyExcerpt } : {}),
+        ...(capturedHeaders !== undefined ? { capturedHeaders } : {}),
+    };
+}
+//# sourceMappingURL=report.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../src/adapters/opencode/report.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Event/hook → report mappers. Pure observation, no policy: the adapter\n * normalizes verified host payloads into `EventReport` shapes the supervisor\n * consumes. Timestamps come from the host event envelope (`created`, epoch\n * milliseconds) — work units are clock-free.\n */\nimport type { Model } from \"@opencode/plugin\"\nimport type { SessionHttpResponse } from \"@opencode/plugin/promise/session\"\nimport type { ModelRef } from \"../../core/work-unit/types.js\"\nimport type {\n  AdapterStructuredError,\n  ExecutionReport,\n  HttpResponseReport,\n  ModelRequestReport,\n} from \"./types.js\"\n\n/**\n * Response bodies are bounded here (and bounded again by the classifier) so a\n * hostile provider payload can never inflate memory or receipts. The excerpt\n * is read with a streaming reader and the stream is cancelled once the cap is\n * reached — a multi-megabyte body never materializes in memory.\n */\nexport const BODY_EXCERPT_LENGTH = 512\n\n/**\n * Reads at most `BODY_EXCERPT_LENGTH` characters from the response body via a\n * streaming reader, cancelling the underlying stream when the cap is reached.\n * Returns `undefined` for missing or empty bodies.\n */\nasync function readBodyExcerpt(response: Response): Promise<string | undefined> {\n  const reader = response.body?.getReader()\n  if (reader === undefined) return undefined\n  const decoder = new TextDecoder()\n  let text = \"\"\n  for (;;) {\n    const { done, value } = await reader.read()\n    if (done) break\n    text += decoder.decode(value, { stream: true })\n    if (text.length >= BODY_EXCERPT_LENGTH) {\n      // Fire-and-forget: cancellation failure must not fail the observation.\n      void reader.cancel().catch(() => undefined)\n      break\n    }\n  }\n  text = text.slice(0, BODY_EXCERPT_LENGTH)\n  return text === \"\" ? undefined : text\n}\n\n/** Capture bounds for wiring-selected telemetry headers. */\nexport const MAX_CAPTURED_HEADERS = 16\nexport const MAX_CAPTURED_VALUE_LENGTH = 64\n\n/** Convert a host `Model.Ref` into the supervisor's `ModelRef` shape. */\nexport function modelRefOf(ref: Model.Ref): ModelRef {\n  return {\n    providerID: ref.providerID,\n    id: ref.id,\n    ...(ref.variant !== undefined ? { variant: ref.variant } : {}),\n  }\n}\n\n/** Structural session event the mapper accepts (host payloads are assignable). */\nexport type SessionEvent =\n  | { type: \"session.execution.started\"; created: number; data: { sessionID: string } }\n  | { type: \"session.execution.succeeded\"; created: number; data: { sessionID: string } }\n  | {\n      type: \"session.execution.failed\"\n      created: number\n      data: { sessionID: string; error: AdapterStructuredError }\n    }\n  | {\n      type: \"session.execution.interrupted\"\n      created: number\n      data: { sessionID: string; reason: string }\n    }\n  | {\n      type: \"session.model.selected\"\n      created: number\n      data: { sessionID: string; model: Model.Ref }\n    }\n\n/**\n * Map one subscribed session event into its report. Returns `null` for event\n * types the supervisor does not consume (defensive — the subscription filters\n * types, so this branch only fires if the host ever widens the stream).\n */\nexport function mapSessionEvent(event: SessionEvent): ExecutionReport | null {\n  switch (event.type) {\n    case \"session.execution.started\":\n      return { kind: \"execution-started\", sessionID: event.data.sessionID, at: event.created }\n    case \"session.execution.succeeded\":\n      return { kind: \"execution-succeeded\", sessionID: event.data.sessionID, at: event.created }\n    case \"session.execution.failed\":\n      return {\n        kind: \"execution-failed\",\n        sessionID: event.data.sessionID,\n        at: event.created,\n        error: event.data.error,\n      }\n    case \"session.execution.interrupted\":\n      return {\n        kind: \"execution-interrupted\",\n        sessionID: event.data.sessionID,\n        at: event.created,\n        reason: event.data.reason,\n      }\n    case \"session.model.selected\":\n      return {\n        kind: \"model-selected\",\n        sessionID: event.data.sessionID,\n        at: event.created,\n        model: modelRefOf(event.data.model),\n      }\n    default:\n      return null\n  }\n}\n\n/** Model request report from the `context` hook — the agent loop is `primary`. */\nexport function contextModelRequest(input: {\n  sessionID: string\n  model: Model.Ref\n  agent?: string\n}): ModelRequestReport {\n  return {\n    kind: \"model-request\",\n    sessionID: input.sessionID,\n    model: modelRefOf(input.model),\n    requestKind: \"primary\",\n    ...(input.agent !== undefined ? { agent: input.agent } : {}),\n  }\n}\n\n/** Model request report from the `model.request` hook (carries the request kind). */\nexport function hookModelRequest(input: {\n  sessionID: string\n  model: Model.Ref\n  kind: \"primary\" | \"compaction\" | \"title\" | \"generate\"\n  agent?: string\n}): ModelRequestReport {\n  return {\n    kind: \"model-request\",\n    sessionID: input.sessionID,\n    model: modelRefOf(input.model),\n    requestKind: input.kind,\n    ...(input.agent !== undefined ? { agent: input.agent } : {}),\n  }\n}\n\n/**\n * Map an `http.response` hook input. The response body is cloned EXACTLY ONCE\n * and only the bounded excerpt of the clone is read — the original body stays\n * untouched for the host (verified one-shot body limitation). If the body\n * cannot be cloned (already consumed, streaming error), the report degrades\n * to status/header evidence.\n *\n * `capture` is an optional allowlist predicate over lowercase header names\n * (quota telemetry only — never `authorization`, cookies, or any other\n * credential-bearing header). Captured entries are bounded in count and value\n * length; capture never throws.\n */\nexport async function mapHttpResponse(\n  input: SessionHttpResponse,\n  options?: { capture?: (lowercaseName: string) => boolean },\n): Promise<HttpResponseReport> {\n  const retryAfterHeader = input.response.headers.get(\"retry-after\")\n  let bodyExcerpt: string | undefined\n  try {\n    bodyExcerpt = await readBodyExcerpt(input.response.clone())\n  } catch {\n    // Body unreadable — status + headers evidence remains available.\n  }\n  let capturedHeaders: Record<string, string> | undefined\n  if (options?.capture !== undefined) {\n    const captured: Record<string, string> = {}\n    for (const [name, value] of input.response.headers) {\n      if (Object.keys(captured).length >= MAX_CAPTURED_HEADERS) {\n        break\n      }\n      if (options.capture(name.toLowerCase())) {\n        captured[name] = value.slice(0, MAX_CAPTURED_VALUE_LENGTH)\n      }\n    }\n    if (Object.keys(captured).length > 0) {\n      capturedHeaders = captured\n    }\n  }\n  return {\n    kind: \"http-response\",\n    sessionID: input.sessionID,\n    status: input.response.status,\n    ...(retryAfterHeader !== null ? { retryAfterHeader } : {}),\n    ...(bodyExcerpt !== undefined ? { bodyExcerpt } : {}),\n    ...(capturedHeaders !== undefined ? { capturedHeaders } : {}),\n  }\n}\n"]}

package/dist/adapters/opencode/session-ops.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Session operations seam (ADP-013/ADP-014/ADP-023/ADP-028). Implements the
+ * supervisor's `ContinuationOps` on the host session domain: settle on the
+ * host's experimental wait, switch model, deliver a prompt. Never replays a
+ * failed request — prompting after a failure starts a NEW execution that
+ * continues from session state (prompt strategy chosen by the supervisor).
+ *
+ * Switch self-tagging (verified limitation: `session.model.selected` fires for
+ * manual AND plugin switches): `beforeSwitch` is invoked BEFORE the host
+ * switch so the supervisor can record its own pending attribution note; the
+ * resulting selection event is then attributed to Adaptive, never to the user.
+ */
+import type { SessionDomain } from "@opencode/plugin/promise/session";
+/** The session surface the ops actually use (structural — fixture-friendly). */
+export type SessionOpsSource = Pick<SessionDomain, "wait" | "switchModel" | "prompt">;
+import type { ContinuationOps } from "../../execution/continuation/types.js";
+import type { ModelRef } from "../../core/work-unit/types.js";
+export interface SessionOpsHooks {
+    /**
+     * Called before every host `switchModel` this adapter performs, so wiring
+     * can tag the switch as Adaptive's own (`noteOwnSwitch`).
+     */
+    readonly beforeSwitch?: (sessionID: string, model: ModelRef) => void;
+    /**
+     * Called before the adapter prompts a continuation, so wiring can mark the
+     * upcoming prompt-hook admission as owned (the continuation belongs to the
+     * active unit and must not re-admit).
+     */
+    readonly beforePrompt?: (sessionID: string) => void;
+    /**
+     * Called when the prompted call settles (success or failure), whether or
+     * not the prompt hook fired — the counterpart that bounds the ownership
+     * mark's lifetime. `delivered` is false exactly when the host prompt
+     * rejected, so the hook can never fire for it.
+     */
+    readonly afterPrompt?: (sessionID: string, delivered: boolean) => void;
+}
+/** Build the supervisor's continuation ops on top of the host session domain. */
+export declare function sessionOps(session: SessionOpsSource, hooks?: SessionOpsHooks): ContinuationOps;