Runtime strategies

SessionRuntimeConfig carries a second set of fields the substrate calls strategies — typed slots the host fills with domain code. A strategy is not a plugin. Plugins contribute through named slots on the HarnessPlugin contract; strategies are individual typed fields on the runtime config, each with one well-defined shape and one consumer inside the runtime or graph. When a strategy is unset, the consumer gracefully degrades — the runtime stays functional, the strategy-backed behavior goes inert.

Plugins and strategies meet at the same constructor. The split is about shape, not lifecycle. A strategy is one typed field with one caller — easy to type, easy to swap in a test. A plugin is an extensible contributor that fills many slots on the HarnessPlugin contract (tier nodes, stream observers, prompts, fabrication detectors). Reach for a strategy when the runtime needs one answer from a host-specific function; reach for a plugin when a package wants to ship a bundle of contributions.

For the plugin counterpart see Plugin contract; for how a host wires both at once see Host adapter.

Representative strategy slots

The full set lives in SessionRuntimeConfig in src/SessionRuntime.ts and the shapes in src/types/strategies.ts.

Wiring strategies at construction

import { SessionRuntime } from "@pleach/core";
import type {
  ToolCatalogProvider,
  SummaryExtractor,
  SubagentExecutorFn,
} from "@pleach/core/types/strategies";

const toolCatalog: ToolCatalogProvider = {
  /* host implementation */
};
const summaryExtractor: SummaryExtractor = {
  extractSummary: (_toolName, result) => ({
    description: typeof result === "string" ? result.slice(0, 280) : "",
  }),
  extractChainingFields: () => undefined,
};
const subagentExecutor: SubagentExecutorFn = async (_config, _parent, options) => {
  /* host implementation */
  return {
    id: options.id ?? crypto.randomUUID(),
    status: "completed",
    content: "",
    toolCalls: [],
    metrics: { totalSteps: 0, durationMs: 0 },
  };
};

import { SupabaseAdapter } from "@pleach/core/sessions";
import { createClient } from "@supabase/supabase-js";

const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_KEY!);

const runtime = new SessionRuntime({
  storage: new SupabaseAdapter({ client: supabase }),
  userId: "user_123",
  toolCatalog,
  summaryExtractor,
  subagentExecutor,
});

fabricationGuardStrategy (typed bundle)

The fabricationGuardStrategy slot takes the typed bundle. The empty default is the floor — quantitativePatterns is required, every other slot is optional and degrades cleanly when omitted.

import { SessionRuntime } from "@pleach/core";
import {
  DEFAULT_FABRICATION_GUARD_STRATEGY_BUNDLE,
  type FabricationGuardStrategyBundle,
} from "@pleach/core/types/strategies";

const fabricationGuardStrategy: FabricationGuardStrategyBundle = {
  ...DEFAULT_FABRICATION_GUARD_STRATEGY_BUNDLE,
  quantitativePatterns: [/\b\d+(?:\.\d+)?%/g, /\$\d[\d,]*/g],
};

const runtime = new SessionRuntime({
  storage,
  userId: "user_123",
  fabricationGuardStrategy,
});

Strategy dep-injection via harnessRuntime accessors

A second category of strategy plumbing rides on OrchestratorConfig.harnessRuntime — a structural shape the runtime threads into the orchestrator config so the streamSingleTurn body and graph nodes can read per-runtime strategies without importing SessionRuntime directly. Each accessor is optional; CLI and raw orchestrator entry points leave the shape minimal (often only getIntentPriorityTools) and the consumer falls back to a default.

The body lift (PO-A1) cohort threads four strategy slots this way:

Sibling accessors carry plugin-contributed strategies and registries that share the same dep-inversion shape:

The pattern is consistent: hosts wire strategies through plugin contributions (see Plugin contract), the SessionRuntime exposes them through facet accessors (see Facets), and the body lift reads them through harnessRuntime?.getX?.() or harnessRuntime?.collectX?.() optional chains. CLI and raw orchestrator paths leave the accessors undefined and the consumer falls back to an inline default — typically a no-op or a direct module import retained for back-compat.

Newer injection hooks

The substrate keeps growing strategy slots as more body-level behaviors get lifted into the typed contract. The hooks below ship today and follow the same shape rules as the slots above — typed field on SessionRuntimeConfig, one consumer, graceful no-op when omitted.

The factory-shaped hook (hallucinationDetectorFactory) is the shape to reach for when a strategy needs per-turn allocation — the consumer calls the factory once at turn entry with a per-turn input bundle, and the returned detector instance is discarded at turn end. The other strategy slots above are per-runtime singletons the consumer calls many times across many turns.

import { SessionRuntime } from "@pleach/core";
import type { HallucinationDetectorFactory } from "@pleach/core/strategies/hallucinationDetector";

const hallucinationDetectorFactory: HallucinationDetectorFactory = (input) => {
  // Host builds a detector parameterized by this turn's
  // `input.availableToolNames` + `input.intent`. The body calls
  // `feed(chunk)` on every content delta and reads the two getters
  // after the turn settles.
  return /* host implementation */ {} as ReturnType<HallucinationDetectorFactory>;
};

const runtime = new SessionRuntime({
  storage,
  userId: "user_123",
  hallucinationDetectorFactory,
  continuationMetaToolNames: new Set(["set_step_complete", "wait_for_jobs"]),
});

See Providers for the provider-fallback registry shape, Fabrication detection for the broader fabrication-guard surface (separate contract from hallucination detection — fabrication is per-call quantitative pattern matching; hallucination is per-turn narration vs. execution analysis), and the Plugin contract for the plugin counterpart to the strategy injection pattern.

Where to go next