@coool/opencode-adaptive 0.0.0-stage → 1.0.1

package/dist/rpc/handlers.js

@@ -0,0 +1,125 @@
+/**
+ * RPC handler binding (ADP-034/036): adapts the supervisor's state API to the
+ * typed RPC methods. Handlers never throw for expected outcomes — an invalid
+ * patch is a per-field `PatchResult`, and an internal failure degrades to
+ * `{ ok: false }` (fail-open, ADP-031). Read methods declare internal failures
+ * through the call context's error factory: a plain throw becomes a server
+ * defect whose generic `rpc.internal` message hides the cause (verified on the
+ * sibling @coool plugins).
+ */
+import { OPERATING_MODES } from "../core/scheduler/types.js";
+import { TIERS } from "../core/tier-policy/types.js";
+import { LOG_ERROR_LENGTH, logFailOpen } from "../supervisor/log.js";
+import { isValidSessionID } from "../state/session-modes/index.js";
+/** Per-field errors for a session-mode patch, mirroring the settings contract. */
+function sessionModeSetError(input) {
+    if (!isValidSessionID(input.sessionID)) {
+        return "sessionID must be a non-empty string of at most 128 characters";
+    }
+    if (input.mode !== null && !OPERATING_MODES.includes(input.mode)) {
+        return `mode must be one of ${OPERATING_MODES.join(", ")} or null`;
+    }
+    return undefined;
+}
+/** Same contract for a tier-request patch (ADP-055): vocabulary-gated tier. */
+function tierRequestSetError(input) {
+    if (!isValidSessionID(input.sessionID)) {
+        return "sessionID must be a non-empty string of at most 128 characters";
+    }
+    if (input.tier !== null && !TIERS.includes(input.tier)) {
+        return `tier must be one of ${TIERS.join(", ")} or null`;
+    }
+    return undefined;
+}
+export function adaptiveRpcHandlers(source, emit) {
+    return {
+        "settings.get": (_input, context) => source
+            .settings()
+            .catch((error) => context.error("internal", String(error).slice(0, LOG_ERROR_LENGTH))),
+        "settings.set": async (patch) => {
+            try {
+                const result = await source.updateSettings(patch);
+                if (result.ok && emit !== undefined) {
+                    try {
+                        await emit("settings-changed", { version: result.settings.version });
+                    }
+                    catch (error) {
+                        logFailOpen("rpc-emit", error);
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                logFailOpen("rpc-set", error);
+                return { ok: false, errors: ["internal error"] };
+            }
+        },
+        "status.get": (_input, context) => source
+            .status()
+            .catch((error) => context.error("internal", String(error).slice(0, LOG_ERROR_LENGTH))),
+        "receipts.list": (_input, context) => source
+            .receipts()
+            .catch((error) => context.error("internal", String(error).slice(0, LOG_ERROR_LENGTH))),
+        "session-mode.get": (input, context) => source
+            .getSessionMode(input.sessionID)
+            .then((mode) => ({ mode }))
+            .catch((error) => context.error("internal", String(error).slice(0, LOG_ERROR_LENGTH))),
+        "session-mode.set": async (input) => {
+            const invalid = sessionModeSetError(input);
+            if (invalid !== undefined)
+                return { ok: false, errors: [invalid] };
+            try {
+                await source.setSessionMode(input.sessionID, input.mode);
+            }
+            catch (error) {
+                logFailOpen("rpc-set", error);
+                return { ok: false, errors: ["internal error"] };
+            }
+            if (emit !== undefined) {
+                try {
+                    await emit("session-mode-changed", { sessionID: input.sessionID });
+                }
+                catch (error) {
+                    logFailOpen("rpc-emit", error);
+                }
+            }
+            return { ok: true };
+        },
+        "tier-request.get": (input, context) => source
+            .getTierRequest(input.sessionID)
+            .then((tier) => ({ tier }))
+            .catch((error) => context.error("internal", String(error).slice(0, LOG_ERROR_LENGTH))),
+        "tier-request.set": async (input) => {
+            const invalid = tierRequestSetError(input);
+            if (invalid !== undefined)
+                return { ok: false, errors: [invalid] };
+            if (input.tier !== null) {
+                // A non-null tier is a sticky record: noteTierRequest re-validates the
+                // vocabulary (post-gate this cannot fail, so treat `false` as internal).
+                if (!source.noteTierRequest(input.sessionID, input.tier)) {
+                    logFailOpen("rpc-set", new Error("tier request rejected"));
+                    return { ok: false, errors: ["internal error"] };
+                }
+            }
+            else {
+                try {
+                    await source.setTierRequest(input.sessionID, null);
+                }
+                catch (error) {
+                    logFailOpen("rpc-set", error);
+                    return { ok: false, errors: ["internal error"] };
+                }
+            }
+            if (emit !== undefined) {
+                try {
+                    await emit("tier-request-changed", { sessionID: input.sessionID });
+                }
+                catch (error) {
+                    logFailOpen("rpc-emit", error);
+                }
+            }
+            return { ok: true };
+        },
+    };
+}
+//# sourceMappingURL=handlers.js.map

package/dist/rpc/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","sourceRoot":"","sources":["../../src/rpc/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAE5D,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAEpD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAsClE,kFAAkF;AAClF,SAAS,mBAAmB,CAAC,KAG5B;IACC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;QACvC,OAAO,gEAAgE,CAAA;IACzE,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,CAAE,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACxF,OAAO,uBAAuB,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAA;IACpE,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,+EAA+E;AAC/E,SAAS,mBAAmB,CAAC,KAG5B;IACC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;QACvC,OAAO,gEAAgE,CAAA;IACzE,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,CAAE,KAA2B,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9E,OAAO,uBAAuB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAA;IAC1D,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC;AAiBD,MAAM,UAAU,mBAAmB,CACjC,MAAyB,EACzB,IAAsB;IAEtB,OAAO;QACL,cAAc,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAClC,MAAM;aACH,QAAQ,EAAE;aACV,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CACxB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CACpE;QACL,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YAC9B,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;gBACjD,IAAI,MAAM,CAAC,EAAE,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;oBACpC,IAAI,CAAC;wBACH,MAAM,IAAI,CAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;oBACtE,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;oBAChC,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAA;YACf,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;gBAC7B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAA;YAClD,CAAC;QACH,CAAC;QACD,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAChC,MAAM;aACH,MAAM,EAAE;aACR,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CACxB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CACpE;QACL,eAAe,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CACnC,MAAM;aACH,QAAQ,EAAE;aACV,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CACxB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CACpE;QACL,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CACrC,MAAM;aACH,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC;aAC/B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;aAC1B,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CACxB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CACpE;QACL,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YAClC,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAA;YAC1C,IAAI,OAAO,KAAK,SAAS;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAA;YAClE,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;YAC1D,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;gBAC7B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAA;YAClD,CAAC;YACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,sBAAsB,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAA;gBACpE,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;gBAChC,CAAC;YACH,CAAC;YACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;QACrB,CAAC;QACD,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CACrC,MAAM;aACH,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC;aAC/B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;aAC1B,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CACxB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CACpE;QACL,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YAClC,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAA;YAC1C,IAAI,OAAO,KAAK,SAAS;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAA;YAClE,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACxB,uEAAuE;gBACvE,yEAAyE;gBACzE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;oBACzD,WAAW,CAAC,SAAS,EAAE,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC,CAAA;oBAC1D,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAA;gBAClD,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC;oBACH,MAAM,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;gBACpD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;oBAC7B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAA;gBAClD,CAAC;YACH,CAAC;YACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,sBAAsB,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAA;gBACpE,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA;gBAChC,CAAC;YACH,CAAC;YACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;QACrB,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["/**\n * RPC handler binding (ADP-034/036): adapts the supervisor's state API to the\n * typed RPC methods. Handlers never throw for expected outcomes — an invalid\n * patch is a per-field `PatchResult`, and an internal failure degrades to\n * `{ ok: false }` (fail-open, ADP-031). Read methods declare internal failures\n * through the call context's error factory: a plain throw becomes a server\n * defect whose generic `rpc.internal` message hides the cause (verified on the\n * sibling @coool plugins).\n */\nimport { OPERATING_MODES } from \"../core/scheduler/types.js\"\nimport type { OperatingMode } from \"../core/scheduler/types.js\"\nimport { TIERS } from \"../core/tier-policy/types.js\"\nimport type { TierName } from \"../core/tier-policy/types.js\"\nimport { LOG_ERROR_LENGTH, logFailOpen } from \"../supervisor/log.js\"\nimport { isValidSessionID } from \"../state/session-modes/index.js\"\nimport type { PatchResult } from \"../state/settings/types.js\"\nimport type { SettingsPatch, SettingsV1 } from \"../state/settings/index.js\"\nimport type { Rpc } from \"@opencode/schema/rpc\"\nimport type { Receipt } from \"../state/receipts/types.js\"\nimport type { StatusSnapshot } from \"./status.js\"\nimport type { AdaptiveRpc } from \"./definition.js\"\n\nexport interface AdaptiveRpcSource {\n  settings(): Promise<SettingsV1>\n  updateSettings(patch: SettingsPatch): Promise<PatchResult>\n  status(): Promise<StatusSnapshot>\n  receipts(): Promise<Receipt[]>\n  getSessionMode(sessionID: string): Promise<OperatingMode | null>\n  setSessionMode(sessionID: string, mode: OperatingMode | null): Promise<void>\n  getTierRequest(sessionID: string): Promise<TierName | null>\n  noteTierRequest(sessionID: string, tier: string): boolean\n  setTierRequest(sessionID: string, tier: TierName | null): Promise<void>\n}\n\nexport type SettingsChangedEmit = (name: \"settings-changed\", data: { version: number }) => unknown\n\n/**\n * Correlated emit: each call site pairs the event name with its own payload\n * shape — an invalid pairing is a type error, and the registration site can\n * forward the tuple to the host emitter untouched.\n */\nexport type AdaptiveRpcEmit = (\n  ...args:\n    | [\"settings-changed\", { version: number }]\n    | [\"session-mode-changed\", { sessionID: string }]\n    | [\"tier-request-changed\", { sessionID: string }]\n) => unknown\n\n/** A successful tier-request write; mirrors the SessionModeSetResult convention. */\nexport type TierRequestSetResult =\n  { readonly ok: true } | { readonly ok: false; readonly errors: readonly string[] }\n\n/** Per-field errors for a session-mode patch, mirroring the settings contract. */\nfunction sessionModeSetError(input: {\n  sessionID: string\n  mode: OperatingMode | null\n}): string | undefined {\n  if (!isValidSessionID(input.sessionID)) {\n    return \"sessionID must be a non-empty string of at most 128 characters\"\n  }\n  if (input.mode !== null && !(OPERATING_MODES as readonly string[]).includes(input.mode)) {\n    return `mode must be one of ${OPERATING_MODES.join(\", \")} or null`\n  }\n  return undefined\n}\n\n/** Same contract for a tier-request patch (ADP-055): vocabulary-gated tier. */\nfunction tierRequestSetError(input: {\n  sessionID: string\n  tier: string | null\n}): string | undefined {\n  if (!isValidSessionID(input.sessionID)) {\n    return \"sessionID must be a non-empty string of at most 128 characters\"\n  }\n  if (input.tier !== null && !(TIERS as readonly string[]).includes(input.tier)) {\n    return `tier must be one of ${TIERS.join(\", \")} or null`\n  }\n  return undefined\n}\n\ntype Methods = AdaptiveRpc[\"methods\"]\ntype MethodName = Extract<keyof Methods, string>\n\n/** The subset of the host's RpcCallContext the handlers use (no plugin import). */\nexport interface AdaptiveRpcCallContext<Name extends MethodName> {\n  readonly error: Rpc.ErrorFactory<Methods[Name]>\n}\n\ntype HandlerErrorOf<Name extends MethodName> = Rpc.HandlerError<Methods[Name]>\n\ntype HandlerOf<Name extends MethodName> = (\n  input: Rpc.Output<Methods[Name][\"input\"]>,\n  context: AdaptiveRpcCallContext<Name>,\n) => Promise<Rpc.HandlerOutput<Methods[Name][\"output\"]> | HandlerErrorOf<Name>>\n\nexport function adaptiveRpcHandlers(\n  source: AdaptiveRpcSource,\n  emit?: AdaptiveRpcEmit,\n): { [Name in MethodName]: HandlerOf<Name> } {\n  return {\n    \"settings.get\": (_input, context) =>\n      source\n        .settings()\n        .catch((error: unknown) =>\n          context.error(\"internal\", String(error).slice(0, LOG_ERROR_LENGTH)),\n        ),\n    \"settings.set\": async (patch) => {\n      try {\n        const result = await source.updateSettings(patch)\n        if (result.ok && emit !== undefined) {\n          try {\n            await emit(\"settings-changed\", { version: result.settings.version })\n          } catch (error) {\n            logFailOpen(\"rpc-emit\", error)\n          }\n        }\n        return result\n      } catch (error) {\n        logFailOpen(\"rpc-set\", error)\n        return { ok: false, errors: [\"internal error\"] }\n      }\n    },\n    \"status.get\": (_input, context) =>\n      source\n        .status()\n        .catch((error: unknown) =>\n          context.error(\"internal\", String(error).slice(0, LOG_ERROR_LENGTH)),\n        ),\n    \"receipts.list\": (_input, context) =>\n      source\n        .receipts()\n        .catch((error: unknown) =>\n          context.error(\"internal\", String(error).slice(0, LOG_ERROR_LENGTH)),\n        ),\n    \"session-mode.get\": (input, context) =>\n      source\n        .getSessionMode(input.sessionID)\n        .then((mode) => ({ mode }))\n        .catch((error: unknown) =>\n          context.error(\"internal\", String(error).slice(0, LOG_ERROR_LENGTH)),\n        ),\n    \"session-mode.set\": async (input) => {\n      const invalid = sessionModeSetError(input)\n      if (invalid !== undefined) return { ok: false, errors: [invalid] }\n      try {\n        await source.setSessionMode(input.sessionID, input.mode)\n      } catch (error) {\n        logFailOpen(\"rpc-set\", error)\n        return { ok: false, errors: [\"internal error\"] }\n      }\n      if (emit !== undefined) {\n        try {\n          await emit(\"session-mode-changed\", { sessionID: input.sessionID })\n        } catch (error) {\n          logFailOpen(\"rpc-emit\", error)\n        }\n      }\n      return { ok: true }\n    },\n    \"tier-request.get\": (input, context) =>\n      source\n        .getTierRequest(input.sessionID)\n        .then((tier) => ({ tier }))\n        .catch((error: unknown) =>\n          context.error(\"internal\", String(error).slice(0, LOG_ERROR_LENGTH)),\n        ),\n    \"tier-request.set\": async (input) => {\n      const invalid = tierRequestSetError(input)\n      if (invalid !== undefined) return { ok: false, errors: [invalid] }\n      if (input.tier !== null) {\n        // A non-null tier is a sticky record: noteTierRequest re-validates the\n        // vocabulary (post-gate this cannot fail, so treat `false` as internal).\n        if (!source.noteTierRequest(input.sessionID, input.tier)) {\n          logFailOpen(\"rpc-set\", new Error(\"tier request rejected\"))\n          return { ok: false, errors: [\"internal error\"] }\n        }\n      } else {\n        try {\n          await source.setTierRequest(input.sessionID, null)\n        } catch (error) {\n          logFailOpen(\"rpc-set\", error)\n          return { ok: false, errors: [\"internal error\"] }\n        }\n      }\n      if (emit !== undefined) {\n        try {\n          await emit(\"tier-request-changed\", { sessionID: input.sessionID })\n        } catch (error) {\n          logFailOpen(\"rpc-emit\", error)\n        }\n      }\n      return { ok: true }\n    },\n  }\n}\n"]}

package/dist/rpc/status.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Status snapshot for the control surfaces (ADP-033): a bounded, secret-free
+ * view of the settings and the resource-health state of every configured
+ * resource. Pure — the supervisor (or any future caller) gathers the inputs.
+ */
+import type { OperatingMode } from "../core/scheduler/types.js";
+import type { ModelRef } from "../core/work-unit/types.js";
+import type { TierName } from "../core/tier-policy/types.js";
+import type { ResourceRecord } from "../health/resource-health/types.js";
+import type { CapacityReading } from "../health/capacity/types.js";
+import type { SettingsV1 } from "../state/settings/index.js";
+export interface TierResourceStatus {
+    ref: ModelRef;
+    health: ResourceRecord["health"];
+    breaker: ResourceRecord["breaker"]["state"];
+    windowed: boolean;
+    /**
+     * Wall-clock deadline of the active window (ms epoch); null when unwindowed.
+     * Null — not undefined: the host RPC encoder rejects JSON objects carrying a
+     * present-but-undefined key ("Expected JSON value"), which 500'd every
+     * status.get once any resource was configured.
+     */
+    windowUntil: number | null;
+    /** Used capacity as a rounded whole percent; null when no reading exists. */
+    usedPercent: number | null;
+    /** Wall-clock capacity reset deadline (ms epoch); null when unread. */
+    resetAt: number | null;
+}
+export interface StatusSnapshot {
+    mode: OperatingMode;
+    pin: ModelRef | null;
+    tiers: Readonly<Record<TierName, readonly TierResourceStatus[]>>;
+    parked: number;
+    receipts: number;
+}
+export declare function buildStatus(input: {
+    settings: SettingsV1;
+    health: readonly ResourceRecord[];
+    capacity: Readonly<Record<string, CapacityReading | null>>;
+    parked: number;
+    receipts: number;
+}): StatusSnapshot;

package/dist/rpc/status.js

@@ -0,0 +1,45 @@
+import { schedulerHealthKey } from "../core/scheduler/index.js";
+import { TIERS } from "../core/tier-policy/types.js";
+import { resourceKeyID } from "../health/resource-health/index.js";
+export function buildStatus(input) {
+    const byKey = new Map();
+    for (const record of input.health)
+        byKey.set(resourceKeyID(record.key), record);
+    const tiers = {};
+    for (const tier of TIERS) {
+        tiers[tier] = input.settings.tiers[tier].map((ref) => {
+            const record = byKey.get(schedulerHealthKey(ref));
+            const capacityReading = input.capacity[schedulerHealthKey(ref)] ?? null;
+            return {
+                ref,
+                health: record?.health ?? "healthy",
+                breaker: record?.breaker.state ?? "closed",
+                windowed: record?.window !== undefined,
+                windowUntil: record?.window?.until ?? null,
+                usedPercent: capacityUsedPercent(capacityReading),
+                resetAt: capacityReading?.resetAt ?? null,
+            };
+        });
+    }
+    return {
+        mode: input.settings.mode,
+        pin: input.settings.pin,
+        tiers,
+        parked: input.parked,
+        receipts: input.receipts,
+    };
+}
+/**
+ * Derives the used-capacity percentage from a reading. Readings may carry any
+ * subset of the two ratios: usedRatio directly, or the remainder inferred from
+ * remainingRatio. A reading with neither ratio is still present (confidence,
+ * resetAt may be set) but yields no percentage — null, not undefined.
+ */
+function capacityUsedPercent(reading) {
+    if (reading?.usedRatio !== undefined)
+        return Math.round(reading.usedRatio * 100);
+    if (reading?.remainingRatio !== undefined)
+        return Math.round((1 - reading.remainingRatio) * 100);
+    return null;
+}
+//# sourceMappingURL=status.js.map

package/dist/rpc/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/rpc/status.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAG/D,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAGpD,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AA6BlE,MAAM,UAAU,WAAW,CAAC,KAM3B;IACC,MAAM,KAAK,GAAG,IAAI,GAAG,EAA0B,CAAA;IAC/C,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,MAAM;QAAE,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAA;IAC/E,MAAM,KAAK,GAAG,EAA4C,CAAA;IAC1D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YACnD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAA;YACjD,MAAM,eAAe,GAAG,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAA;YACvE,OAAO;gBACL,GAAG;gBACH,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,SAAS;gBACnC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,QAAQ;gBAC1C,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,SAAS;gBACtC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,IAAI;gBAC1C,WAAW,EAAE,mBAAmB,CAAC,eAAe,CAAC;gBACjD,OAAO,EAAE,eAAe,EAAE,OAAO,IAAI,IAAI;aAC1C,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI;QACzB,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG;QACvB,KAAK;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACzB,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,OAA+B;IAC1D,IAAI,OAAO,EAAE,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,GAAG,GAAG,CAAC,CAAA;IAChF,IAAI,OAAO,EAAE,cAAc,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,GAAG,CAAC,CAAA;IAChG,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["/**\n * Status snapshot for the control surfaces (ADP-033): a bounded, secret-free\n * view of the settings and the resource-health state of every configured\n * resource. Pure — the supervisor (or any future caller) gathers the inputs.\n */\nimport type { OperatingMode } from \"../core/scheduler/types.js\"\nimport { schedulerHealthKey } from \"../core/scheduler/index.js\"\nimport type { ModelRef } from \"../core/work-unit/types.js\"\nimport type { TierName } from \"../core/tier-policy/types.js\"\nimport { TIERS } from \"../core/tier-policy/types.js\"\nimport type { ResourceRecord } from \"../health/resource-health/types.js\"\nimport type { CapacityReading } from \"../health/capacity/types.js\"\nimport { resourceKeyID } from \"../health/resource-health/index.js\"\nimport type { SettingsV1 } from \"../state/settings/index.js\"\n\nexport interface TierResourceStatus {\n  ref: ModelRef\n  health: ResourceRecord[\"health\"]\n  breaker: ResourceRecord[\"breaker\"][\"state\"]\n  windowed: boolean\n  /**\n   * Wall-clock deadline of the active window (ms epoch); null when unwindowed.\n   * Null — not undefined: the host RPC encoder rejects JSON objects carrying a\n   * present-but-undefined key (\"Expected JSON value\"), which 500'd every\n   * status.get once any resource was configured.\n   */\n  windowUntil: number | null\n  /** Used capacity as a rounded whole percent; null when no reading exists. */\n  usedPercent: number | null\n  /** Wall-clock capacity reset deadline (ms epoch); null when unread. */\n  resetAt: number | null\n}\n\nexport interface StatusSnapshot {\n  mode: OperatingMode\n  pin: ModelRef | null\n  tiers: Readonly<Record<TierName, readonly TierResourceStatus[]>>\n  parked: number\n  receipts: number\n}\n\nexport function buildStatus(input: {\n  settings: SettingsV1\n  health: readonly ResourceRecord[]\n  capacity: Readonly<Record<string, CapacityReading | null>>\n  parked: number\n  receipts: number\n}): StatusSnapshot {\n  const byKey = new Map<string, ResourceRecord>()\n  for (const record of input.health) byKey.set(resourceKeyID(record.key), record)\n  const tiers = {} as Record<TierName, TierResourceStatus[]>\n  for (const tier of TIERS) {\n    tiers[tier] = input.settings.tiers[tier].map((ref) => {\n      const record = byKey.get(schedulerHealthKey(ref))\n      const capacityReading = input.capacity[schedulerHealthKey(ref)] ?? null\n      return {\n        ref,\n        health: record?.health ?? \"healthy\",\n        breaker: record?.breaker.state ?? \"closed\",\n        windowed: record?.window !== undefined,\n        windowUntil: record?.window?.until ?? null,\n        usedPercent: capacityUsedPercent(capacityReading),\n        resetAt: capacityReading?.resetAt ?? null,\n      }\n    })\n  }\n  return {\n    mode: input.settings.mode,\n    pin: input.settings.pin,\n    tiers,\n    parked: input.parked,\n    receipts: input.receipts,\n  }\n}\n\n/**\n * Derives the used-capacity percentage from a reading. Readings may carry any\n * subset of the two ratios: usedRatio directly, or the remainder inferred from\n * remainingRatio. A reading with neither ratio is still present (confidence,\n * resetAt may be set) but yields no percentage — null, not undefined.\n */\nfunction capacityUsedPercent(reading: CapacityReading | null): number | null {\n  if (reading?.usedRatio !== undefined) return Math.round(reading.usedRatio * 100)\n  if (reading?.remainingRatio !== undefined) return Math.round((1 - reading.remainingRatio) * 100)\n  return null\n}\n"]}

