@ixo/oracle-runtime-workers 0.13.0 → 0.16.0

package/src/core/env.ts

@@ -1,7 +1,17 @@
+import {
+  capabilityRouterEnvShape,
+  decisionProviderEnvShape,
+} from '@ixo/common/ai/decisions';
 import { z } from 'zod';
 import type { OraclePlugin } from '../plugin-api/oracle-plugin';
 import type { Logger } from '../plugin-api/types';
 import { NOOP_LOGGER } from './utils';
+import { FEEDBACK_ENV_PREFIX } from '../feedback/contract';
+import {
+  isSecureUrl,
+  MAX_ARTIFACT_SWEEP_INTERVAL_HOURS,
+  MAX_ARTIFACT_TTL_DAYS,
+} from '../artifacts/config';
 
 /**
  * Tier-0 (core) environment for the Workers runtime. Mirrors
@@ -29,6 +39,11 @@ import { NOOP_LOGGER } from './utils';
  */
 export const TURN_RECURSION_LIMIT_DEFAULT = 600;
 
+/** An https URL, or http on localhost / 127.0.0.1 (local harness). */
+const secureUrlSchema = z.string().refine((raw) => isSecureUrl(raw), {
+  message: 'must be an https URL (http only on localhost)',
+});
+
 export const baseEnvSchema = z.object({
   // --- identity -----------------------------------------------------------
   ORACLE_NAME: z.string().min(1),
@@ -50,6 +65,13 @@ export const baseEnvSchema = z.object({
    * declares. Default 15 minutes.
    */
   UCAN_AUTH_MAX_TTL_SECONDS: z.coerce.number().int().positive().default(900),
+  /**
+   * `true` lets a bare `x-ucan-delegation` (no invocation) authenticate a
+   * request — the legacy fallback, for clients that do not send a UCAN
+   * invocation yet. Off by default: a delegation travels on as proof in
+   * downstream invocations, so it must not also be a login credential.
+   */
+  UCAN_ALLOW_BARE_DELEGATION_AUTH: z.enum(['true', 'false']).optional(),
 
   // --- matrix -------------------------------------------------------------
   MATRIX_BASE_URL: z.string().min(1),
@@ -114,6 +136,45 @@ export const baseEnvSchema = z.object({
     .int()
     .min(1)
     .default(TURN_RECURSION_LIMIT_DEFAULT),
+  /**
+   * The turn budget (docs/plans/workers-harness-hardening.md): cumulative
+   * model tokens across the main agent, sub-agents and helper models; tool
+   * attempts; and the wall-clock deadline. Exhaustion ends the turn and keeps
+   * the work done so far. Parsed by `turnLimitsFromEnv`.
+   */
+  TURN_MAX_TOKENS: z.coerce.number().int().positive().default(500_000),
+  TURN_MAX_TOOL_CALLS: z.coerce.number().int().positive().default(120),
+  TURN_TIMEOUT_MS: z.coerce.number().int().positive().default(600_000),
+  /**
+   * The repetition guard's per-turn caps on identical successful calls
+   * (same tool, same arguments): a write, and a read or `repeatable` tool.
+   * Parsed by `repetitionCapsFromEnv`.
+   */
+  TURN_MAX_IDENTICAL_WRITES: z.coerce.number().int().positive().default(1),
+  TURN_MAX_IDENTICAL_READS: z.coerce.number().int().positive().default(5),
+  /**
+   * Time limit per plugin `getRequestAdmission` handler (ms). A handler that
+   * has not answered by then counts as `pass` and the turn goes on to the
+   * next handler or the agent. See docs/architecture/request-admission.md.
+   */
+  REQUEST_ADMISSION_TIMEOUT_MS: z.coerce
+    .number()
+    .int()
+    .positive()
+    .default(2_000),
+
+  // --- decisions ----------------------------------------------------------
+  // Bounded semantic Decision provider (`DECISION_PROVIDER`, `DECISION_MODEL`,
+  // Cloudflare credentials), shared with the Node runtime and optional so
+  // oracles without Decisions keep their behaviour. `openrouter-jev` reuses
+  // `OPEN_ROUTER_API_KEY` (required above). On Workers `cloudflare-jev`
+  // prefers the `AI` binding over the account credentials, which are only
+  // needed when the binding is not declared.
+  ...decisionProviderEnvShape,
+  // `CAPABILITY_ROUTER` (`off` | `shadow` | `on`, default `off`): the first
+  // runtime consumer of Decisions. It predicts the on-demand plugin a message
+  // needs and preloads it for the turn; it needs a `DECISION_PROVIDER`.
+  ...capabilityRouterEnvShape,
 
   // --- durable runs (docs/plans/durable-runs.md) ---------------------------
   // Parsed by `runDurabilityConfig` (src/do/run-store.ts) with defaults:
@@ -144,9 +205,49 @@ export const baseEnvSchema = z.object({
   TOOL_RESULT_TTL_HOURS: z.string().optional(),
   TOOL_RESULT_R2_MIN_BYTES: z.string().optional(),
 
+  // --- chat delivery (docs/chat-delivery.md) -------------------------------
+  /**
+   * `true` gives Matrix room turns the chat style (several short messages,
+   * long content as artefacts); unset keeps `OracleConfig.delivery.matrixChat`,
+   * which defaults to one message per reply.
+   */
+  MATRIX_CHAT_DELIVERY: z.enum(['true', 'false']).optional(),
+  /**
+   * Artefact links (the bucket is a binding, `ARTIFACT_BUCKET`): the oracle's
+   * public origin, an optional shared viewer page, and the link lifetime in
+   * days. Links carry the decryption key, so both URLs must be https (http
+   * only on localhost).
+   */
+  ORACLE_PUBLIC_URL: secureUrlSchema.optional(),
+  ARTIFACT_VIEWER_URL: secureUrlSchema.optional(),
+  ARTIFACT_LINK_TTL_DAYS: z.coerce
+    .number()
+    .int()
+    .min(1)
+    .max(MAX_ARTIFACT_TTL_DAYS)
+    .optional(),
+  /**
+   * Hours between the cron's sweeps of expired share copies in the bucket
+   * (unset = 24). Only runs where `ARTIFACT_BUCKET` is bound and a cron
+   * trigger is declared.
+   */
+  ARTIFACT_SWEEP_INTERVAL_HOURS: z.coerce
+    .number()
+    .int()
+    .min(1)
+    .max(MAX_ARTIFACT_SWEEP_INTERVAL_HOURS)
+    .optional(),
+
   // --- misc ---------------------------------------------------------------
   LOG_LEVEL: z.string().default('info'),
   CORS_ORIGIN: z.string().default('*'),
+  /**
+   * Comma-separated DIDs allowed onto the gateway-wide operator routes
+   * (`/debug/matrix/*`). Unset: any authenticated caller (with
+   * `ORACLE_DEBUG_ROUTES=true`). A list with an entry that is not a DID
+   * admits nobody.
+   */
+  ORACLE_OPERATOR_DIDS: z.string().optional(),
 });
 
 export type BaseEnv = z.infer<typeof baseEnvSchema>;
@@ -207,8 +308,18 @@ export function composeEnvSchema(
     if (!plugin.configSchema) continue;
     const shape = plugin.configSchema.shape as Record<string, unknown>;
     for (const key of Object.keys(shape)) {
+      // Runtime-only secrets (the feedback sink's Linear key and pseudonym
+      // secret) must never reach a plugin's `ctx.config`.
+      if (key.startsWith(FEEDBACK_ENV_PREFIX))
+        throw new Error(
+          `Plugin '${plugin.name}' declares env key '${key}': the '${FEEDBACK_ENV_PREFIX}' prefix is reserved for the runtime`,
+        );
       const previous = pluginOwnership.get(key);
       if (previous !== undefined && previous !== plugin.name) {
+        // Plugins that declare the very same schema object share the key on
+        // purpose (the wallet-signing chain ids): nothing is replaced, and
+        // the first declarer stays its owner.
+        if (merged.shape[key] === shape[key]) continue;
         logger.warn(
           `[boot] env key '${key}' is defined by both '${previous}' and '${plugin.name}'; '${plugin.name}' wins.`,
         );

package/src/core/execution-profile.ts

@@ -0,0 +1,17 @@
+export const TASK_EXECUTION_PROFILES = ['supplied-context-markdown'] as const;
+
+export type TaskExecutionProfile = (typeof TASK_EXECUTION_PROFILES)[number];
+
+export function isTaskExecutionProfile(
+  value: unknown,
+): value is TaskExecutionProfile {
+  return (TASK_EXECUTION_PROFILES as readonly unknown[]).includes(value);
+}
+
+export function taskExecutionProfile(
+  value: unknown,
+): TaskExecutionProfile | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (isTaskExecutionProfile(value)) return value;
+  throw new Error('Unsupported task execution profile');
+}

package/src/core/index.ts

@@ -4,6 +4,18 @@
  * Durable Objects, Matrix, or Hono; the host (`src/do`, `src/shell`) supplies
  * those through the `AmbientServices` adapters and mounts `pluginRoutes`.
  */
+import {
+  DecisionProviderRegistry,
+  DecisionProviderRouter,
+  DecisionRuntime,
+  HOST_DECISION_PROVIDER_ID,
+  resolveDecisionAdapter,
+  type DecisionAdapter,
+  type DecisionEvaluator,
+  type DecisionProviderPolicy,
+  type DecisionProviderRegistration,
+  type WorkersAiBinding,
+} from '@ixo/common/ai/decisions';
 import { z } from 'zod';
 import type { OraclePlugin, PluginRoute } from '../plugin-api/oracle-plugin';
 import type {
@@ -14,8 +26,17 @@ import type {
   PluginContext,
 } from '../plugin-api/types';
 import { baseEnvSchema, composeEnvSchema, validateEnv } from './env';
-import { createLlmAdapter, type OpenRouterLlmAdapter } from './llm';
-import { validateManifest, type PluginManifestOverride } from './manifest';
+import {
+  createLlmAdapter,
+  openRouterAttributionHeaders,
+  type OpenRouterLlmAdapter,
+} from './llm';
+import {
+  estimateTokensApprox,
+  OPERATING_GUIDE_WARN_TOKENS,
+  validateManifest,
+  type PluginManifestOverride,
+} from './manifest';
 import {
   resolvePlugins,
   type ExcludedPlugin,
@@ -23,6 +44,10 @@ import {
   type SoftDepGap,
 } from './plugin-loader';
 import { createRegistries, type Registries } from './registries';
+import {
+  type DeliveryConfig,
+  deliveryConfigWithEnv,
+} from '../delivery/profile';
 import { buildPluginContext } from './runtime-context';
 import { NOOP_LOGGER } from './utils';
 
@@ -50,6 +75,7 @@ export type {
 
 export {
   ConfigSchemaRegistry,
+  DecisionRegistry,
   ManifestRegistry,
   MiddlewareRegistry,
   SharedStateRegistry,
@@ -61,6 +87,7 @@ export {
 export type {
   ManifestCrossCheckResult,
   RegisteredConfigSchema,
+  RegisteredDecision,
   RegisteredManifest,
   RegisteredMiddleware,
   RegisteredSharedAccessor,
@@ -70,8 +97,67 @@ export type {
   ToolSummary,
 } from './registries';
 
+export {
+  AmbiguousDecisionProviderError,
+  CloudflareJevDecisionAdapter,
+  DECISION_PROVIDERS,
+  DecisionNotApplicableError,
+  DecisionProviderNotFoundError,
+  DecisionProviderRegistry,
+  DecisionProviderRouter,
+  DecisionProviderUnavailableError,
+  DecisionRuntime,
+  HOST_DECISION_PROVIDER_ID,
+  JevDecisionError,
+  OpenRouterJevDecisionAdapter,
+  StaleDecisionSubjectError,
+  UNAVAILABLE_DECISION_EVALUATOR,
+  WorkersAiJevDecisionAdapter,
+  assertFinalDecisionSubjectUnchanged,
+  canonicalizeFinalDecisionSubject,
+  createDecisionAuthorityReceipt,
+  createDecisionExecutionReceipt,
+  decisionProviderEnvShape,
+  digestFinalDecisionSubject,
+  measureDecisionQuestionIsolation,
+  resolveDecisionAdapter,
+} from '@ixo/common/ai/decisions';
+export type {
+  CloudflareJevAdapterOptions,
+  DecisionAdapter,
+  DecisionApplicability,
+  DecisionAuthorityReceipt,
+  DecisionCalibrationProvenance,
+  DecisionEvaluator,
+  DecisionExecution,
+  DecisionExecutionReceipt,
+  DecisionJudgmentMethod,
+  DecisionJudgmentProvenance,
+  DecisionLookup,
+  DecisionProviderConfigIssue,
+  DecisionProviderName,
+  DecisionProviderPolicy,
+  DecisionProviderProvenance,
+  DecisionProviderRegistration,
+  DecisionProviderResolution,
+  DecisionProviderSelection,
+  DecisionQuestionIsolationObservation,
+  DecisionQuestionIsolationReport,
+  DecisionRuntimeLogger,
+  FinalDecisionSubject,
+  FinalDecisionSubjectBinding,
+  FinalDecisionSubjectValue,
+  JevProviderName,
+  OpenRouterJevAdapterOptions,
+  ResolveDecisionAdapterOptions,
+  ResolveDecisionAdapterResult,
+  WorkersAiBinding,
+  WorkersAiJevAdapterOptions,
+} from '@ixo/common/ai/decisions';
+
 export {
   estimateTokensApprox,
+  OPERATING_GUIDE_WARN_TOKENS,
   manifestCategorySchema,
   manifestExampleSchema,
   manifestStabilitySchema,
@@ -114,6 +200,7 @@ export {
   isAllowedModel,
   listModelCatalog,
   listModels,
+  openRouterAttributionHeaders,
 } from './llm';
 export {
   OPENROUTER_MODELS_URL,
@@ -146,9 +233,16 @@ export type {
 export {
   buildOracleSection,
   composePrompt,
+  formatDateContext,
   formatTimeContext,
   formatUserPreferences,
+  renderTurnTimeNote,
 } from './prompt-composer';
+export {
+  stripTurnTimeNote,
+  TURN_TIME_NOTE_KWARG,
+  withTurnTimeNote,
+} from './turn-time-note';
 export type {
   ComposePromptInput,
   MemoryCommunity,
@@ -163,6 +257,8 @@ export type { CompiledTemplate, TemplateValues } from './template';
 
 export * from './middlewares';
 
+export { createMemoryUserKv } from './user-kv';
+
 export {
   EMPTY_SHARED,
   EVENT_NAMES,
@@ -253,6 +349,26 @@ export interface RuntimeCoreOptions {
    * namespaces, …) are stripped from `validatedEnv`.
    */
   env: Record<string, unknown>;
+  /**
+   * Single host-supplied Decision adapter, registered as provider `host` and
+   * the default. Wins over the `DECISION_PROVIDER` env configuration, which
+   * is then neither checked nor registered. Mutually exclusive with
+   * `decisionProviders`.
+   */
+  decisionAdapter?: DecisionAdapter;
+  /**
+   * Host-configured Decision providers, registered beside the env-selected
+   * provider (`DECISION_PROVIDER`, registered under that value as its id).
+   * Ids must be unique across both.
+   */
+  decisionProviders?: readonly DecisionProviderRegistration[];
+  /**
+   * Default and per-Decision routes over the registered providers. Without a
+   * `defaultProviderId` the env-selected provider is the default. With
+   * several providers and neither a route nor a default for a Decision, its
+   * evaluation is refused with `AmbiguousDecisionProviderError`.
+   */
+  decisionProviderPolicy?: DecisionProviderPolicy;
   /** Boot + runtime logger. Defaults to a silent logger. */
   logger?: Logger;
 }
@@ -263,6 +379,8 @@ export interface RuntimeCoreOptions {
  */
 export interface RuntimeCore {
   identity: OracleIdentity;
+  /** `OracleConfig.delivery`: how chat surfaces receive replies. */
+  delivery: DeliveryConfig;
   registries: Registries;
   /** Names of the plugins that loaded, in dependency order. */
   availablePlugins: ReadonlySet<string>;
@@ -278,13 +396,20 @@ export interface RuntimeCore {
   authExcludedRoutes: AuthExcludedRoute[];
   /** OpenRouter-backed LLM adapter (`get(role, params?)`). */
   llm: OpenRouterLlmAdapter;
+  /**
+   * Bounded semantic Decision evaluator over the decision registry and the
+   * configured adapter — what `ctx.decisions` forwards to. Without a provider
+   * every call rejects with `DecisionProviderUnavailableError`.
+   */
+  decisions: DecisionEvaluator;
   logger: Logger;
   /** A boot-time `PluginContext` scoped to `pluginName` (default `__runtime__`). */
   buildCtx(pluginName?: string): PluginContext;
   /**
    * Warm the registries' boot caches (`getTools` / `getSubAgents` /
-   * `getMiddlewares`) and run the cross-plugin checks that need them: tool,
-   * sub-agent and shared-state name collisions (fatal), and every manifest's
+   * `getMiddlewares` / `getDecisions`) and run the cross-plugin checks that
+   * need them: tool, sub-agent, shared-state and decision name collisions
+   * (fatal), and every manifest's
    * `examples[].tool` references (advisory — logged). Memoised — safe to
    * await on every turn; the first agent build would otherwise perform the
    * collection lazily without the checks. Rejects with the boot error.
@@ -297,6 +422,19 @@ function reportBootError(logger: Logger, message: string, hint?: string): void {
   logger.error(`[boot-error] ${body}`);
 }
 
+/**
+ * The Workers AI binding (`env.AI`) is an object exposing `run`. Only its
+ * shape can be checked: bindings carry no brand the runtime could test for.
+ */
+function isWorkersAiBinding(value: unknown): value is WorkersAiBinding {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'run' in value &&
+    typeof value.run === 'function'
+  );
+}
+
 function validateConfig(config: OracleConfig): void {
   if (!config || typeof config !== 'object') {
     throw new Error('createRuntimeCore: `config` is required.');
@@ -354,6 +492,24 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     for (const warning of result.warnings) logger.warn(`[boot] ${warning}`);
     if (!result.valid) manifestErrors.push(...result.errors);
   }
+  const guides = registries.manifests.operatingGuides();
+  if (guides.length > 0) {
+    logger.log(
+      `[boot] operating guides: ${guides
+        .map(
+          ({ pluginName, guide }) =>
+            `${pluginName}=${guide.length} chars (~${estimateTokensApprox(guide)} tokens)`,
+        )
+        .join(', ')}`,
+    );
+    for (const { pluginName, guide } of guides) {
+      const tokens = estimateTokensApprox(guide);
+      if (tokens > OPERATING_GUIDE_WARN_TOKENS)
+        logger.warn(
+          `[boot] operating guide of '${pluginName}' is ~${tokens} tokens (over ${OPERATING_GUIDE_WARN_TOKENS}); it is in the system prompt of every turn that has the plugin loaded`,
+        );
+    }
+  }
   if (manifestErrors.length > 0) {
     for (const err of manifestErrors) reportBootError(logger, err);
     throw new Error(
@@ -386,7 +542,81 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     );
   }
 
-  // 4. Identity.
+  // 4. Decision providers — resolved here so a selected provider with missing
+  // credentials, or a policy naming an unknown provider, fails at boot rather
+  // than on the first evaluation. A single host adapter wins over env and
+  // skips the env check. The Workers AI binding is not a string, so Zod
+  // strips it from `validated.config`; it is read from the raw env.
+  if (opts.decisionAdapter && opts.decisionProviders !== undefined) {
+    const message =
+      'createRuntimeCore: decisionAdapter and decisionProviders are mutually exclusive.';
+    reportBootError(logger, message);
+    throw new Error(message);
+  }
+  const decisionRegistrations: DecisionProviderRegistration[] = [];
+  let defaultDecisionProviderId: string | undefined;
+  if (opts.decisionAdapter) {
+    decisionRegistrations.push({
+      id: HOST_DECISION_PROVIDER_ID,
+      adapter: opts.decisionAdapter,
+    });
+    defaultDecisionProviderId = HOST_DECISION_PROVIDER_ID;
+  } else {
+    const workersAi = opts.env.AI;
+    const resolvedAdapter = resolveDecisionAdapter(validated.config, {
+      ...(isWorkersAiBinding(workersAi) ? { workersAi } : {}),
+      openRouterHeaders: openRouterAttributionHeaders(
+        String(validated.config.ORACLE_NAME),
+      ),
+    });
+    if (!resolvedAdapter.ok) {
+      const lines: string[] = [];
+      for (const issue of resolvedAdapter.issues) {
+        const message = `Decision provider env validation failed for '${issue.field}': ${issue.message}`;
+        reportBootError(
+          logger,
+          message,
+          `Set '${issue.field}' on the Worker (wrangler secret / vars).`,
+        );
+        lines.push(message);
+      }
+      throw new Error(
+        `Env validation failed (${lines.length} issues):\n  - ${lines.join('\n  - ')}`,
+      );
+    }
+    if (resolvedAdapter.adapter) {
+      // `resolveDecisionAdapter` only builds an adapter for a set provider.
+      const envProviderId = String(validated.config.DECISION_PROVIDER);
+      decisionRegistrations.push({
+        id: envProviderId,
+        adapter: resolvedAdapter.adapter,
+      });
+      defaultDecisionProviderId = envProviderId;
+    }
+    decisionRegistrations.push(...(opts.decisionProviders ?? []));
+  }
+  let decisionProviders: DecisionProviderRouter;
+  try {
+    const policy = opts.decisionProviderPolicy;
+    const defaultProviderId =
+      policy?.defaultProviderId ?? defaultDecisionProviderId;
+    decisionProviders = new DecisionProviderRouter(
+      new DecisionProviderRegistry(decisionRegistrations),
+      {
+        ...(defaultProviderId !== undefined && { defaultProviderId }),
+        ...(policy?.routes !== undefined && { routes: policy.routes }),
+      },
+    );
+  } catch (err) {
+    reportBootError(
+      logger,
+      `Decision provider configuration is invalid: ${err instanceof Error ? err.message : String(err)}`,
+      'Check createOracleWorker({ decisionProviders, decisionProviderPolicy }) against DECISION_PROVIDER.',
+    );
+    throw err;
+  }
+
+  // 5. Identity.
   const oracleDid = String(validated.config.ORACLE_DID);
   const entityDid =
     typeof validated.config.ORACLE_ENTITY_DID === 'string' &&
@@ -401,14 +631,20 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     prompt: opts.config.prompt ?? {},
   };
 
-  // 5. Registries.
+  // 6. Registries.
   for (const plugin of resolved.loaded) {
     registries.tools.register(plugin);
     registries.subAgents.register(plugin);
     registries.middlewares.register(plugin);
     registries.configSchema.register(plugin);
     registries.sharedState.register(plugin);
+    registries.decisions.register(plugin);
   }
+  const decisions: DecisionEvaluator = new DecisionRuntime(
+    registries.decisions,
+    decisionProviders,
+    logger,
+  );
 
   const availablePlugins: ReadonlySet<string> = loadedNames;
   const buildCtx = (pluginName = '__runtime__'): PluginContext =>
@@ -420,7 +656,7 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
       pluginName,
     });
 
-  // 6. Routes + auth exclusions (sync — plugins close over config here).
+  // 7. Routes + auth exclusions (sync — plugins close over config here).
   const pluginRoutes: PluginRoute[] = resolved.loaded.flatMap(
     (p) => p.getRoutes?.(buildCtx(p.name)) ?? [],
   );
@@ -428,7 +664,7 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     (p) => p.getAuthExcludedRoutes?.() ?? [],
   );
 
-  // 7. LLM.
+  // 8. LLM.
   const llm = createLlmAdapter(
     {
       OPEN_ROUTER_API_KEY: String(validated.config.OPEN_ROUTER_API_KEY),
@@ -446,7 +682,7 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     logger,
   );
 
-  // 8. Warm-up (memoised). Collision + manifest cross-checks need the boot
+  // 9. Warm-up (memoised). Collision + manifest cross-checks need the boot
   // caches, which may involve async `getTools`, so they cannot run here.
   let warmed: Promise<void> | null = null;
   const warm = (): Promise<void> => {
@@ -455,10 +691,12 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
       await registries.tools.collectBoot(ctx);
       registries.subAgents.collectBoot(ctx);
       registries.middlewares.collect(ctx);
+      registries.decisions.collect(ctx);
       try {
         registries.tools.assertNoCollisions();
         registries.subAgents.assertNoCollisions();
         registries.sharedState.assertNoCollisions();
+        registries.decisions.assertNoCollisions();
         // Advisory only: request-time tools (`getRequestTools`) are invisible
         // at boot, so an example that names one reads as "unknown" here. The
         // Node runtime does not run this check at boot at all; surfacing it
@@ -497,6 +735,12 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
 
   return {
     identity,
+    delivery: deliveryConfigWithEnv(
+      opts.config.delivery,
+      typeof validated.config.MATRIX_CHAT_DELIVERY === 'string'
+        ? validated.config.MATRIX_CHAT_DELIVERY
+        : undefined,
+    ),
     registries,
     availablePlugins,
     plugins: resolved.loaded,
@@ -506,8 +750,22 @@ export function createRuntimeCore(opts: RuntimeCoreOptions): RuntimeCore {
     pluginRoutes,
     authExcludedRoutes,
     llm,
+    decisions,
     logger,
     buildCtx,
     warm,
   };
 }
+export {
+  DEFAULT_TURN_LIMITS,
+  HarnessLimitError,
+  TurnBudget,
+  harnessLimitOf,
+  isHarnessLimitError,
+  turnLimitsFromEnv,
+} from './turn-budget';
+export type { TurnLimits, TurnUsage } from './turn-budget';
+export { budgetedLlm } from './budgeted-llm';
+export type { BudgetedLlm, BudgetedLlmOptions } from './budgeted-llm';
+export { ToolScheduler } from './tool-scheduler';
+export type { ToolLane, ToolSchedulerOptions } from './tool-scheduler';