@coool/opencode-adaptive 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,7 @@
+import type { DeferDecision, EscalateDecision, EscalationInput } from "./types.js";
+/**
+ * Plan the next escalation step, or defer with the reason escalation cannot
+ * proceed. Total and deterministic.
+ */
+export declare function planEscalation(input: EscalationInput): EscalateDecision | DeferDecision;
+//# sourceMappingURL=escalate.d.ts.map

package/dist/core/scheduler/escalate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalate.d.ts","sourceRoot":"","sources":["../../../src/core/scheduler/escalate.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAmBlF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,GAAG,aAAa,CA4BvF"}

package/dist/core/scheduler/escalate.js

@@ -0,0 +1,56 @@
+/**
+ * Capability escalation planner (ADP-015).
+ *
+ * Escalation is justified only by non-empty structured evidence, follows the
+ * ladder same model / current effort → same model / stronger effort → next
+ * tier, and is bounded by a finite per-unit budget. Every output either moves
+ * strictly up the ladder or refuses — the planner can never produce a loop,
+ * because each accepted step strictly increases a well-founded measure
+ * (variant index within the ladder, then tier index).
+ */
+import { nextTier } from "../tier-policy/types.js";
+import { MAX_ESCALATION_EVIDENCE } from "./types.js";
+function escalate(input, target, step, tier) {
+    return {
+        kind: "escalate",
+        target,
+        step,
+        tier,
+        evidence: input.evidence.slice(-MAX_ESCALATION_EVIDENCE),
+        budgetRemaining: input.budget.max - input.budget.used - 1,
+    };
+}
+/**
+ * Plan the next escalation step, or defer with the reason escalation cannot
+ * proceed. Total and deterministic.
+ */
+export function planEscalation(input) {
+    if (input.evidence.length === 0) {
+        return { kind: "defer", reason: "escalation-not-justified" };
+    }
+    if (input.budget.max <= 0 || input.budget.used >= input.budget.max) {
+        return { kind: "defer", reason: "escalation-budget-exhausted" };
+    }
+    const { currentModel, variantLadder } = input;
+    if (currentModel.variant !== undefined && variantLadder !== undefined) {
+        const index = variantLadder.indexOf(currentModel.variant);
+        if (index >= 0) {
+            // For a well-formed (non-holey) ladder, undefined here means the current
+            // variant is the strongest — the ladder is exhausted.
+            const stronger = variantLadder[index + 1];
+            if (stronger !== undefined) {
+                return escalate(input, { ...currentModel, variant: stronger }, "variant", input.currentTier);
+            }
+        }
+    }
+    const next = nextTier(input.currentTier);
+    if (next === undefined) {
+        return { kind: "defer", reason: "escalation-ceiling" };
+    }
+    const target = input.nextTierResources[0];
+    if (target === undefined) {
+        return { kind: "defer", reason: "escalation-no-candidate" };
+    }
+    return escalate(input, target, "tier", next);
+}
+//# sourceMappingURL=escalate.js.map

package/dist/core/scheduler/escalate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalate.js","sourceRoot":"","sources":["../../../src/core/scheduler/escalate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAGlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAEpD,SAAS,QAAQ,CACf,KAAsB,EACtB,MAAgB,EAChB,IAA8B,EAC9B,IAA8B;IAE9B,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,MAAM;QACN,IAAI;QACJ,IAAI;QACJ,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,uBAAuB,CAAC;QACxD,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC;KAC1D,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,KAAsB;IACnD,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAA;IAC9D,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QACnE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,6BAA6B,EAAE,CAAA;IACjE,CAAC;IACD,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,KAAK,CAAA;IAC7C,IAAI,YAAY,CAAC,OAAO,KAAK,SAAS,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QACtE,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;QACzD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,yEAAyE;YACzE,sDAAsD;YACtD,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;YACzC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,OAAO,QAAQ,CAAC,KAAK,EAAE,EAAE,GAAG,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;YAC9F,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;IACxC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAA;IACxD,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAA;IACzC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,yBAAyB,EAAE,CAAA;IAC7D,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;AAC9C,CAAC"}

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

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