package/dist/rpc.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RPC entrypoint: the typed definition shared by the server plugin and the
+ * control surfaces, plus the handler binding used server-side.
+ */
+export { adaptiveRpc, ADAPTIVE_RPC_ID } from "./rpc/definition.js";
+export type { AdaptiveRpc } from "./rpc/definition.js";
+export { adaptiveRpcHandlers } from "./rpc/handlers.js";
+export type { AdaptiveRpcSource, AdaptiveRpcEmit, SettingsChangedEmit, TierRequestSetResult, } from "./rpc/handlers.js";
+export { buildStatus } from "./rpc/status.js";
+export type { StatusSnapshot, TierResourceStatus } from "./rpc/status.js";

package/dist/rpc.js

@@ -0,0 +1,8 @@
+/**
+ * RPC entrypoint: the typed definition shared by the server plugin and the
+ * control surfaces, plus the handler binding used server-side.
+ */
+export { adaptiveRpc, ADAPTIVE_RPC_ID } from "./rpc/definition.js";
+export { adaptiveRpcHandlers } from "./rpc/handlers.js";
+export { buildStatus } from "./rpc/status.js";
+//# sourceMappingURL=rpc.js.map

package/dist/rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAElE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAOvD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA","sourcesContent":["/**\n * RPC entrypoint: the typed definition shared by the server plugin and the\n * control surfaces, plus the handler binding used server-side.\n */\nexport { adaptiveRpc, ADAPTIVE_RPC_ID } from \"./rpc/definition.js\"\nexport type { AdaptiveRpc } from \"./rpc/definition.js\"\nexport { adaptiveRpcHandlers } from \"./rpc/handlers.js\"\nexport type {\n  AdaptiveRpcSource,\n  AdaptiveRpcEmit,\n  SettingsChangedEmit,\n  TierRequestSetResult,\n} from \"./rpc/handlers.js\"\nexport { buildStatus } from \"./rpc/status.js\"\nexport type { StatusSnapshot, TierResourceStatus } from \"./rpc/status.js\"\n"]}

