@coool/opencode-adaptive 0.0.0-stage → 1.0.1

package/dist/core/scheduler/admit.js

@@ -0,0 +1,154 @@
+/**
+ * Admission routing (ADP-013/016/022): pick the model for a fresh work unit,
+ * or decide to defer (OpenCode's choice stands) or park (wait for recovery).
+ *
+ * Selection, after the compatibility gate (ADP-017) filters candidates: the
+ * first candidate in user order that is ready or due for its half-open probe
+ * wins; draining only when none is. Rationale: a due probe at a preferred
+ * position is how that resource returns (ADP-018/019) — passing it over for a
+ * later ready sibling would keep it out forever; a draining resource is being
+ * retired, so depending on it is the last resort. Breaker single-flight is
+ * enforced by the resource-health registry, not here.
+ */
+import { checkCompatibility } from "../compatibility/gate.js";
+import { sameModelRef } from "../work-unit/types.js";
+import { MAX_EVIDENCE_SKIPPED, schedulerHealthKey } from "./types.js";
+function refOfCandidate(candidate) {
+    return {
+        providerID: candidate.providerID,
+        id: candidate.modelID,
+        variant: candidate.variant,
+    };
+}
+function lookup(inventory, ref) {
+    return inventory.find((candidate) => sameModelRef(refOfCandidate(candidate), ref));
+}
+function classify(assessment, signals) {
+    if (signals?.exhausted === true) {
+        return { kind: "skip", why: "capacity-exhausted" };
+    }
+    if (assessment === undefined) {
+        return signals?.draining === true ? { kind: "draining" } : { kind: "ready" };
+    }
+    if (assessment.kind === "probe") {
+        return { kind: "probe", probeId: assessment.ticket.id };
+    }
+    if (assessment.kind === "available") {
+        return signals?.draining === true ? { kind: "draining" } : { kind: "ready" };
+    }
+    return assessment.reason === "draining"
+        ? { kind: "draining" }
+        : { kind: "skip", why: assessment.reason };
+}
+function apply(model, tier, reason, skipped, probeId) {
+    return {
+        kind: "apply",
+        model,
+        ...(tier === undefined ? {} : { tier }),
+        reason,
+        evidence: {
+            skipped: skipped.slice(0, MAX_EVIDENCE_SKIPPED),
+            ...(probeId === undefined ? {} : { probeId }),
+        },
+    };
+}
+function admitPin(input, pin) {
+    const entry = lookup(input.inventory, pin);
+    if (entry === undefined) {
+        return { kind: "defer", reason: "pin-unverifiable" };
+    }
+    const verdict = checkCompatibility(entry, input.demand);
+    if (!verdict.compatible) {
+        return { kind: "defer", reason: "pin-incompatible", detail: verdict.reasons.join(",") };
+    }
+    const key = schedulerHealthKey(pin);
+    const bucket = classify(input.health[key], input.capacity[key]);
+    if (bucket.kind === "skip") {
+        return { kind: "park", reason: "pin-blocked", detail: bucket.why };
+    }
+    // Manual intent wins (GOAL): a pinned model is applied even while draining;
+    // a probe admission is recorded for observability but never overrides intent.
+    return apply(pin, undefined, "pin", [], bucket.kind === "probe" ? bucket.probeId : undefined);
+}
+function admitTier(input, tier) {
+    if (input.tierCandidates.length === 0) {
+        // The tier was reported configured but has an empty list — a configuration
+        // discrepancy; park rather than invent resources (ADP-005).
+        return { kind: "park", reason: "no-candidates" };
+    }
+    // Candidates passed over before the winner (or all of them, when none won).
+    const seen = [];
+    let gateSkipped = 0;
+    const skipWhys = [];
+    let chosen;
+    for (const ref of input.tierCandidates) {
+        const entry = lookup(input.inventory, ref);
+        if (entry === undefined) {
+            seen.push({ ref, bucket: { kind: "skip", why: "not-in-inventory" } });
+            skipWhys.push("not-in-inventory");
+            gateSkipped += 1;
+            continue;
+        }
+        const verdict = checkCompatibility(entry, input.demand);
+        if (!verdict.compatible) {
+            // The gate reports incompatible only when at least one reason exists; the
+            // non-null assertion is the only way to express that invariant locally.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const why = verdict.reasons[0];
+            seen.push({ ref, bucket: { kind: "skip", why } });
+            skipWhys.push(why);
+            gateSkipped += 1;
+            continue;
+        }
+        const key = schedulerHealthKey(ref);
+        const bucket = classify(input.health[key], input.capacity[key]);
+        if (bucket.kind === "ready" || bucket.kind === "probe") {
+            // The first ready or probe candidate wins; later candidates are
+            // irrelevant, so the scan stops and the evidence stays an honest prefix
+            // of the user order.
+            chosen = { ref, bucket };
+            break;
+        }
+        seen.push({ ref, bucket });
+        if (bucket.kind === "skip") {
+            skipWhys.push(bucket.why);
+        }
+    }
+    const first = input.tierCandidates[0];
+    const evidenceBefore = (until) => seen.slice(0, until).map((e) => ({
+        ref: e.ref,
+        why: e.bucket.kind === "skip" ? e.bucket.why : "draining",
+    }));
+    if (chosen?.bucket.kind === "probe") {
+        return apply(chosen.ref, tier, "probe", evidenceBefore(seen.length), chosen.bucket.probeId);
+    }
+    if (chosen !== undefined) {
+        return apply(chosen.ref, tier, first !== undefined && sameModelRef(chosen.ref, first) ? "preferred" : "fallback", evidenceBefore(seen.length), undefined);
+    }
+    const drainIndex = seen.findIndex((e) => e.bucket.kind === "draining");
+    const drainEntry = drainIndex >= 0 ? seen[drainIndex] : undefined;
+    if (drainEntry !== undefined) {
+        return apply(drainEntry.ref, tier, "draining", evidenceBefore(drainIndex), undefined);
+    }
+    const summary = skipWhys.slice(0, 3).join(",");
+    return {
+        kind: "park",
+        reason: gateSkipped === skipWhys.length ? "no-compatible-resource" : "all-blocked",
+        detail: summary,
+    };
+}
+/**
+ * Decide the model for a fresh work unit. Total and deterministic: the same
+ * input always yields the same decision, and the function has no effects.
+ */
+export function admit(input) {
+    const routing = input.routing;
+    if (routing.kind === "defer") {
+        return { kind: "defer", reason: "routing-defer", detail: routing.reason };
+    }
+    if (routing.kind === "pin") {
+        return admitPin(input, routing.model);
+    }
+    return admitTier(input, routing.tier);
+}
+//# sourceMappingURL=admit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"admit.js","sourceRoot":"","sources":["../../../src/core/scheduler/admit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Admission routing (ADP-013/016/022): pick the model for a fresh work unit,\n * or decide to defer (OpenCode's choice stands) or park (wait for recovery).\n *\n * Selection, after the compatibility gate (ADP-017) filters candidates: the\n * first candidate in user order that is ready or due for its half-open probe\n * wins; draining only when none is. Rationale: a due probe at a preferred\n * position is how that resource returns (ADP-018/019) — passing it over for a\n * later ready sibling would keep it out forever; a draining resource is being\n * retired, so depending on it is the last resort. Breaker single-flight is\n * enforced by the resource-health registry, not here.\n */\nimport { checkCompatibility } from \"../compatibility/gate.js\"\nimport type { CandidateModel } from \"../compatibility/types.js\"\nimport type { RoutingDecision, TierName } from \"../tier-policy/types.js\"\nimport { sameModelRef, type ModelRef } from \"../work-unit/types.js\"\nimport type { Assessment } from \"../../health/resource-health/types.js\"\nimport type { CapacitySignals } from \"../../health/capacity/types.js\"\nimport type {\n  AdmissionDecision,\n  ApplyDecision,\n  ApplyReason,\n  SchedulerInput,\n  SkippedCandidate,\n  SkipReason,\n} from \"./types.js\"\nimport { MAX_EVIDENCE_SKIPPED, schedulerHealthKey } from \"./types.js\"\n\n/** The health/capacity view of one candidate, resolved to an admission bucket. */\ntype Bucket =\n  | { readonly kind: \"ready\" }\n  | { readonly kind: \"probe\"; readonly probeId: string }\n  | { readonly kind: \"draining\" }\n  | { readonly kind: \"skip\"; readonly why: SkipReason }\n\nfunction refOfCandidate(candidate: CandidateModel): ModelRef {\n  return {\n    providerID: candidate.providerID,\n    id: candidate.modelID,\n    variant: candidate.variant,\n  }\n}\n\nfunction lookup(inventory: readonly CandidateModel[], ref: ModelRef): CandidateModel | undefined {\n  return inventory.find((candidate) => sameModelRef(refOfCandidate(candidate), ref))\n}\n\nfunction classify(\n  assessment: Assessment | undefined,\n  signals: CapacitySignals | undefined,\n): Bucket {\n  if (signals?.exhausted === true) {\n    return { kind: \"skip\", why: \"capacity-exhausted\" }\n  }\n  if (assessment === undefined) {\n    return signals?.draining === true ? { kind: \"draining\" } : { kind: \"ready\" }\n  }\n  if (assessment.kind === \"probe\") {\n    return { kind: \"probe\", probeId: assessment.ticket.id }\n  }\n  if (assessment.kind === \"available\") {\n    return signals?.draining === true ? { kind: \"draining\" } : { kind: \"ready\" }\n  }\n  return assessment.reason === \"draining\"\n    ? { kind: \"draining\" }\n    : { kind: \"skip\", why: assessment.reason }\n}\n\nfunction apply(\n  model: ModelRef,\n  tier: TierName | undefined,\n  reason: ApplyReason,\n  skipped: readonly SkippedCandidate[],\n  probeId: string | undefined,\n): ApplyDecision {\n  return {\n    kind: \"apply\",\n    model,\n    ...(tier === undefined ? {} : { tier }),\n    reason,\n    evidence: {\n      skipped: skipped.slice(0, MAX_EVIDENCE_SKIPPED),\n      ...(probeId === undefined ? {} : { probeId }),\n    },\n  }\n}\n\nfunction admitPin(input: SchedulerInput, pin: ModelRef): AdmissionDecision {\n  const entry = lookup(input.inventory, pin)\n  if (entry === undefined) {\n    return { kind: \"defer\", reason: \"pin-unverifiable\" }\n  }\n  const verdict = checkCompatibility(entry, input.demand)\n  if (!verdict.compatible) {\n    return { kind: \"defer\", reason: \"pin-incompatible\", detail: verdict.reasons.join(\",\") }\n  }\n  const key = schedulerHealthKey(pin)\n  const bucket = classify(input.health[key], input.capacity[key])\n  if (bucket.kind === \"skip\") {\n    return { kind: \"park\", reason: \"pin-blocked\", detail: bucket.why }\n  }\n  // Manual intent wins (GOAL): a pinned model is applied even while draining;\n  // a probe admission is recorded for observability but never overrides intent.\n  return apply(pin, undefined, \"pin\", [], bucket.kind === \"probe\" ? bucket.probeId : undefined)\n}\n\nfunction admitTier(input: SchedulerInput, tier: TierName): AdmissionDecision {\n  if (input.tierCandidates.length === 0) {\n    // The tier was reported configured but has an empty list — a configuration\n    // discrepancy; park rather than invent resources (ADP-005).\n    return { kind: \"park\", reason: \"no-candidates\" }\n  }\n  // Candidates passed over before the winner (or all of them, when none won).\n  const seen: { ref: ModelRef; bucket: Extract<Bucket, { kind: \"draining\" | \"skip\" }> }[] = []\n  let gateSkipped = 0\n  const skipWhys: string[] = []\n  let chosen: { ref: ModelRef; bucket: Extract<Bucket, { kind: \"ready\" | \"probe\" }> } | undefined\n  for (const ref of input.tierCandidates) {\n    const entry = lookup(input.inventory, ref)\n    if (entry === undefined) {\n      seen.push({ ref, bucket: { kind: \"skip\", why: \"not-in-inventory\" } })\n      skipWhys.push(\"not-in-inventory\")\n      gateSkipped += 1\n      continue\n    }\n    const verdict = checkCompatibility(entry, input.demand)\n    if (!verdict.compatible) {\n      // The gate reports incompatible only when at least one reason exists; the\n      // non-null assertion is the only way to express that invariant locally.\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const why = verdict.reasons[0]!\n      seen.push({ ref, bucket: { kind: \"skip\", why } })\n      skipWhys.push(why)\n      gateSkipped += 1\n      continue\n    }\n    const key = schedulerHealthKey(ref)\n    const bucket = classify(input.health[key], input.capacity[key])\n    if (bucket.kind === \"ready\" || bucket.kind === \"probe\") {\n      // The first ready or probe candidate wins; later candidates are\n      // irrelevant, so the scan stops and the evidence stays an honest prefix\n      // of the user order.\n      chosen = { ref, bucket }\n      break\n    }\n    seen.push({ ref, bucket })\n    if (bucket.kind === \"skip\") {\n      skipWhys.push(bucket.why)\n    }\n  }\n  const first = input.tierCandidates[0]\n  const evidenceBefore = (until: number): SkippedCandidate[] =>\n    seen.slice(0, until).map((e): SkippedCandidate => ({\n      ref: e.ref,\n      why: e.bucket.kind === \"skip\" ? e.bucket.why : \"draining\",\n    }))\n  if (chosen?.bucket.kind === \"probe\") {\n    return apply(chosen.ref, tier, \"probe\", evidenceBefore(seen.length), chosen.bucket.probeId)\n  }\n  if (chosen !== undefined) {\n    return apply(\n      chosen.ref,\n      tier,\n      first !== undefined && sameModelRef(chosen.ref, first) ? \"preferred\" : \"fallback\",\n      evidenceBefore(seen.length),\n      undefined,\n    )\n  }\n  const drainIndex = seen.findIndex((e) => e.bucket.kind === \"draining\")\n  const drainEntry = drainIndex >= 0 ? seen[drainIndex] : undefined\n  if (drainEntry !== undefined) {\n    return apply(drainEntry.ref, tier, \"draining\", evidenceBefore(drainIndex), undefined)\n  }\n  const summary = skipWhys.slice(0, 3).join(\",\")\n  return {\n    kind: \"park\",\n    reason: gateSkipped === skipWhys.length ? \"no-compatible-resource\" : \"all-blocked\",\n    detail: summary,\n  }\n}\n\n/**\n * Decide the model for a fresh work unit. Total and deterministic: the same\n * input always yields the same decision, and the function has no effects.\n */\nexport function admit(input: SchedulerInput): AdmissionDecision {\n  const routing: RoutingDecision = input.routing\n  if (routing.kind === \"defer\") {\n    return { kind: \"defer\", reason: \"routing-defer\", detail: routing.reason }\n  }\n  if (routing.kind === \"pin\") {\n    return admitPin(input, routing.model)\n  }\n  return admitTier(input, routing.tier)\n}\n"]}

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