package/dist/core/scheduler/index.d.ts.map

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

package/dist/core/scheduler/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/scheduler/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA"}

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

@@ -0,0 +1,9 @@
+/**
+ * Operating-mode wrapper (GOAL operating modes). OBSERVE and CONTROL run the
+ * identical core; OBSERVE wraps the result without applying it. OFF never
+ * reaches the scheduler, but the total wrapper maps it to an explicit defer
+ * so the union stays closed.
+ */
+import type { Decision, OperatingMode } from "./types.js";
+export declare function forMode(decision: Decision, mode: OperatingMode): Decision;
+//# sourceMappingURL=mode.d.ts.map

package/dist/core/scheduler/mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.d.ts","sourceRoot":"","sources":["../../../src/core/scheduler/mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAEzD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,QAAQ,CAQzE"}

package/dist/core/scheduler/mode.js

@@ -0,0 +1,10 @@
+export function forMode(decision, mode) {
+    if (mode === "observe") {
+        return { kind: "observe-only", would: decision };
+    }
+    if (mode === "active") {
+        return decision;
+    }
+    return { kind: "defer", reason: "adaptive-off" };
+}
+//# sourceMappingURL=mode.js.map

package/dist/core/scheduler/mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.js","sourceRoot":"","sources":["../../../src/core/scheduler/mode.ts"],"names":[],"mappings":"AAQA,MAAM,UAAU,OAAO,CAAC,QAAkB,EAAE,IAAmB;IAC7D,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAA;IAClD,CAAC;IACD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtB,OAAO,QAAQ,CAAA;IACjB,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA;AAClD,CAAC"}

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