package/dist/state/capacity/index.d.ts

@@ -0,0 +1,3 @@
+export { CAPACITY_KEY, CAPACITY_VERSION, MAX_CAPACITY_READINGS, type CapacityPayload, type CapacityStorage, type PersistedCapacityReading, } from "./types.js";
+export { parseCapacityPayload } from "./parse.js";
+export { CapacityReadingStore } from "./store.js";

package/dist/state/capacity/index.js

@@ -0,0 +1,4 @@
+export { CAPACITY_KEY, CAPACITY_VERSION, MAX_CAPACITY_READINGS, } from "./types.js";
+export { parseCapacityPayload } from "./parse.js";
+export { CapacityReadingStore } from "./store.js";
+//# sourceMappingURL=index.js.map

package/dist/state/capacity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/state/capacity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,GAItB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA","sourcesContent":["export {\n  CAPACITY_KEY,\n  CAPACITY_VERSION,\n  MAX_CAPACITY_READINGS,\n  type CapacityPayload,\n  type CapacityStorage,\n  type PersistedCapacityReading,\n} from \"./types.js\"\nexport { parseCapacityPayload } from \"./parse.js\"\nexport { CapacityReadingStore } from \"./store.js\"\n"]}

package/dist/state/capacity/parse.d.ts

@@ -0,0 +1,2 @@
+import { type PersistedCapacityReading } from "./types.js";
+export declare function parseCapacityPayload(raw: unknown): PersistedCapacityReading[];