@@ -0,0 +1,6 @@
+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;

package/dist/core/scheduler/escalate.js

@@ -0,0 +1,45 @@
+/**
+ * Capability escalation planner (ADP-015).
+ *
+ * Escalation is justified only by non-empty structured evidence, follows the
+ * ladder next tier, and is bounded by the caller's finite budget. The
+ * same-model stronger-variant rung is not implemented: it would need an
+ * ordered variant ladder the host does not expose, and strength is never
+ * guessed from variant names. Every output moves strictly up the ladder or
+ * refuses. Termination rests on the budget, which the caller must carry
+ * across every unit of one task (each escalation continues on a new unit).
+ */
+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 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;;;;;;;;;;GAUG;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,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","sourcesContent":["/**\n * Capability escalation planner (ADP-015).\n *\n * Escalation is justified only by non-empty structured evidence, follows the\n * ladder next tier, and is bounded by the caller's finite budget. The\n * same-model stronger-variant rung is not implemented: it would need an\n * ordered variant ladder the host does not expose, and strength is never\n * guessed from variant names. Every output moves strictly up the ladder or\n * refuses. Termination rests on the budget, which the caller must carry\n * across every unit of one task (each escalation continues on a new unit).\n */\nimport { nextTier } from \"../tier-policy/types.js\"\nimport type { ModelRef } from \"../work-unit/types.js\"\nimport type { DeferDecision, EscalateDecision, EscalationInput } from \"./types.js\"\nimport { MAX_ESCALATION_EVIDENCE } from \"./types.js\"\n\nfunction escalate(\n  input: EscalationInput,\n  target: ModelRef,\n  step: EscalateDecision[\"step\"],\n  tier: EscalateDecision[\"tier\"],\n): EscalateDecision {\n  return {\n    kind: \"escalate\",\n    target,\n    step,\n    tier,\n    evidence: input.evidence.slice(-MAX_ESCALATION_EVIDENCE),\n    budgetRemaining: input.budget.max - input.budget.used - 1,\n  }\n}\n\n/**\n * Plan the next escalation step, or defer with the reason escalation cannot\n * proceed. Total and deterministic.\n */\nexport function planEscalation(input: EscalationInput): EscalateDecision | DeferDecision {\n  if (input.evidence.length === 0) {\n    return { kind: \"defer\", reason: \"escalation-not-justified\" }\n  }\n  if (input.budget.max <= 0 || input.budget.used >= input.budget.max) {\n    return { kind: \"defer\", reason: \"escalation-budget-exhausted\" }\n  }\n  const next = nextTier(input.currentTier)\n  if (next === undefined) {\n    return { kind: \"defer\", reason: \"escalation-ceiling\" }\n  }\n  const target = input.nextTierResources[0]\n  if (target === undefined) {\n    return { kind: \"defer\", reason: \"escalation-no-candidate\" }\n  }\n  return escalate(input, target, \"tier\", next)\n}\n"]}

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

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./admit.js";
+export * from "./escalate.js";
+export * from "./mode.js";

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","sourcesContent":["export * from \"./types.js\"\nexport * from \"./admit.js\"\nexport * from \"./escalate.js\"\nexport * from \"./mode.js\"\n"]}

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