@@ -0,0 +1,143 @@
+/**
+ * Scheduler types (ADP-013/015/016/022): the pure decision core's vocabulary.
+ *
+ * The core is a total function over its inputs — routing outcome, demand,
+ * inventory, per-candidate health and capacity views — and never performs
+ * effects. Effects (switching, receipts, parking) belong to the execution
+ * layer. OBSERVE and CONTROL call the same core; mode handling is a pure
+ * wrapper (`forMode`).
+ */
+import type { ModelRef } from "../work-unit/types.js";
+import type { RoutingDecision, TierName } from "../tier-policy/types.js";
+import type { CandidateModel, Demand } from "../compatibility/types.js";
+import type { Assessment } from "../../health/resource-health/types.js";
+import type { CapacitySignals } from "../../health/capacity/types.js";
+/** Operating modes (GOAL manual control). The plugin defaults to `observe`. */
+export declare const OPERATING_MODES: readonly ["off", "observe", "active"];
+export type OperatingMode = (typeof OPERATING_MODES)[number];
+/** Why an `apply` decision chose its model (receipt provenance). */
+export declare const APPLY_REASONS: readonly ["pin", "preferred", "fallback", "probe", "draining"];
+export type ApplyReason = (typeof APPLY_REASONS)[number];
+/**
+ * Why the core did not apply anything.
+ * - `routing-defer` — the tier ladder deferred; OpenCode's choice stands.
+ * - `pin-unverifiable` — the pinned model is not in the host inventory, so
+ *   availability cannot be verified (inventory gate); deferring keeps the
+ *   user's own model choice, which for a pin is typically the pinned model.
+ * - `pin-incompatible` — the pinned model cannot execute the work.
+ * - `escalation-*` — escalation evidence was absent, the budget was spent,
+ *   the tier ladder is at its ceiling, or the next tier has no resources
+ *   (no cross-tier borrowing).
+ * - `adaptive-off` — the plugin is off; only reachable through `forMode`.
+ */
+export declare const SCHEDULER_DEFER_REASONS: readonly ["routing-defer", "pin-unverifiable", "pin-incompatible", "escalation-not-justified", "escalation-budget-exhausted", "escalation-ceiling", "escalation-no-candidate", "adaptive-off"];
+export type SchedulerDeferReason = (typeof SCHEDULER_DEFER_REASONS)[number];
+/**
+ * Why work parks instead of applying: the required tier has no usable
+ * resource right now. Parking waits for recovery — it never borrows across
+ * tiers (ADP-022).
+ */
+export declare const PARK_REASONS: readonly ["pin-blocked", "no-candidates", "no-compatible-resource", "all-blocked"];
+export type ParkReason = (typeof PARK_REASONS)[number];
+/** Why a tier candidate was not usable. Superset of gate and health reasons. */
+export declare const SKIP_REASONS: readonly ["not-in-inventory", "capacity-exhausted", "incompatible", "provider-unavailable", "model-unavailable", "variant-unavailable", "tool-use-unsupported", "input-modality-unsupported", "output-modality-unsupported", "context-capacity-insufficient", "context-capacity-unknown", "unavailable", "quota-exhausted", "rate-limited", "breaker-open", "probe-in-flight", "draining"];
+export type SkipReason = (typeof SKIP_REASONS)[number];
+/** A tier candidate that could not take the work, with the bounded reason. */
+export interface SkippedCandidate {
+    readonly ref: ModelRef;
+    readonly why: SkipReason;
+}
+/** Bounded evidence attached to an `apply` decision. */
+export interface ApplyEvidence {
+    /** Candidates considered before the applied one, in order (bounded). */
+    readonly skipped: readonly SkippedCandidate[];
+    /** Breaker probe id when the applied unit is the half-open probe. */
+    readonly probeId?: string | undefined;
+}
+export interface ApplyDecision {
+    readonly kind: "apply";
+    readonly model: ModelRef;
+    /** Required tier; `undefined` for pin routing (a pin is not a tier). */
+    readonly tier?: TierName | undefined;
+    readonly reason: ApplyReason;
+    readonly evidence: ApplyEvidence;
+}
+export interface DeferDecision {
+    readonly kind: "defer";
+    readonly reason: SchedulerDeferReason;
+    readonly detail?: string | undefined;
+}
+export interface ParkDecision {
+    readonly kind: "park";
+    readonly reason: ParkReason;
+    readonly detail?: string | undefined;
+}
+/** Structured capability evidence for escalation (ADP-015). Never prose mining. */
+export declare const ESCALATION_EVIDENCE_KINDS: readonly ["agent-request", "reviewer-rejection", "verification-failure", "repeated-failure", "explicit-blocker"];
+export type EscalationEvidenceKind = (typeof ESCALATION_EVIDENCE_KINDS)[number];
+export interface EscalationEvidence {
+    readonly kind: EscalationEvidenceKind;
+    readonly detail?: string | undefined;
+}
+export declare const ESCALATION_STEPS: readonly ["variant", "tier"];
+export type EscalationStep = (typeof ESCALATION_STEPS)[number];
+/** Finite per-unit escalation budget (ADP-015). `used >= max` ends escalation. */
+export interface EscalationBudget {
+    readonly used: number;
+    readonly max: number;
+}
+/** Bound on evidence carried by an `escalate` decision (latest wins). */
+export declare const MAX_ESCALATION_EVIDENCE = 4;
+export interface EscalationInput {
+    readonly currentModel: ModelRef;
+    readonly currentTier: TierName;
+    /**
+     * Ordered variant ids for the current model, weakest → strongest, when the
+     * host inventory exposes an order. Without a ladder the variant step is
+     * skipped — strength is never guessed from variant names (ADP-004).
+     */
+    readonly variantLadder?: readonly string[] | undefined;
+    /** Configured resources of the next tier, user order, already gated. */
+    readonly nextTierResources: readonly ModelRef[];
+    /** Non-empty structured evidence justifies escalation. */
+    readonly evidence: readonly EscalationEvidence[];
+    readonly budget: EscalationBudget;
+}
+export interface EscalateDecision {
+    readonly kind: "escalate";
+    readonly target: ModelRef;
+    readonly step: EscalationStep;
+    /** Tier of the target: unchanged for the variant step, next tier otherwise. */
+    readonly tier: TierName;
+    readonly evidence: readonly EscalationEvidence[];
+    readonly budgetRemaining: number;
+}
+/** OBSERVE mode's wrapper: the identical decision, recorded but not applied. */
+export interface ObserveOnlyDecision {
+    readonly kind: "observe-only";
+    readonly would: Decision;
+}
+export type Decision = ApplyDecision | DeferDecision | ParkDecision | EscalateDecision | ObserveOnlyDecision;
+/** What admission can return — escalation never originates from admission. */
+export type AdmissionDecision = ApplyDecision | DeferDecision | ParkDecision;
+/**
+ * Everything admission looks at. `health` and `capacity` are keyed by
+ * `schedulerHealthKey(ref)`; an absent health entry means "no observed
+ * failure" (the registry's default), an absent capacity entry means "no
+ * estimate" — unknown is never treated as exhausted.
+ */
+export interface SchedulerInput {
+    readonly routing: RoutingDecision;
+    readonly demand: Demand;
+    /** Host inventory (adapter-normalized). Candidates absent here are unverifiable. */
+    readonly inventory: readonly CandidateModel[];
+    /** Configured resources of the required tier, in user order (ADP-005). */
+    readonly tierCandidates: readonly ModelRef[];
+    readonly health: Readonly<Record<string, Assessment>>;
+    readonly capacity: Readonly<Record<string, CapacitySignals>>;
+}
+/** Bound on the `skipped` evidence list of an `apply` decision. */
+export declare const MAX_EVIDENCE_SKIPPED = 8;
+/** Canonical health/capacity map key for a candidate model reference. */
+export declare function schedulerHealthKey(ref: ModelRef): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/scheduler/types.d.ts.map

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