package/dist/state/capacity/parse.js

@@ -0,0 +1,122 @@
+import { CONFIDENCE_LEVELS } from "../../health/capacity/types.js";
+import { CAPACITY_VERSION, MAX_CAPACITY_READINGS } from "./types.js";
+// Defensive readers: persisted data is untrusted. Every parser is total —
+// accepts unknown, returns typed records, and drops anything invalid — so a
+// corrupted file can never take the plugin down (ADP-031). An older plugin
+// reading a newer payload drops unknown-vocabulary entries; the version field
+// guards the schema itself.
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(raw) {
+    return typeof raw === "number" && Number.isFinite(raw);
+}
+/**
+ * A non-empty bounded identifier. Over-long values are rejected, not
+ * truncated: the writer stores keys as-is, so a truncated key would name a
+ * different resource.
+ */
+function parseIdentifier(raw) {
+    if (typeof raw !== "string" || raw === "" || raw.length > 128)
+        return undefined;
+    return raw;
+}
+function parseKey(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const providerID = parseIdentifier(raw["providerID"]);
+    if (providerID === undefined)
+        return undefined;
+    const accountID = parseIdentifier(raw["accountID"]);
+    const modelID = parseIdentifier(raw["modelID"]);
+    const variantID = parseIdentifier(raw["variantID"]);
+    // A present-but-unusable scope field would silently widen the key.
+    if (raw["accountID"] !== undefined && accountID === undefined)
+        return undefined;
+    if (raw["modelID"] !== undefined && modelID === undefined)
+        return undefined;
+    if (raw["variantID"] !== undefined && variantID === undefined)
+        return undefined;
+    // Scope fields must form a valid prefix: a variant without a model is not
+    // addressable against a model inventory and is not a real resource.
+    if (variantID !== undefined && modelID === undefined)
+        return undefined;
+    return {
+        providerID,
+        ...(accountID !== undefined ? { accountID } : {}),
+        ...(modelID !== undefined ? { modelID } : {}),
+        ...(variantID !== undefined ? { variantID } : {}),
+    };
+}
+function parseRatio(raw) {
+    return isFiniteNumber(raw) && raw >= 0 && raw <= 1 ? raw : undefined;
+}
+function parseReading(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const confidence = CONFIDENCE_LEVELS.find((level) => level === raw["confidence"]);
+    if (confidence === undefined)
+        return undefined;
+    const observedAt = raw["observedAt"];
+    if (!isFiniteNumber(observedAt) || observedAt < 0)
+        return undefined;
+    const usedRatio = parseRatio(raw["usedRatio"]);
+    const remainingRatio = parseRatio(raw["remainingRatio"]);
+    const retryAfterMs = isFiniteNumber(raw["retryAfterMs"]) && raw["retryAfterMs"] >= 0
+        ? raw["retryAfterMs"]
+        : undefined;
+    const resetAt = isFiniteNumber(raw["resetAt"]) && raw["resetAt"] >= 0 ? raw["resetAt"] : undefined;
+    // A reading with none of the measured fields carries no information and is
+    // discarded (mirrors the domain rule in health/capacity/types.ts).
+    if (usedRatio === undefined &&
+        remainingRatio === undefined &&
+        retryAfterMs === undefined &&
+        resetAt === undefined) {
+        return undefined;
+    }
+    const evidence = raw["evidence"];
+    return {
+        ...(usedRatio !== undefined ? { usedRatio } : {}),
+        ...(remainingRatio !== undefined ? { remainingRatio } : {}),
+        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        ...(resetAt !== undefined ? { resetAt } : {}),
+        confidence,
+        observedAt,
+        ...(typeof evidence === "string" && evidence.length > 0
+            ? { evidence: evidence.slice(0, 128) }
+            : {}),
+    };
+}
+function parseEntry(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const key = parseKey(raw["key"]);
+    if (key === undefined)
+        return undefined;
+    const reading = parseReading(raw["reading"]);
+    if (reading === undefined)
+        return undefined;
+    return { key, reading };
+}
+// Every parser is total: accepts unknown, returns typed records, and drops
+// anything invalid — a corrupted file can never take the plugin down
+// (ADP-031). An older plugin reading newer records may drop
+// unknown-vocabulary entries — records are bounded mirrors of an in-memory
+// registry, and the payload version guards the schema itself.
+export function parseCapacityPayload(raw) {
+    if (!isRecord(raw))
+        return [];
+    if (raw["version"] !== CAPACITY_VERSION)
+        return [];
+    if (!Array.isArray(raw["readings"]))
+        return [];
+    const list = raw["readings"];
+    const readings = [];
+    for (const entry of list.slice(0, MAX_CAPACITY_READINGS)) {
+        const parsed = parseEntry(entry);
+        if (parsed !== undefined)
+            readings.push(parsed);
+    }
+    return readings;
+}
+//# sourceMappingURL=parse.js.map

