@jmanuelcorral/openteam 0.15.1 → 0.16.1

package/dist/index.js

@@ -416,7 +416,8 @@ var LocalRuntimeSchema = z2.object({
   baseURL: z2.string().url().optional(),
   discovery: z2.enum(["cli", "sdk", "manual"]).optional(),
   defaultModel: ModelRefSchema,
-  maxConcurrency: z2.number().int().positive().optional()
+  maxConcurrency: z2.number().int().positive().optional(),
+  reservedInteractiveSlots: z2.number().int().nonnegative().optional()
 }).strict().superRefine((runtime, ctx) => {
   const resolvedKind = runtime.kind ?? runtime.id;
   if (!LocalRuntimeKindSchema.safeParse(resolvedKind).success) {
@@ -430,6 +431,15 @@ var LocalRuntimeSchema = z2.object({
 function localRuntimeKind(runtime) {
   return runtime.kind ?? runtime.id;
 }
+function effectiveMaxConcurrency(runtime) {
+  return runtime.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY;
+}
+function effectiveReservedInteractiveSlots(runtime) {
+  if (runtime.reservedInteractiveSlots !== undefined) {
+    return runtime.reservedInteractiveSlots;
+  }
+  return effectiveMaxConcurrency(runtime) >= 2 ? 1 : 0;
+}
 var MemoryScopeSchema = z2.enum(["project", "user"]);
 var MemoryExtractionModeSchema = z2.enum([
   "local",
@@ -2440,6 +2450,10 @@ function splitVirtualPath(path) {
 
 // src/cli/graphOperator.ts
 var ALLOWED_GATE = { allowed: true, violations: [] };
+var ALLOWED_EVALUATION = {
+  kind: "evaluated",
+  gate: ALLOWED_GATE
+};
 function journalRoot(config) {
   return config.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT;
 }
@@ -2529,7 +2543,7 @@ async function listWorktreeObservations(config, options) {
   })));
 }
 function createGraphOperator(options) {
-  const evaluateCutoverGate = options.evaluateCutoverGate ?? (async () => ALLOWED_GATE);
+  const evaluateCutoverGate = options.evaluateCutoverGate ?? (async () => ALLOWED_EVALUATION);
   const worktreeOptions = options.exec === undefined ? undefined : {
     exec: options.exec,
     repoRoot: options.repoRoot ?? process.cwd(),
@@ -2721,7 +2735,8 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
       "baseURL",
       "discovery",
       "defaultModel",
-      "maxConcurrency"
+      "maxConcurrency",
+      "reservedInteractiveSlots"
     ]
   ],
   ["local.runtimes[].defaultModel", MODEL_REF_KEYS],
@@ -4287,6 +4302,36 @@ var SUPPORTED_OPENCODE_VERSIONS = [
   "1.18.18",
   "1.18.19"
 ];
+var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)/;
+function parseSemver(version) {
+  const normalized = version.trim().replace(/^[=^~v]+/, "");
+  const match = SEMVER_RE.exec(normalized);
+  if (match === null) {
+    throw new Error(`invalid semver: "${version}"`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+}
+function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
+  if (certifiedVersion === liveVersion) {
+    return true;
+  }
+  let certified;
+  let live;
+  try {
+    certified = parseSemver(certifiedVersion);
+    live = parseSemver(liveVersion);
+  } catch {
+    return false;
+  }
+  if (certified.major !== live.major || certified.minor !== live.minor) {
+    return false;
+  }
+  return live.patch >= certified.patch;
+}
 
 // src/graph/soakLedger.ts
 import { z as z15 } from "zod";
@@ -4545,8 +4590,8 @@ function parseShadowCertificate(value, opencodeVersion) {
   if (sha256Hex(canonicalCertificate(unsigned)) !== digest) {
     throw new ShadowCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
   }
-  if (certificate.opencodeVersion !== opencodeVersion) {
-    throw new ShadowCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", expected "${opencodeVersion}"`);
+  if (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
+    throw new ShadowCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
   }
   return certificate;
 }
@@ -4730,8 +4775,8 @@ function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
   if (sha256Hex(canonicalReleaseCertificate(unsigned)) !== digest) {
     throw new ReleaseCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
   }
-  if (certificate.opencodeVersion !== opencodeVersion) {
-    throw new ReleaseCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", expected "${opencodeVersion}"`);
+  if (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
+    throw new ReleaseCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
   }
   return certificate;
 }
@@ -5061,50 +5106,106 @@ var realCacheAdapter = {
 };
 
 // src/local/concurrency.ts
+var PRIORITY_BANDS = [
+  "interactive",
+  "worker",
+  "background"
+];
 function createRuntimeConcurrencyLimiter(options) {
   const states = new Map;
   function stateFor(runtimeId) {
     let state = states.get(runtimeId);
     if (state === undefined) {
-      state = { active: 0, queue: [] };
+      state = {
+        active: 0,
+        nonInteractiveActive: 0,
+        queues: { interactive: [], worker: [], background: [] }
+      };
       states.set(runtimeId, state);
     }
     return state;
   }
-  function makeRelease(state) {
+  function reservedFor(runtimeId, capacity) {
+    const maxReserved = Math.max(0, capacity - 1);
+    const raw = options.reservedInteractiveFor?.(runtimeId);
+    if (raw === undefined || Number.isNaN(raw)) {
+      return 0;
+    }
+    const truncated = Math.trunc(raw);
+    if (truncated < 0) {
+      return 0;
+    }
+    return Math.min(truncated, maxReserved);
+  }
+  function limitsFor(runtimeId) {
+    const capacity = options.capacityFor(runtimeId);
+    const reserved = reservedFor(runtimeId, capacity);
+    return { capacity, nonInteractiveBudget: capacity - reserved };
+  }
+  function grantNext(state, runtimeId, nonInteractiveAfterRelease) {
+    const interactiveWaiter = state.queues.interactive.shift();
+    if (interactiveWaiter !== undefined) {
+      return { waiter: interactiveWaiter, nonInteractive: false };
+    }
+    const { nonInteractiveBudget } = limitsFor(runtimeId);
+    if (nonInteractiveAfterRelease < nonInteractiveBudget) {
+      const workerWaiter = state.queues.worker.shift();
+      if (workerWaiter !== undefined) {
+        return { waiter: workerWaiter, nonInteractive: true };
+      }
+      const backgroundWaiter = state.queues.background.shift();
+      if (backgroundWaiter !== undefined) {
+        return { waiter: backgroundWaiter, nonInteractive: true };
+      }
+    }
+    return;
+  }
+  function makeRelease(state, runtimeId, heldNonInteractive) {
     let released = false;
     return () => {
       if (released) {
         return;
       }
       released = true;
-      const next = state.queue.shift();
-      if (next !== undefined) {
-        next(makeRelease(state));
-      } else {
+      const nonInteractiveAfterRelease = state.nonInteractiveActive - (heldNonInteractive ? 1 : 0);
+      const next = grantNext(state, runtimeId, nonInteractiveAfterRelease);
+      if (next === undefined) {
         state.active -= 1;
+        state.nonInteractiveActive = nonInteractiveAfterRelease;
+        return;
       }
+      state.nonInteractiveActive = nonInteractiveAfterRelease + (next.nonInteractive ? 1 : 0);
+      next.waiter(makeRelease(state, runtimeId, next.nonInteractive));
     };
   }
-  function tryAcquire(runtimeId) {
+  function tryAcquire(runtimeId, priority = "worker") {
     const state = stateFor(runtimeId);
-    if (state.active < options.capacityFor(runtimeId)) {
+    const { capacity, nonInteractiveBudget } = limitsFor(runtimeId);
+    if (priority === "interactive") {
+      if (state.active < capacity) {
+        state.active += 1;
+        return makeRelease(state, runtimeId, false);
+      }
+      return;
+    }
+    if (state.active < capacity && state.nonInteractiveActive < nonInteractiveBudget) {
       state.active += 1;
-      return makeRelease(state);
+      state.nonInteractiveActive += 1;
+      return makeRelease(state, runtimeId, true);
     }
     return;
   }
   return {
     tryAcquire,
-    acquire(runtimeId) {
-      const immediate = tryAcquire(runtimeId);
+    acquire(runtimeId, priority = "worker") {
+      const immediate = tryAcquire(runtimeId, priority);
       if (immediate !== undefined) {
         return Promise.resolve({ release: immediate, waitedMs: 0 });
       }
       const state = stateFor(runtimeId);
       const queuedAt = options.now();
       return new Promise((resolve3) => {
-        state.queue.push((release) => {
+        state.queues[priority].push((release) => {
           resolve3({ release, waitedMs: options.now() - queuedAt });
         });
       });
@@ -5113,7 +5214,15 @@ function createRuntimeConcurrencyLimiter(options) {
       return states.get(runtimeId)?.active ?? 0;
     },
     queuedCount(runtimeId) {
-      return states.get(runtimeId)?.queue.length ?? 0;
+      const state = states.get(runtimeId);
+      if (state === undefined) {
+        return 0;
+      }
+      let total = 0;
+      for (const band of PRIORITY_BANDS) {
+        total += state.queues[band].length;
+      }
+      return total;
     }
   };
 }
@@ -6291,6 +6400,9 @@ function warnUnknownRole(roleID, warn, warnedRoles) {
 function roleFor(input) {
   return getRoleProfile(input.roleID, input.config.orchestrator?.roles) ?? synthesiseFallbackProfile(input.roleID);
 }
+function priorityForRole(role) {
+  return role.roleID === "scribe" ? "background" : "worker";
+}
 function mandatoryLocalRuntimeMessage(roleID) {
   return `openteam: role "${roleID}" requires a local runtime, but no local runtime is reachable. ` + `This role must run locally and will not fall back to a frontier provider. ` + `Start one of the supported local runtimes (Ollama, LM Studio, or Lemonade) and try again. ` + "Run `openteam doctor` to diagnose your local runtime configuration.";
 }
@@ -6654,10 +6766,11 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch) {
   let queueObservation;
   if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
     const limiter = deps.runtimeLimiter;
-    release = limiter.tryAcquire(runtimeId);
+    const priority = priorityForRole(role);
+    release = limiter.tryAcquire(runtimeId, priority);
     let waitedMs = 0;
     if (release === undefined) {
-      const acquisition = await limiter.acquire(runtimeId);
+      const acquisition = await limiter.acquire(runtimeId, priority);
       release = acquisition.release;
       waitedMs = acquisition.waitedMs;
     }
@@ -8265,7 +8378,7 @@ function legacyRosterFindings(audit) {
   }
   return findings;
 }
-function rosterHealthSection(audit, loadError, rosterRoleCount) {
+function rosterHealthSection(audit, loadError, rosterRoleCount, rosterMissing) {
   const auditFindings = audit?.findings ?? legacyRosterFindings(audit ?? {});
   const unparseable = auditFindings.find((finding) => finding.kind === "unparseable-roster");
   const unparseableMessage = loadError ?? unparseable?.message;
@@ -8278,6 +8391,14 @@ function rosterHealthSection(audit, loadError, rosterRoleCount) {
     ];
   }
   if (audit === undefined) {
+    if (rosterMissing === true) {
+      return [
+        "  roster health:",
+        `    ✗ ${OPENTEAM_ROSTER_PATH} does not exist — no team roster has been cast.`,
+        "      consequence: without a roster openteam cannot distribute work across roles, so every request is handled by a single agent and no work splitting happens.",
+        `      remedy: run \`openteam setup\` to cast a team and write the roster (${OPENTEAM_ROSTER_PATH}), then re-run \`openteam doctor\`.`
+      ];
+    }
     return [];
   }
   const missing = auditFindings.filter((finding) => finding.kind === "missing-guaranteed-role").map((finding) => finding.roleID);
@@ -8313,6 +8434,14 @@ function rosterHealthSection(audit, loadError, rosterRoleCount) {
   }
   return lines;
 }
+function orchestratorAgentSection() {
+  return [
+    "  orchestrator agent:",
+    `    ✗ ${ORCHESTRATOR_AGENT_PATH} does not exist — opencode has no openteam coordinator agent.`,
+    "      consequence: this is the primary agent that reads the roster and calls `openteam-orchestrate` to fan work out across roles; without it opencode has no openteam coordinator, so every request is handled by a single agent and no work splitting happens.",
+    `      remedy: run \`openteam setup\` to generate ${ORCHESTRATOR_AGENT_PATH}, then re-run \`openteam doctor\`.`
+  ];
+}
 function gitignoreSection(gitignore) {
   if (gitignore.missingRules.length === 0) {
     return [
@@ -8376,7 +8505,10 @@ function renderDoctor(input) {
   if (input.diagnostics !== undefined) {
     lines.push(...diagnosticsSection(input.diagnostics));
   }
-  lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount));
+  lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount, input.rosterMissing));
+  if (input.orchestratorAgentMissing === true) {
+    lines.push(...orchestratorAgentSection());
+  }
   if (input.gitignore !== undefined) {
     lines.push(...gitignoreSection(input.gitignore));
   }
@@ -8460,14 +8592,31 @@ function leaseLine(lease) {
   const state = lease.released ? "released" : "active";
   return `  lease:      ${lease.holder} → ${lease.runID} (${state})`;
 }
-function renderGraphStatus(snapshot) {
+function appendEffectiveLines(lines, gate) {
+  switch (gate.kind) {
+    case "not-applicable":
+      return;
+    case "passed":
+      lines.push("  effective:  active");
+      return;
+    case "unevaluable":
+      lines.push("  effective:  unknown — could not evaluate the cutover gate");
+      lines.push(`    ${gate.reason}`);
+      return;
+    case "denied":
+      lines.push("  effective:  off — cutover gate denied");
+      for (const violation of gate.violations) {
+        lines.push(`    • ${violation.code}: ${violation.detail}`);
+      }
+  }
+}
+function renderGraphStatus(snapshot, gate = { kind: "not-applicable" }) {
   const lines = [
     "openteam graph status:",
-    `  config:     ${snapshot.effectiveMode} (source: ${snapshot.source})`,
-    leaseLine(snapshot.lease),
-    `  journal:    ${snapshot.journal}`,
-    `  effects:    ${snapshot.pendingEffects} pending, ${snapshot.unknownEffects} unknown`
+    `  config:     ${snapshot.effectiveMode} (source: ${snapshot.source})`
   ];
+  appendEffectiveLines(lines, gate);
+  lines.push(leaseLine(snapshot.lease), `  journal:    ${snapshot.journal}`, `  effects:    ${snapshot.pendingEffects} pending, ${snapshot.unknownEffects} unknown`);
   const needsReconciliation = isRecoveryRequired(snapshot.journal, snapshot.unknownEffects);
   if (needsReconciliation) {
     lines.push("  ⚠ Reconciliation required: journal or effects in an uncertain state.");
@@ -9911,8 +10060,7 @@ async function runAgents(deps, configPath, opencodeConfigPaths, configResolution
 async function runGraph(positionals, deps, configPath, configResolution) {
   const sub = positionals[1];
   if (sub === "status") {
-    const snapshot = await deps.readGraphSnapshot(configPath, configResolution);
-    return { exitCode: 0, stdout: renderGraphStatus(snapshot) };
+    return runGraphStatus(deps, configPath, configResolution);
   }
   if (sub === "cancel") {
     return runGraphCancel(positionals, deps, configPath, configResolution);
@@ -9967,7 +10115,9 @@ function renderGraphOutcome(outcome) {
 async function resolveOperatorGraphPolicy(config, operator) {
   let graph = resolveGraphConfig(config, "file");
   if (isGateApplicable(graph.effectiveMode)) {
-    graph = applyGraphGate(graph, await operator.evaluateCutoverGate());
+    const evaluation = await operator.evaluateCutoverGate(config);
+    const gate = evaluation.kind === "evaluated" ? evaluation.gate : { allowed: false, violations: [] };
+    graph = applyGraphGate(graph, gate);
   }
   return {
     graph,
@@ -9985,6 +10135,32 @@ function checkOperatorGate(policy) {
     stdout: renderLegacyGraphReason(decision2)
   };
 }
+async function runGraphStatus(deps, configPath, configResolution) {
+  const snapshot = await deps.readGraphSnapshot(configPath, configResolution);
+  if (!isGateApplicable(snapshot.effectiveMode)) {
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot) };
+  }
+  const operator = deps.graphOperator;
+  if (operator === undefined) {
+    const gate2 = {
+      kind: "unevaluable",
+      reason: "graph operator ports are not configured"
+    };
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate2) };
+  }
+  const config = await deps.loadConfig(configPath, configResolution);
+  const evaluation = await operator.evaluateCutoverGate(config);
+  if (evaluation.kind === "unevaluable") {
+    const gate2 = {
+      kind: "unevaluable",
+      reason: evaluation.reason
+    };
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate2) };
+  }
+  const resolved = applyGraphGate(resolveGraphConfig(config, "file"), evaluation.gate);
+  const gate = resolved.gateDenied === true ? { kind: "denied", violations: resolved.gateViolations ?? [] } : { kind: "passed" };
+  return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate) };
+}
 async function runGraphCancel(positionals, deps, configPath, configResolution) {
   const runID = positionals[2];
   if (runID === undefined || runID.trim() === "") {
@@ -10431,6 +10607,9 @@ async function runCli(argv, deps) {
         const summary = summarizeQueueWaits(queueEvents);
         queueWait = summary !== undefined ? { summary } : {};
       }
+      const rosterMissing = deps.loadRosterForDoctor !== undefined && roster === undefined && rosterLoadError === undefined;
+      const orchestratorAgentName = ORCHESTRATOR_AGENT_PATH.slice(ORCHESTRATOR_AGENT_PATH.lastIndexOf("/") + 1).replace(/\.md$/, "");
+      const orchestratorAgentMissing = !agentFiles.some((file) => file.name === orchestratorAgentName);
       return {
         exitCode: 0,
         stdout: renderDoctor({
@@ -10444,6 +10623,8 @@ async function runCli(argv, deps) {
           ...rosterAudit !== undefined ? { rosterAudit } : {},
           ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
           ...rosterLoadError !== undefined ? { rosterLoadError } : {},
+          ...rosterMissing ? { rosterMissing } : {},
+          ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
           ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
           ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
           ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
@@ -13308,7 +13489,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.15.1",
+  version: "0.16.1",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -13672,6 +13853,14 @@ async function buildGateInput(config, storage, opencodeVersion, warn) {
   const operatorApproval = config.graph?.operatorApproval ?? false;
   return { shadow, release, soak, migration, operatorApproval };
 }
+var OPENCODE_VERSION_UNRESOLVED_REASON = "the opencode version is not determinable outside a running opencode session, " + "so the cutover gate cannot be verified here — the running plugin logs the " + "authoritative gate result and warns loudly on a real denial";
+async function evaluateCutoverGateForBoundary(config, storage, version) {
+  if (version === undefined) {
+    return { kind: "unevaluable", reason: OPENCODE_VERSION_UNRESOLVED_REASON };
+  }
+  const gateInput = await buildGateInput(config, storage, version, () => {});
+  return { kind: "evaluated", gate: evaluateGraphGate(gateInput) };
+}
 function recorderPortsFromStorage(storage) {
   return {
     fs: {
@@ -13759,7 +13948,7 @@ async function readStoredRosterForDoctor(storage) {
   }
 }
 var auditStoredRosterForDoctor = (roster, configuredRoles) => typeof roster === "string" ? auditRoster(roster, configuredRoles) : auditRoster(roster, configuredRoles);
-function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SESSIONS_DIR, storage = createFsStorageProvider(process.cwd()), fallbackSource = "options", rawOptions) {
+function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SESSIONS_DIR, storage = createFsStorageProvider(process.cwd()), fallbackSource = "options", rawOptions, resolveOpencodeVersion) {
   return {
     loadConfig: async (path4, resolution = { explicit: false }) => {
       const content = await readCliConfigFromStorage(storage, path4, resolution);
@@ -13833,7 +14022,8 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     }),
     graphOperator: createGraphOperator({
       storage,
-      holder: "openteam-cli"
+      holder: "openteam-cli",
+      evaluateCutoverGate: async (gateConfig) => evaluateCutoverGateForBoundary(gateConfig, storage, resolveOpencodeVersion === undefined ? undefined : await resolveOpencodeVersion())
     }),
     configPath: DEFAULT_CONFIG_PATH,
     telemetryPath,
@@ -13963,7 +14153,14 @@ var server = async (ctx, rawOptions) => {
     injectMemory,
     onRoute: (sid, model) => sessionTracker.trackRoutedModel(sid, model)
   });
-  const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage, runtimeConfig.source, rawOptions);
+  const getOpencodeVersion = createLazyOpencodeVersionReader(ctx.serverUrl, {
+    client: ctx.client,
+    onFailure: createOpencodeVersionReadFailureLogger(MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES, diagnostics.warn("opencode-version-read-failed", { toast: false }))
+  });
+  const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage, runtimeConfig.source, rawOptions, async () => {
+    const version = await getOpencodeVersion();
+    return version === "unknown" ? undefined : version;
+  });
   const toolcalls = createToolcallTracker({ sink });
   const announcedSessions = new Set;
   const announceEndpoint = (sessionID) => {
@@ -13986,10 +14183,6 @@ var server = async (ctx, rawOptions) => {
   if (config.privacyMode === "forceLocalOnSensitive" && localDefault(config) === null) {
     warnInertPrivacySetting(runtimeConfig.searchedPaths, diagnostics.warn("privacy-inert"));
   }
-  const getOpencodeVersion = createLazyOpencodeVersionReader(ctx.serverUrl, {
-    client: ctx.client,
-    onFailure: createOpencodeVersionReadFailureLogger(MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES, diagnostics.warn("opencode-version-read-failed", { toast: false }))
-  });
   if (isGateApplicable(graphConfig.effectiveMode)) {
     const opencodeVersion = await getOpencodeVersion();
     const gateInput = await buildGateInput(config, storage, opencodeVersion, diagnostics.warn("soak-evidence-rejected", { toast: false }));
@@ -14047,8 +14240,16 @@ var server = async (ctx, rawOptions) => {
     const snapshots = await registry.probe(config.local.runtimes.filter((runtime) => runtime.enabled));
     return reachableRuntimeIds(snapshots);
   };
+  const runtimeById = (id) => config.local.runtimes.find((runtime) => runtime.id === id);
   const runtimeLimiter = createRuntimeConcurrencyLimiter({
-    capacityFor: (id) => config.local.runtimes.find((runtime) => runtime.id === id)?.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY,
+    capacityFor: (id) => {
+      const runtime = runtimeById(id);
+      return runtime === undefined ? DEFAULT_LOCAL_MAX_CONCURRENCY : effectiveMaxConcurrency(runtime);
+    },
+    reservedInteractiveFor: (id) => {
+      const runtime = runtimeById(id);
+      return runtime === undefined ? 0 : effectiveReservedInteractiveSlots(runtime);
+    },
     now
   });
   const orchestrateTool = createOrchestrateTool({
@@ -14146,6 +14347,7 @@ export {
   logOpencodeServerUrl,
   logAvailabilityRefreshError,
   isMissingFile,
+  evaluateCutoverGateForBoundary,
   src_default as default,
   createOpencodeVersionReadFailureLogger,
   createLazyOpencodeVersionReader,
@@ -14153,5 +14355,6 @@ export {
   createCliDeps,
   buildGateInput,
   PACKAGE_VERSION,
+  OPENCODE_VERSION_UNRESOLVED_REASON,
   MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES
 };

package/dist/local/concurrency.d.ts

@@ -7,8 +7,8 @@ import type { LocalRuntimeId } from "./types";
 export type RuntimeSlotRelease = () => void;
 /**
  * Outcome of an `acquire`: the slot release plus how long the caller waited in
- * the FIFO queue before the slot was granted. `waitedMs` is `0` when a slot was
- * free and the acquisition resolved without queuing. It is measured with the
+ * the priority queue before the slot was granted. `waitedMs` is `0` when a slot
+ * was free and the acquisition resolved without queuing. It is measured with the
  * injected clock (`RuntimeConcurrencyLimiterOptions.now`), so tests are
  * deterministic and the limiter never reads wall-clock time inline.
  */
@@ -17,7 +17,22 @@ export type RuntimeSlotAcquisition = {
     readonly waitedMs: number;
 };
 /**
- * Per-runtime concurrency limiter with FIFO queuing (#144).
+ * Priority band a caller acquires a runtime slot under (#213), highest first:
+ *
+ * - `"interactive"` — latency-sensitive, coordinator-facing work. May use the
+ *   runtime's FULL capacity.
+ * - `"worker"` — ordinary fan-out generations. The DEFAULT, so every pre-#213
+ *   caller keeps its behaviour unchanged.
+ * - `"background"` — bookkeeping/telemetry work (e.g. the scribe role).
+ *
+ * Queue ordering is STRICT PRIORITY ACROSS bands and FIFO WITHIN a band: on
+ * release the freed slot is granted to the longest-waiting waiter in the highest
+ * non-empty admissible band.
+ */
+export type RuntimeSlotPriority = "interactive" | "worker" | "background";
+/**
+ * Per-runtime concurrency limiter with a PRIORITY queue and RESERVED interactive
+ * capacity (#144, #213).
  *
  * A runtime has a fixed number of slots (its configured `maxConcurrency`). The
  * limiter caps concurrent generations to that number and QUEUES excess work
@@ -32,21 +47,55 @@ export type RuntimeSlotAcquisition = {
  * concurrent-telemetry emission order of a wave is unperturbed. Only when a
  * runtime is saturated does `acquire` return a promise that settles when a slot
  * frees.
+ *
+ * ## Priority bands
+ *
+ * Callers pass a {@link RuntimeSlotPriority}; when omitted it defaults to
+ * `"worker"` so existing callers are unchanged. Queuing is strict priority
+ * across bands and FIFO within a band: an interactive waiter is always served
+ * before any worker, and workers before background, but two waiters of the same
+ * band keep their arrival order (so existing ordering guarantees survive).
+ *
+ * ## Reserved interactive capacity — the core of #213
+ *
+ * `reservedInteractiveFor` withholds a slice of a runtime's capacity from the
+ * non-interactive bands: `worker`/`background` callers may occupy at most
+ * `capacity - reserved` slots, while `interactive` callers may use the FULL
+ * capacity. The reserved count is clamped to `[0, capacity - 1]` so the
+ * non-interactive budget is never driven to 0 (a single-slot runtime with
+ * `reserved = 1` would otherwise deadlock every worker forever); non-integer,
+ * negative and NaN inputs are sanitised too.
+ *
+ * The non-obvious part: openteam's own INTERACTIVE/coordinator traffic reaches
+ * the local runtime as ordinary opencode chat and never passes through this
+ * limiter. Reserving a slot still helps, because the reservation caps how many
+ * slots openteam's WORKERS occupy on the shared runtime. By refusing to let
+ * workers fill the last slot, the limiter guarantees the runtime SERVER always
+ * has free headroom for the ungoverned interactive request — turning a
+ * `maxConcurrency` that equals the server's real slot count (the reported
+ * incident: a 4-slot Lemonade box with `DEFAULT_LOCAL_MAX_CONCURRENCY === 4`)
+ * from full saturation into a 3-worker + 1-reserved split with no config change.
+ * The `interactive` band exists so an in-process interactive caller can still
+ * claim the reserved slot when one is wired up.
  */
 export type RuntimeConcurrencyLimiter = {
     /**
-     * Attempts to take a slot for `runtimeId` synchronously. Returns a release
-     * when a slot was free, or `undefined` when the runtime is at its cap.
+     * Attempts to take a slot for `runtimeId` synchronously under `priority`
+     * (default `"worker"`). Returns a release when a slot was free within the
+     * band's admissible budget, or `undefined` when the runtime is at its cap (for
+     * `interactive`) or at its reserved-adjusted budget (for `worker`/
+     * `background`).
      */
-    tryAcquire(runtimeId: LocalRuntimeId): RuntimeSlotRelease | undefined;
+    tryAcquire(runtimeId: LocalRuntimeId, priority?: RuntimeSlotPriority): RuntimeSlotRelease | undefined;
     /**
-     * Takes a slot for `runtimeId`, queuing FIFO when the runtime is saturated.
-     * Resolves with a release and the measured queue wait once a slot is
-     * available. Prefer `tryAcquire` first and only `await acquire` when it
-     * returns `undefined`, so the common free path stays synchronous. When a slot
-     * is free, resolves immediately with `waitedMs === 0`.
+     * Takes a slot for `runtimeId` under `priority` (default `"worker"`), queuing
+     * when the runtime is saturated for that band. Resolves with a release and the
+     * measured queue wait once a slot is available. Prefer `tryAcquire` first and
+     * only `await acquire` when it returns `undefined`, so the common free path
+     * stays synchronous. When a slot is free, resolves immediately with
+     * `waitedMs === 0`.
      */
-    acquire(runtimeId: LocalRuntimeId): Promise<RuntimeSlotAcquisition>;
+    acquire(runtimeId: LocalRuntimeId, priority?: RuntimeSlotPriority): Promise<RuntimeSlotAcquisition>;
     /** Current in-flight count for a runtime. Exposed for tests and diagnostics. */
     activeCount(runtimeId: LocalRuntimeId): number;
     /** Current queued (waiting) count for a runtime. Exposed for tests. */
@@ -59,12 +108,21 @@ export type RuntimeConcurrencyLimiterOptions = {
      * runtime does not declare a cap. Must return a positive integer.
      */
     capacityFor: (runtimeId: LocalRuntimeId) => number;
+    /**
+     * Resolves how many of a runtime's slots are RESERVED for interactive work
+     * (#213). Optional and injected so the limiter carries no config coupling;
+     * when absent, no capacity is reserved and behaviour matches the pre-#213
+     * FIFO limiter exactly. The returned value is clamped to `[0, capacity - 1]`
+     * and sanitised (non-integer/negative/NaN handled conservatively), so it can
+     * never starve the non-interactive budget to 0.
+     */
+    reservedInteractiveFor?: (runtimeId: LocalRuntimeId) => number;
     /**
      * Injected clock in epoch milliseconds, used ONLY to measure how long a
-     * saturated `acquire` waited in the FIFO queue. The free `tryAcquire` path
-     * never reads it, so the happy path stays allocation-free and clock-free.
-     * Injected (never `Date.now()` inline) so queue-wait telemetry is
-     * deterministic under test.
+     * saturated `acquire` waited in the queue. The free `tryAcquire` path never
+     * reads it, so the happy path stays allocation-free and clock-free. Injected
+     * (never `Date.now()` inline) so queue-wait telemetry is deterministic under
+     * test.
      */
     now: () => number;
 };

package/dist/local/concurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/local/concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;OAGG;IACH,UAAU,CAAC,SAAS,EAAE,cAAc,GAAG,kBAAkB,GAAG,SAAS,CAAC;IACtE;;;;;;OAMG;IACH,OAAO,CAAC,SAAS,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACpE,gFAAgF;IAChF,WAAW,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CAAC;IAC/C,uEAAuE;IACvE,WAAW,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CAAC;CAChD,CAAC;AAOF,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;OAIG;IACH,WAAW,EAAE,CAAC,SAAS,EAAE,cAAc,KAAK,MAAM,CAAC;IACnD;;;;;;OAMG;IACH,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,yBAAyB,CA+D3B"}
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/local/concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG,QAAQ,GAAG,YAAY,CAAC;AAQ1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;OAMG;IACH,UAAU,CACR,SAAS,EAAE,cAAc,EACzB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,kBAAkB,GAAG,SAAS,CAAC;IAClC;;;;;;;OAOG;IACH,OAAO,CACL,SAAS,EAAE,cAAc,EACzB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACnC,gFAAgF;IAChF,WAAW,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CAAC;IAC/C,uEAAuE;IACvE,WAAW,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CAAC;CAChD,CAAC;AAaF,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;OAIG;IACH,WAAW,EAAE,CAAC,SAAS,EAAE,cAAc,KAAK,MAAM,CAAC;IACnD;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,CAAC,SAAS,EAAE,cAAc,KAAK,MAAM,CAAC;IAC/D;;;;;;OAMG;IACH,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,yBAAyB,CAuK3B"}