package/dist/core/scheduler/types.js

@@ -0,0 +1,74 @@
+import { INCOMPATIBILITY_REASONS } from "../compatibility/types.js";
+import { BLOCKED_REASONS } from "../../health/resource-health/types.js";
+import { resourceKeyID } from "../../health/resource-health/key.js";
+/** Operating modes (GOAL manual control). The plugin defaults to `observe`. */
+export const OPERATING_MODES = ["off", "observe", "active"];
+/** Why an `apply` decision chose its model (receipt provenance). */
+export const APPLY_REASONS = [
+    "pin",
+    "preferred",
+    "fallback",
+    "probe",
+    "draining",
+];
+/**
+ * Why the core did not apply anything.
+ * - `routing-defer` — the tier ladder deferred; OpenCode's choice stands.
+ * - `pin-unverifiable` — the pinned model is not in the host inventory, so
+ *   availability cannot be verified (inventory gate); deferring keeps the
+ *   user's own model choice, which for a pin is typically the pinned model.
+ * - `pin-incompatible` — the pinned model cannot execute the work.
+ * - `escalation-*` — escalation evidence was absent, the budget was spent,
+ *   the tier ladder is at its ceiling, or the next tier has no resources
+ *   (no cross-tier borrowing).
+ * - `adaptive-off` — the plugin is off; only reachable through `forMode`.
+ */
+export const SCHEDULER_DEFER_REASONS = [
+    "routing-defer",
+    "pin-unverifiable",
+    "pin-incompatible",
+    "escalation-not-justified",
+    "escalation-budget-exhausted",
+    "escalation-ceiling",
+    "escalation-no-candidate",
+    "adaptive-off",
+];
+/**
+ * Why work parks instead of applying: the required tier has no usable
+ * resource right now. Parking waits for recovery — it never borrows across
+ * tiers (ADP-022).
+ */
+export const PARK_REASONS = [
+    "pin-blocked",
+    "no-candidates",
+    "no-compatible-resource",
+    "all-blocked",
+];
+/** Why a tier candidate was not usable. Superset of gate and health reasons. */
+export const SKIP_REASONS = [
+    "not-in-inventory",
+    "capacity-exhausted",
+    "incompatible",
+    ...INCOMPATIBILITY_REASONS,
+    ...BLOCKED_REASONS,
+];
+/** Structured capability evidence for escalation (ADP-015). Never prose mining. */
+export const ESCALATION_EVIDENCE_KINDS = [
+    "agent-request",
+    "reviewer-rejection",
+    "verification-failure",
+    "repeated-failure",
+    "explicit-blocker",
+];
+export const ESCALATION_STEPS = ["variant", "tier"];
+/** Bound on evidence carried by an `escalate` decision (latest wins). */
+export const MAX_ESCALATION_EVIDENCE = 4;
+/** Bound on the `skipped` evidence list of an `apply` decision. */
+export const MAX_EVIDENCE_SKIPPED = 8;
+/** Canonical health/capacity map key for a candidate model reference. */
+export function schedulerHealthKey(ref) {
+    return resourceKeyID(ref.variant === undefined
+        ? { providerID: ref.providerID, modelID: ref.id }
+        : { providerID: ref.providerID, modelID: ref.id, variantID: ref.variant });
+}
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/scheduler/types.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AAEnE,+EAA+E;AAC/E,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAsC,CAAA;AAIhG,oEAAoE;AACpE,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,KAAK;IACL,WAAW;IACX,UAAU;IACV,OAAO;IACP,UAAU;CAC0B,CAAA;AAItC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,0BAA0B;IAC1B,6BAA6B;IAC7B,oBAAoB;IACpB,yBAAyB;IACzB,cAAc;CACsB,CAAA;AAItC;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,aAAa;IACb,eAAe;IACf,wBAAwB;IACxB,aAAa;CACuB,CAAA;AAItC,gFAAgF;AAChF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,kBAAkB;IAClB,oBAAoB;IACpB,cAAc;IACd,GAAG,uBAAuB;IAC1B,GAAG,eAAe;CACkB,CAAA;AAuCtC,mFAAmF;AACnF,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,eAAe;IACf,oBAAoB;IACpB,sBAAsB;IACtB,kBAAkB;IAClB,kBAAkB;CACkB,CAAA;AAStC,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,CAAsC,CAAA;AAUxF,yEAAyE;AACzE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAA;AAyDxC,mEAAmE;AACnE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAA;AAErC,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,GAAa;IAC9C,OAAO,aAAa,CAClB,GAAG,CAAC,OAAO,KAAK,SAAS;QACvB,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,EAAE;QACjD,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,OAAO,EAAE,CAC5E,CAAA;AACH,CAAC"}