package/dist/state/capacity/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../src/state/capacity/parse.ts"],"names":[],"mappings":"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","sourcesContent":["import { CONFIDENCE_LEVELS } from \"../../health/capacity/types.js\"\nimport type { CapacityReading } from \"../../health/capacity/types.js\"\nimport type { ResourceKey } from \"../../health/resource-health/types.js\"\nimport { CAPACITY_VERSION, MAX_CAPACITY_READINGS, type PersistedCapacityReading } from \"./types.js\"\n\n// Defensive readers: persisted data is untrusted. Every parser is total —\n// accepts unknown, returns typed records, and drops anything invalid — so a\n// corrupted file can never take the plugin down (ADP-031). An older plugin\n// reading a newer payload drops unknown-vocabulary entries; the version field\n// guards the schema itself.\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value)\n}\n\nfunction isFiniteNumber(raw: unknown): raw is number {\n  return typeof raw === \"number\" && Number.isFinite(raw)\n}\n\n/**\n * A non-empty bounded identifier. Over-long values are rejected, not\n * truncated: the writer stores keys as-is, so a truncated key would name a\n * different resource.\n */\nfunction parseIdentifier(raw: unknown): string | undefined {\n  if (typeof raw !== \"string\" || raw === \"\" || raw.length > 128) return undefined\n  return raw\n}\n\nfunction parseKey(raw: unknown): ResourceKey | undefined {\n  if (!isRecord(raw)) return undefined\n  const providerID = parseIdentifier(raw[\"providerID\"])\n  if (providerID === undefined) return undefined\n  const accountID = parseIdentifier(raw[\"accountID\"])\n  const modelID = parseIdentifier(raw[\"modelID\"])\n  const variantID = parseIdentifier(raw[\"variantID\"])\n  // A present-but-unusable scope field would silently widen the key.\n  if (raw[\"accountID\"] !== undefined && accountID === undefined) return undefined\n  if (raw[\"modelID\"] !== undefined && modelID === undefined) return undefined\n  if (raw[\"variantID\"] !== undefined && variantID === undefined) return undefined\n  // Scope fields must form a valid prefix: a variant without a model is not\n  // addressable against a model inventory and is not a real resource.\n  if (variantID !== undefined && modelID === undefined) return undefined\n  return {\n    providerID,\n    ...(accountID !== undefined ? { accountID } : {}),\n    ...(modelID !== undefined ? { modelID } : {}),\n    ...(variantID !== undefined ? { variantID } : {}),\n  }\n}\n\nfunction parseRatio(raw: unknown): number | undefined {\n  return isFiniteNumber(raw) && raw >= 0 && raw <= 1 ? raw : undefined\n}\n\nfunction parseReading(raw: unknown): CapacityReading | undefined {\n  if (!isRecord(raw)) return undefined\n  const confidence = CONFIDENCE_LEVELS.find((level) => level === raw[\"confidence\"])\n  if (confidence === undefined) return undefined\n  const observedAt = raw[\"observedAt\"]\n  if (!isFiniteNumber(observedAt) || observedAt < 0) return undefined\n  const usedRatio = parseRatio(raw[\"usedRatio\"])\n  const remainingRatio = parseRatio(raw[\"remainingRatio\"])\n  const retryAfterMs =\n    isFiniteNumber(raw[\"retryAfterMs\"]) && raw[\"retryAfterMs\"] >= 0\n      ? raw[\"retryAfterMs\"]\n      : undefined\n  const resetAt = isFiniteNumber(raw[\"resetAt\"]) && raw[\"resetAt\"] >= 0 ? raw[\"resetAt\"] : undefined\n  // A reading with none of the measured fields carries no information and is\n  // discarded (mirrors the domain rule in health/capacity/types.ts).\n  if (\n    usedRatio === undefined &&\n    remainingRatio === undefined &&\n    retryAfterMs === undefined &&\n    resetAt === undefined\n  ) {\n    return undefined\n  }\n  const evidence = raw[\"evidence\"]\n  return {\n    ...(usedRatio !== undefined ? { usedRatio } : {}),\n    ...(remainingRatio !== undefined ? { remainingRatio } : {}),\n    ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),\n    ...(resetAt !== undefined ? { resetAt } : {}),\n    confidence,\n    observedAt,\n    ...(typeof evidence === \"string\" && evidence.length > 0\n      ? { evidence: evidence.slice(0, 128) }\n      : {}),\n  }\n}\n\nfunction parseEntry(raw: unknown): PersistedCapacityReading | undefined {\n  if (!isRecord(raw)) return undefined\n  const key = parseKey(raw[\"key\"])\n  if (key === undefined) return undefined\n  const reading = parseReading(raw[\"reading\"])\n  if (reading === undefined) return undefined\n  return { key, reading }\n}\n\n// Every parser is total: accepts unknown, returns typed records, and drops\n// anything invalid — a corrupted file can never take the plugin down\n// (ADP-031). An older plugin reading newer records may drop\n// unknown-vocabulary entries — records are bounded mirrors of an in-memory\n// registry, and the payload version guards the schema itself.\nexport function parseCapacityPayload(raw: unknown): PersistedCapacityReading[] {\n  if (!isRecord(raw)) return []\n  if (raw[\"version\"] !== CAPACITY_VERSION) return []\n  if (!Array.isArray(raw[\"readings\"])) return []\n  const list = raw[\"readings\"]\n  const readings: PersistedCapacityReading[] = []\n  for (const entry of list.slice(0, MAX_CAPACITY_READINGS)) {\n    const parsed = parseEntry(entry)\n    if (parsed !== undefined) readings.push(parsed)\n  }\n  return readings\n}\n"]}