@@ -0,0 +1,8 @@
+/**
+ * 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;

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","sourcesContent":["/**\n * Operating-mode wrapper (GOAL operating modes). OBSERVE and CONTROL run the\n * identical core; OBSERVE wraps the result without applying it. OFF never\n * reaches the scheduler, but the total wrapper maps it to an explicit defer\n * so the union stays closed.\n */\nimport type { Decision, OperatingMode } from \"./types.js\"\n\nexport function forMode(decision: Decision, mode: OperatingMode): Decision {\n  if (mode === \"observe\") {\n    return { kind: \"observe-only\", would: decision }\n  }\n  if (mode === \"active\") {\n    return decision\n  }\n  return { kind: \"defer\", reason: \"adaptive-off\" }\n}\n"]}

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

@@ -0,0 +1,136 @@
+/**
+ * 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", "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;
+    /** 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 escalated-to resource (the next tier). */
+    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;

package/dist/core/scheduler/types.js

@@ -0,0 +1,75 @@
+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",
+    ...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",
+];
+// Persisted receipt vocabulary. The planner produces only "tier" today; the
+// historical "variant" step stays parseable so old receipts are not dropped.
+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,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,4EAA4E;AAC5E,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,CAAsC,CAAA;AAUxF,yEAAyE;AACzE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAA;AAmDxC,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","sourcesContent":["/**\n * Scheduler types (ADP-013/015/016/022): the pure decision core's vocabulary.\n *\n * The core is a total function over its inputs — routing outcome, demand,\n * inventory, per-candidate health and capacity views — and never performs\n * effects. Effects (switching, receipts, parking) belong to the execution\n * layer. OBSERVE and CONTROL call the same core; mode handling is a pure\n * wrapper (`forMode`).\n */\nimport type { ModelRef } from \"../work-unit/types.js\"\nimport type { RoutingDecision, TierName } from \"../tier-policy/types.js\"\nimport type { CandidateModel, Demand } from \"../compatibility/types.js\"\nimport type { Assessment } from \"../../health/resource-health/types.js\"\nimport type { CapacitySignals } from \"../../health/capacity/types.js\"\nimport { INCOMPATIBILITY_REASONS } from \"../compatibility/types.js\"\nimport { BLOCKED_REASONS } from \"../../health/resource-health/types.js\"\nimport { resourceKeyID } from \"../../health/resource-health/key.js\"\n\n/** Operating modes (GOAL manual control). The plugin defaults to `observe`. */\nexport const OPERATING_MODES = [\"off\", \"observe\", \"active\"] as const satisfies readonly string[]\n\nexport type OperatingMode = (typeof OPERATING_MODES)[number]\n\n/** Why an `apply` decision chose its model (receipt provenance). */\nexport const APPLY_REASONS = [\n  \"pin\",\n  \"preferred\",\n  \"fallback\",\n  \"probe\",\n  \"draining\",\n] as const satisfies readonly string[]\n\nexport type ApplyReason = (typeof APPLY_REASONS)[number]\n\n/**\n * Why the core did not apply anything.\n * - `routing-defer` — the tier ladder deferred; OpenCode's choice stands.\n * - `pin-unverifiable` — the pinned model is not in the host inventory, so\n *   availability cannot be verified (inventory gate); deferring keeps the\n *   user's own model choice, which for a pin is typically the pinned model.\n * - `pin-incompatible` — the pinned model cannot execute the work.\n * - `escalation-*` — escalation evidence was absent, the budget was spent,\n *   the tier ladder is at its ceiling, or the next tier has no resources\n *   (no cross-tier borrowing).\n * - `adaptive-off` — the plugin is off; only reachable through `forMode`.\n */\nexport const SCHEDULER_DEFER_REASONS = [\n  \"routing-defer\",\n  \"pin-unverifiable\",\n  \"pin-incompatible\",\n  \"escalation-not-justified\",\n  \"escalation-budget-exhausted\",\n  \"escalation-ceiling\",\n  \"escalation-no-candidate\",\n  \"adaptive-off\",\n] as const satisfies readonly string[]\n\nexport type SchedulerDeferReason = (typeof SCHEDULER_DEFER_REASONS)[number]\n\n/**\n * Why work parks instead of applying: the required tier has no usable\n * resource right now. Parking waits for recovery — it never borrows across\n * tiers (ADP-022).\n */\nexport const PARK_REASONS = [\n  \"pin-blocked\",\n  \"no-candidates\",\n  \"no-compatible-resource\",\n  \"all-blocked\",\n] as const satisfies readonly string[]\n\nexport type ParkReason = (typeof PARK_REASONS)[number]\n\n/** Why a tier candidate was not usable. Superset of gate and health reasons. */\nexport const SKIP_REASONS = [\n  \"not-in-inventory\",\n  \"capacity-exhausted\",\n  ...INCOMPATIBILITY_REASONS,\n  ...BLOCKED_REASONS,\n] as const satisfies readonly string[]\n\nexport type SkipReason = (typeof SKIP_REASONS)[number]\n\n/** A tier candidate that could not take the work, with the bounded reason. */\nexport interface SkippedCandidate {\n  readonly ref: ModelRef\n  readonly why: SkipReason\n}\n\n/** Bounded evidence attached to an `apply` decision. */\nexport interface ApplyEvidence {\n  /** Candidates considered before the applied one, in order (bounded). */\n  readonly skipped: readonly SkippedCandidate[]\n  /** Breaker probe id when the applied unit is the half-open probe. */\n  readonly probeId?: string | undefined\n}\n\nexport interface ApplyDecision {\n  readonly kind: \"apply\"\n  readonly model: ModelRef\n  /** Required tier; `undefined` for pin routing (a pin is not a tier). */\n  readonly tier?: TierName | undefined\n  readonly reason: ApplyReason\n  readonly evidence: ApplyEvidence\n}\n\nexport interface DeferDecision {\n  readonly kind: \"defer\"\n  readonly reason: SchedulerDeferReason\n  readonly detail?: string | undefined\n}\n\nexport interface ParkDecision {\n  readonly kind: \"park\"\n  readonly reason: ParkReason\n  readonly detail?: string | undefined\n}\n\n/** Structured capability evidence for escalation (ADP-015). Never prose mining. */\nexport const ESCALATION_EVIDENCE_KINDS = [\n  \"agent-request\",\n  \"reviewer-rejection\",\n  \"verification-failure\",\n  \"repeated-failure\",\n  \"explicit-blocker\",\n] as const satisfies readonly string[]\n\nexport type EscalationEvidenceKind = (typeof ESCALATION_EVIDENCE_KINDS)[number]\n\nexport interface EscalationEvidence {\n  readonly kind: EscalationEvidenceKind\n  readonly detail?: string | undefined\n}\n\n// Persisted receipt vocabulary. The planner produces only \"tier\" today; the\n// historical \"variant\" step stays parseable so old receipts are not dropped.\nexport const ESCALATION_STEPS = [\"variant\", \"tier\"] as const satisfies readonly string[]\n\nexport type EscalationStep = (typeof ESCALATION_STEPS)[number]\n\n/** Finite per-unit escalation budget (ADP-015). `used >= max` ends escalation. */\nexport interface EscalationBudget {\n  readonly used: number\n  readonly max: number\n}\n\n/** Bound on evidence carried by an `escalate` decision (latest wins). */\nexport const MAX_ESCALATION_EVIDENCE = 4\n\nexport interface EscalationInput {\n  readonly currentModel: ModelRef\n  readonly currentTier: TierName\n  /** Configured resources of the next tier, user order, already gated. */\n  readonly nextTierResources: readonly ModelRef[]\n  /** Non-empty structured evidence justifies escalation. */\n  readonly evidence: readonly EscalationEvidence[]\n  readonly budget: EscalationBudget\n}\n\nexport interface EscalateDecision {\n  readonly kind: \"escalate\"\n  readonly target: ModelRef\n  readonly step: EscalationStep\n  /** Tier of the escalated-to resource (the next tier). */\n  readonly tier: TierName\n  readonly evidence: readonly EscalationEvidence[]\n  readonly budgetRemaining: number\n}\n\n/** OBSERVE mode's wrapper: the identical decision, recorded but not applied. */\nexport interface ObserveOnlyDecision {\n  readonly kind: \"observe-only\"\n  readonly would: Decision\n}\n\nexport type Decision =\n  ApplyDecision | DeferDecision | ParkDecision | EscalateDecision | ObserveOnlyDecision\n\n/** What admission can return — escalation never originates from admission. */\nexport type AdmissionDecision = ApplyDecision | DeferDecision | ParkDecision\n\n/**\n * Everything admission looks at. `health` and `capacity` are keyed by\n * `schedulerHealthKey(ref)`; an absent health entry means \"no observed\n * failure\" (the registry's default), an absent capacity entry means \"no\n * estimate\" — unknown is never treated as exhausted.\n */\nexport interface SchedulerInput {\n  readonly routing: RoutingDecision\n  readonly demand: Demand\n  /** Host inventory (adapter-normalized). Candidates absent here are unverifiable. */\n  readonly inventory: readonly CandidateModel[]\n  /** Configured resources of the required tier, in user order (ADP-005). */\n  readonly tierCandidates: readonly ModelRef[]\n  readonly health: Readonly<Record<string, Assessment>>\n  readonly capacity: Readonly<Record<string, CapacitySignals>>\n}\n\n/** Bound on the `skipped` evidence list of an `apply` decision. */\nexport const MAX_EVIDENCE_SKIPPED = 8\n\n/** Canonical health/capacity map key for a candidate model reference. */\nexport function schedulerHealthKey(ref: ModelRef): string {\n  return resourceKeyID(\n    ref.variant === undefined\n      ? { providerID: ref.providerID, modelID: ref.id }\n      : { providerID: ref.providerID, modelID: ref.id, variantID: ref.variant },\n  )\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./resolve.js";
+export * from "./tier-list.js";

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","sourcesContent":["export * from \"./types.js\"\nexport * from \"./resolve.js\"\nexport * from \"./tier-list.js\"\n"]}

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

@@ -0,0 +1,18 @@
+/**
+ * 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;

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