package/dist/core/tier-policy/index.d.ts

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

package/dist/core/tier-policy/index.d.ts.map

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

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

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

package/dist/core/tier-policy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/tier-policy/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA"}

package/dist/core/tier-policy/resolve.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Routing priority ladder (ADP-002):
+ *
+ *   explicit user/model pin
+ *   → explicit tier request
+ *   → supported agent role hint
+ *   → deterministic local request evidence (auxiliary kinds)
+ *   → default `standard`
+ *
+ * Ambiguity within a level resolves to `standard`. An explicit signal whose
+ * tier has no configured resources is NOT silently downgraded to another
+ * tier (that would borrow across tiers — GOAL tenet 4): the router defers
+ * instead (ADP-003), keeping OpenCode's model choice. No LLM call and no
+ * keyword classifier participates (ADP-004) — every input is a structured
+ * field.
+ */
+import { type RoutingDecision, type RoutingInput } from "./types.js";
+export declare function resolveRouting(input: RoutingInput): RoutingDecision;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/core/tier-policy/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/core/tier-policy/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAIL,KAAK,eAAe,EACpB,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAA;AAEnB,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAiCnE"}

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

@@ -0,0 +1,52 @@
+/**
+ * Routing priority ladder (ADP-002):
+ *
+ *   explicit user/model pin
+ *   → explicit tier request
+ *   → supported agent role hint
+ *   → deterministic local request evidence (auxiliary kinds)
+ *   → default `standard`
+ *
+ * Ambiguity within a level resolves to `standard`. An explicit signal whose
+ * tier has no configured resources is NOT silently downgraded to another
+ * tier (that would borrow across tiers — GOAL tenet 4): the router defers
+ * instead (ADP-003), keeping OpenCode's model choice. No LLM call and no
+ * keyword classifier participates (ADP-004) — every input is a structured
+ * field.
+ */
+import { AUXILIARY_TIER, DEFAULT_TIER, isAuxiliary, } from "./types.js";
+export function resolveRouting(input) {
+    if (input.pin !== undefined) {
+        return { kind: "pin", model: input.pin };
+    }
+    if (input.tierRequest !== undefined) {
+        return byConfiguration(input.tierRequest.tier, "tier-request", input.configuredTiers);
+    }
+    // Role level: an agent-name hint from user policy and deterministic
+    // auxiliary-request evidence. Conflict inside the level is ambiguity
+    // (ADP-002) and resolves to `standard`; agreement keeps the tier.
+    const agentTier = input.agent !== undefined &&
+        input.agent.length > 0 &&
+        input.agentTiers !== undefined &&
+        Object.hasOwn(input.agentTiers, input.agent)
+        ? input.agentTiers[input.agent]
+        : undefined;
+    const auxiliaryTier = input.requestKind !== undefined && isAuxiliary(input.requestKind) ? AUXILIARY_TIER : undefined;
+    if (agentTier !== undefined && auxiliaryTier !== undefined && agentTier !== auxiliaryTier) {
+        return byConfiguration(DEFAULT_TIER, "ambiguity", input.configuredTiers);
+    }
+    if (agentTier !== undefined) {
+        return byConfiguration(agentTier, "agent-role", input.configuredTiers);
+    }
+    if (auxiliaryTier !== undefined) {
+        return byConfiguration(auxiliaryTier, "auxiliary-request", input.configuredTiers);
+    }
+    return byConfiguration(DEFAULT_TIER, "default", input.configuredTiers);
+}
+function byConfiguration(tier, source, configuredTiers) {
+    if (!configuredTiers.includes(tier)) {
+        return { kind: "defer", tier, reason: "tier-not-configured" };
+    }
+    return { kind: "tier", tier, source };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/core/tier-policy/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../../src/core/tier-policy/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,cAAc,EACd,YAAY,EACZ,WAAW,GAKZ,MAAM,YAAY,CAAA;AAEnB,MAAM,UAAU,cAAc,CAAC,KAAmB;IAChD,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAA;IAC1C,CAAC;IAED,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACpC,OAAO,eAAe,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACvF,CAAC;IAED,oEAAoE;IACpE,qEAAqE;IACrE,kEAAkE;IAClE,MAAM,SAAS,GACb,KAAK,CAAC,KAAK,KAAK,SAAS;QACzB,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;QACtB,KAAK,CAAC,UAAU,KAAK,SAAS;QAC9B,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;QAC1C,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC;QAC/B,CAAC,CAAC,SAAS,CAAA;IACf,MAAM,aAAa,GACjB,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAA;IAEhG,IAAI,SAAS,KAAK,SAAS,IAAI,aAAa,KAAK,SAAS,IAAI,SAAS,KAAK,aAAa,EAAE,CAAC;QAC1F,OAAO,eAAe,CAAC,YAAY,EAAE,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IAC1E,CAAC;IACD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACxE,CAAC;IACD,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,eAAe,CAAC,aAAa,EAAE,mBAAmB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACnF,CAAC;IAED,OAAO,eAAe,CAAC,YAAY,EAAE,SAAS,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;AACxE,CAAC;AAED,SAAS,eAAe,CACtB,IAAc,EACd,MAAqB,EACrB,eAAoC;IAEpC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAA;IAC/D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;AACvC,CAAC"}

package/dist/core/tier-policy/tier-list.d.ts

@@ -0,0 +1,11 @@
+/**
+ * User-configured tier lists (ADP-005): each tier is an ordered list of
+ * resources; list order is user policy and is never reordered by Adaptive.
+ * Normalization only removes unusable entries and exact duplicates — it
+ * never reorders and never merges look-alike names (ADP-006: similar model
+ * names across providers are never equivalent unless the user configures
+ * both, and full-reference equality below is deliberately provider-scoped).
+ */
+import { type ModelRef } from "../work-unit/types.js";
+export declare function normalizeTierList(resources: readonly ModelRef[]): ModelRef[];
+//# sourceMappingURL=tier-list.d.ts.map

package/dist/core/tier-policy/tier-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-list.d.ts","sourceRoot":"","sources":["../../../src/core/tier-policy/tier-list.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAEnE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAY5E"}

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

@@ -0,0 +1,23 @@
+/**
+ * User-configured tier lists (ADP-005): each tier is an ordered list of
+ * resources; list order is user policy and is never reordered by Adaptive.
+ * Normalization only removes unusable entries and exact duplicates — it
+ * never reorders and never merges look-alike names (ADP-006: similar model
+ * names across providers are never equivalent unless the user configures
+ * both, and full-reference equality below is deliberately provider-scoped).
+ */
+import { sameModelRef } from "../work-unit/types.js";
+export function normalizeTierList(resources) {
+    const kept = [];
+    for (const resource of resources) {
+        if (resource.providerID.length === 0 || resource.id.length === 0) {
+            continue;
+        }
+        if (kept.some((existing) => sameModelRef(existing, resource))) {
+            continue;
+        }
+        kept.push(resource);
+    }
+    return kept;
+}
+//# sourceMappingURL=tier-list.js.map

package/dist/core/tier-policy/tier-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-list.js","sourceRoot":"","sources":["../../../src/core/tier-policy/tier-list.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAiB,MAAM,uBAAuB,CAAA;AAEnE,MAAM,UAAU,iBAAiB,CAAC,SAA8B;IAC9D,MAAM,IAAI,GAAe,EAAE,CAAA;IAC3B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjE,SAAQ;QACV,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC9D,SAAQ;QACV,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACrB,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/core/tier-policy/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Tier-policy types (ADP-002..006). Tier names are an ecosystem proposal —
+ * OpenCode has no native capability-tier API — so every tier semantic lives
+ * in this module and nowhere else.
+ */
+import type { ModelRef } from "../work-unit/types.js";
+export declare const TIERS: readonly ["quick", "standard", "advanced"];
+export type TierName = (typeof TIERS)[number];
+/**
+ * Request kinds the OpenCode `context` hook exposes for the executing
+ * request. Auxiliary kinds are trivial host-internal requests (title,
+ * compaction, generate) that must not consume an unnecessarily expensive
+ * tier — this is structured host evidence, not prompt keyword matching
+ * (ADP-004).
+ */
+export declare const AUXILIARY_KINDS: readonly ["compaction", "title", "generate"];
+export type AuxiliaryKind = (typeof AUXILIARY_KINDS)[number];
+export type RequestKind = "primary" | AuxiliaryKind;
+/** Auxiliary requests route to `quick`. */
+export declare const AUXILIARY_TIER: TierName;
+/** Unambiguous fallback tier (ADP-002). */
+export declare const DEFAULT_TIER: TierName;
+/** How an explicit tier request reached the plugin (provenance for receipts). */
+export declare const TIER_REQUEST_VIAS: readonly ["manual-command", "session-setting"];
+export type TierRequestVia = (typeof TIER_REQUEST_VIAS)[number];
+export interface TierRequest {
+    readonly tier: TierName;
+    readonly via: TierRequestVia;
+}
+/**
+ * Everything the ladder may look at, all optional except the configuration
+ * view. Every signal is a structured field supplied by the adapter — never
+ * text mined from a prompt.
+ */
+export interface RoutingInput {
+    /** Explicit user/model pin (manual control); always wins (ADP-002). */
+    readonly pin?: ModelRef | undefined;
+    /** Explicit tier request (manual command or session setting). */
+    readonly tierRequest?: TierRequest | undefined;
+    /** OpenCode agent name of the executing request, when the host supplies one. */
+    readonly agent?: string | undefined;
+    /** Request kind from the `context` hook, when known. */
+    readonly requestKind?: RequestKind | undefined;
+    /** User-configured agent-name → tier mapping (role hints are user policy). */
+    readonly agentTiers?: Readonly<Record<string, TierName>> | undefined;
+    /**
+     * Tiers that currently have at least one configured resource (ADP-005).
+     * A tier without resources can never be honored — Adaptive does not
+     * invent resources and never borrows across tiers (GOAL tenet 4).
+     */
+    readonly configuredTiers: readonly TierName[];
+}
+/** Why the ladder produced a tier decision (receipt provenance). */
+export declare const ROUTING_SOURCES: readonly ["pin", "tier-request", "agent-role", "auxiliary-request", "ambiguity", "default"];
+export type RoutingSource = (typeof ROUTING_SOURCES)[number];
+export declare const DEFER_REASONS: readonly ["tier-not-configured"];
+export type DeferReason = (typeof DEFER_REASONS)[number];
+/**
+ * Routing outcome (ADP-002/003):
+ * - `pin` — route to the pinned resource.
+ * - `tier` — route within the named tier.
+ * - `defer` — Adaptive has no reason to override ordinary OpenCode behavior;
+ *   the unit keeps OpenCode's model choice. `tier` records which tier the
+ *   ladder resolved to before the configuration gate blocked it.
+ */
+export type RoutingDecision = {
+    readonly kind: "pin";
+    readonly model: ModelRef;
+} | {
+    readonly kind: "tier";
+    readonly tier: TierName;
+    readonly source: RoutingSource;
+} | {
+    readonly kind: "defer";
+    readonly tier: TierName;
+    readonly reason: DeferReason;
+};
+/** True only for the trivial auxiliary request kinds. */
+export declare function isAuxiliary(kind: RequestKind): boolean;
+/**
+ * Escalation ladder order (GOAL capability escalation): `quick` → `standard`
+ * → `advanced`. `advanced` is the last tier — there is no next.
+ */
+export declare function nextTier(tier: TierName): TierName | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/tier-policy/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/tier-policy/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAErD,eAAO,MAAM,KAAK,4CAAyE,CAAA;AAE3F,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAA;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,8CAIU,CAAA;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAE5D,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,aAAa,CAAA;AAEnD,2CAA2C;AAC3C,eAAO,MAAM,cAAc,EAAE,QAAkB,CAAA;AAE/C,2CAA2C;AAC3C,eAAO,MAAM,YAAY,EAAE,QAAqB,CAAA;AAEhD,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,gDAGQ,CAAA;AAEtC,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAA;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACnC,iEAAiE;IACjE,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;IAC9C,gFAAgF;IAChF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,wDAAwD;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;IAC9C,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAA;IACpE;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,QAAQ,EAAE,CAAA;CAC9C;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,6FAOU,CAAA;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAE5D,eAAO,MAAM,aAAa,kCAA+D,CAAA;AAEzF,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAClF;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAA;AAErF,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEtD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAG7D"}