package/dist/state/capacity/store.d.ts

@@ -0,0 +1,18 @@
+import { type CapacityStorage, type PersistedCapacityReading } from "./types.js";
+export declare class CapacityReadingStore {
+    #private;
+    private readonly storage;
+    constructor(storage: CapacityStorage);
+    /** Load the persisted mirror; unreadable or corrupt data is empty, not an error. */
+    load(): Promise<void>;
+    snapshot(): readonly PersistedCapacityReading[];
+    /**
+     * Merge one refresh batch into the mirror and persist it. Merge — not
+     * replace — per resource key, with the newest `observedAt` winning: the TUI
+     * host loads this plugin into several supervisor instances, and an instance
+     * whose sensors have seen nothing must never clobber what the observing
+     * instance persisted. Bound by MAX_CAPACITY_READINGS, evicting the oldest
+     * observations first.
+     */
+    replace(entries: readonly PersistedCapacityReading[]): Promise<void>;
+}

package/dist/state/capacity/store.js

@@ -0,0 +1,78 @@
+/**
+ * Persistence mirror of the in-memory capacity registry: loads what any
+ * instance observed and keeps it bounded (oldest-observed evicted), merging
+ * per resource key on every replace.
+ *
+ * As everywhere else in state/, memory is only advanced after a successful
+ * write, so memory and disk never diverge; write failures propagate to the
+ * caller — the wiring layer's fail-open wrapper decides how to degrade
+ * (ADP-031).
+ */
+import { resourceKeyID } from "../../health/resource-health/key.js";
+import { CAPACITY_VERSION, MAX_CAPACITY_READINGS, } from "./types.js";
+import { parseCapacityPayload } from "./parse.js";
+export class CapacityReadingStore {
+    storage;
+    #readings = [];
+    #queue = Promise.resolve();
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /** Load the persisted mirror; unreadable or corrupt data is empty, not an error. */
+    load() {
+        return this.#serialize(() => this.#load());
+    }
+    async #load() {
+        let raw;
+        try {
+            raw = await this.storage.read();
+        }
+        catch {
+            this.#readings = [];
+            return;
+        }
+        this.#readings = parseCapacityPayload(raw);
+    }
+    snapshot() {
+        return this.#readings;
+    }
+    /**
+     * Merge one refresh batch into the mirror and persist it. Merge — not
+     * replace — per resource key, with the newest `observedAt` winning: the TUI
+     * host loads this plugin into several supervisor instances, and an instance
+     * whose sensors have seen nothing must never clobber what the observing
+     * instance persisted. Bound by MAX_CAPACITY_READINGS, evicting the oldest
+     * observations first.
+     */
+    replace(entries) {
+        return this.#serialize(() => this.#replace(entries));
+    }
+    async #replace(entries) {
+        const byKey = new Map();
+        for (const entry of this.#readings) {
+            byKey.set(resourceKeyID(entry.key), entry);
+        }
+        for (const entry of entries) {
+            const id = resourceKeyID(entry.key);
+            const previous = byKey.get(id);
+            if (previous === undefined || entry.reading.observedAt > previous.reading.observedAt) {
+                byKey.set(id, entry);
+            }
+        }
+        const merged = [...byKey.values()];
+        merged.sort((a, b) => b.reading.observedAt - a.reading.observedAt);
+        const next = merged.slice(0, MAX_CAPACITY_READINGS);
+        // Persist BEFORE committing memory: a write failure must leave memory and
+        // disk consistent (the caller decides how to fail open).
+        await this.storage.write({ version: CAPACITY_VERSION, readings: next });
+        this.#readings = next;
+    }
+    // The merge must run after the preceding commit, and reloads cannot race
+    // writes. Rejections remain visible to callers without poisoning the tail.
+    #serialize(operation) {
+        const run = this.#queue.then(operation);
+        this.#queue = run.catch(() => undefined);
+        return run;
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/state/capacity/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../src/state/capacity/store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persistence mirror of the in-memory capacity registry: loads what any\n * instance observed and keeps it bounded (oldest-observed evicted), merging\n * per resource key on every replace.\n *\n * As everywhere else in state/, memory is only advanced after a successful\n * write, so memory and disk never diverge; write failures propagate to the\n * caller — the wiring layer's fail-open wrapper decides how to degrade\n * (ADP-031).\n */\nimport { resourceKeyID } from \"../../health/resource-health/key.js\"\nimport {\n  CAPACITY_VERSION,\n  MAX_CAPACITY_READINGS,\n  type CapacityStorage,\n  type PersistedCapacityReading,\n} from \"./types.js\"\nimport { parseCapacityPayload } from \"./parse.js\"\n\nexport class CapacityReadingStore {\n  #readings: PersistedCapacityReading[] = []\n  #queue: Promise<unknown> = Promise.resolve()\n\n  constructor(private readonly storage: CapacityStorage) {}\n\n  /** Load the persisted mirror; unreadable or corrupt data is empty, not an error. */\n  load(): Promise<void> {\n    return this.#serialize(() => this.#load())\n  }\n\n  async #load(): Promise<void> {\n    let raw: unknown\n    try {\n      raw = await this.storage.read()\n    } catch {\n      this.#readings = []\n      return\n    }\n    this.#readings = parseCapacityPayload(raw)\n  }\n\n  snapshot(): readonly PersistedCapacityReading[] {\n    return this.#readings\n  }\n\n  /**\n   * Merge one refresh batch into the mirror and persist it. Merge — not\n   * replace — per resource key, with the newest `observedAt` winning: the TUI\n   * host loads this plugin into several supervisor instances, and an instance\n   * whose sensors have seen nothing must never clobber what the observing\n   * instance persisted. Bound by MAX_CAPACITY_READINGS, evicting the oldest\n   * observations first.\n   */\n  replace(entries: readonly PersistedCapacityReading[]): Promise<void> {\n    return this.#serialize(() => this.#replace(entries))\n  }\n\n  async #replace(entries: readonly PersistedCapacityReading[]): Promise<void> {\n    const byKey = new Map<string, PersistedCapacityReading>()\n    for (const entry of this.#readings) {\n      byKey.set(resourceKeyID(entry.key), entry)\n    }\n    for (const entry of entries) {\n      const id = resourceKeyID(entry.key)\n      const previous = byKey.get(id)\n      if (previous === undefined || entry.reading.observedAt > previous.reading.observedAt) {\n        byKey.set(id, entry)\n      }\n    }\n    const merged = [...byKey.values()]\n    merged.sort((a, b) => b.reading.observedAt - a.reading.observedAt)\n    const next = merged.slice(0, MAX_CAPACITY_READINGS)\n    // Persist BEFORE committing memory: a write failure must leave memory and\n    // disk consistent (the caller decides how to fail open).\n    await this.storage.write({ version: CAPACITY_VERSION, readings: next })\n    this.#readings = next\n  }\n\n  // The merge must run after the preceding commit, and reloads cannot race\n  // writes. Rejections remain visible to callers without poisoning the tail.\n  #serialize(operation: () => Promise<void>): Promise<void> {\n    const run = this.#queue.then(operation)\n    this.#queue = run.catch(() => undefined)\n    return run\n  }\n}\n"]}

package/dist/state/capacity/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Persisted capacity readings (ADP-020/ADP-031).
+ *
+ * The host's TUI-mode plugin reconciliation can load the plugin several times
+ * into one process: the session hooks (the event pump that observes capacity
+ * headers) and the RPC registration that serves status.get can land on
+ * DIFFERENT supervisor instances. The in-memory capacity registry lives only
+ * on the hook instance, so capacity would be invisible to the status-serving
+ * instance — the same trap that health records solve with their persisted
+ * mirror. Persisting readings lets every instance read what any instance
+ * observed, like receipts/settings/parked work.
+ */
+import type { ResourceKey } from "../../health/resource-health/types.js";
+import type { CapacityReading } from "../../health/capacity/types.js";
+/** Storage key for the capacity mirror (bound by the adapter to ctx.storage). */
+export declare const CAPACITY_KEY = "coool.adaptive/capacity";
+export declare const CAPACITY_VERSION = 1;
+/**
+ * Product bound — not a user knob. A capacity reading is only useful while it
+ * is fresh (readings older than the max age are treated as absent), so far
+ * fewer entries than the health bound suffice to cover every configured
+ * resource.
+ */
+export declare const MAX_CAPACITY_READINGS = 64;
+export interface PersistedCapacityReading {
+    readonly key: ResourceKey;
+    readonly reading: CapacityReading;
+}
+export interface CapacityPayload {
+    readonly version: typeof CAPACITY_VERSION;
+    readonly readings: readonly PersistedCapacityReading[];
+}
+/** Storage seam — the adapter binds `CAPACITY_KEY` to `ctx.storage`. */
+export interface CapacityStorage {
+    read(): Promise<unknown>;
+    write(payload: CapacityPayload): Promise<void>;
+}

package/dist/state/capacity/types.js

@@ -0,0 +1,11 @@
+/** Storage key for the capacity mirror (bound by the adapter to ctx.storage). */
+export const CAPACITY_KEY = "coool.adaptive/capacity";
+export const CAPACITY_VERSION = 1;
+/**
+ * Product bound — not a user knob. A capacity reading is only useful while it
+ * is fresh (readings older than the max age are treated as absent), so far
+ * fewer entries than the health bound suffice to cover every configured
+ * resource.
+ */
+export const MAX_CAPACITY_READINGS = 64;
+//# sourceMappingURL=types.js.map

package/dist/state/capacity/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/state/capacity/types.ts"],"names":[],"mappings":"AAeA,iFAAiF;AACjF,MAAM,CAAC,MAAM,YAAY,GAAG,yBAAyB,CAAA;AAErD,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAA;AAEjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAA","sourcesContent":["/**\n * Persisted capacity readings (ADP-020/ADP-031).\n *\n * The host's TUI-mode plugin reconciliation can load the plugin several times\n * into one process: the session hooks (the event pump that observes capacity\n * headers) and the RPC registration that serves status.get can land on\n * DIFFERENT supervisor instances. The in-memory capacity registry lives only\n * on the hook instance, so capacity would be invisible to the status-serving\n * instance — the same trap that health records solve with their persisted\n * mirror. Persisting readings lets every instance read what any instance\n * observed, like receipts/settings/parked work.\n */\nimport type { ResourceKey } from \"../../health/resource-health/types.js\"\nimport type { CapacityReading } from \"../../health/capacity/types.js\"\n\n/** Storage key for the capacity mirror (bound by the adapter to ctx.storage). */\nexport const CAPACITY_KEY = \"coool.adaptive/capacity\"\n\nexport const CAPACITY_VERSION = 1\n\n/**\n * Product bound — not a user knob. A capacity reading is only useful while it\n * is fresh (readings older than the max age are treated as absent), so far\n * fewer entries than the health bound suffice to cover every configured\n * resource.\n */\nexport const MAX_CAPACITY_READINGS = 64\n\nexport interface PersistedCapacityReading {\n  readonly key: ResourceKey\n  readonly reading: CapacityReading\n}\n\nexport interface CapacityPayload {\n  readonly version: typeof CAPACITY_VERSION\n  readonly readings: readonly PersistedCapacityReading[]\n}\n\n/** Storage seam — the adapter binds `CAPACITY_KEY` to `ctx.storage`. */\nexport interface CapacityStorage {\n  read(): Promise<unknown>\n  write(payload: CapacityPayload): Promise<void>\n}\n"]}

package/dist/state/health/index.d.ts

@@ -0,0 +1,4 @@
+export { parseHealthPayload } from "./parse.js";
+export { HealthRecordStore } from "./store.js";
+export { HEALTH_KEY, HEALTH_VERSION, MAX_HEALTH_RECORDS } from "./types.js";
+export type { HealthPayload, HealthStorage } from "./types.js";

package/dist/state/health/index.js

@@ -0,0 +1,4 @@
+export { parseHealthPayload } from "./parse.js";
+export { HealthRecordStore } from "./store.js";
+export { HEALTH_KEY, HEALTH_VERSION, MAX_HEALTH_RECORDS } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/state/health/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/state/health/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA","sourcesContent":["export { parseHealthPayload } from \"./parse.js\"\nexport { HealthRecordStore } from \"./store.js\"\nexport { HEALTH_KEY, HEALTH_VERSION, MAX_HEALTH_RECORDS } from \"./types.js\"\nexport type { HealthPayload, HealthStorage } from \"./types.js\"\n"]}