@harness-engineering/orchestrator 0.6.0 → 0.8.0

package/dist/index.d.mts

@@ -1,9 +1,11 @@
-import { Issue, AgentEvent, WorkflowConfig, TokenUsage, ConcernSignal, ScopeTier, EscalationConfig, RoutingDecision, Result, WorkflowDefinition, WorkspaceConfig, HooksConfig, AgentBackend, SessionStartParams, AgentSession, AgentError, TurnParams, TurnResult, CheckScriptDefinition, OutputRetentionConfig, BackendDef, RoutingConfig, RoutingUseCase, ContainerConfig, SecretConfig, AgentConfig, CustomTaskDefinition, TokenScope, AuthToken, AuthTokenPublic, IndexedFileKind, SessionSearchResult, ReindexStats, SessionSummarizationConfig, SessionSummary, SessionSummaryMeta, SessionsConfig, GatewayEvent, NotificationEnvelope, NotificationDeliveryResult, NotificationSinkConfig, NotificationsConfig } from '@harness-engineering/types';
+import * as _harness_engineering_types from '@harness-engineering/types';
+import { Issue, AgentEvent, WorkflowConfig, TokenUsage, ConcernSignal, ScopeTier, EscalationConfig, IssueRoutingDecision, Result, WorkflowDefinition, BackendDef, RoutingConfig, WorkspaceConfig, HooksConfig, AgentBackend, SessionStartParams, AgentSession, AgentError, TurnParams, TurnResult, CheckScriptDefinition, OutputRetentionConfig, RoutingDecision, RoutingUseCase, ContainerConfig, SecretConfig, AgentConfig, LocalModelStatus, CustomTaskDefinition, TokenScope, AuthToken, AuthTokenPublic, IndexedFileKind, SessionSearchResult, ReindexStats, SessionSummarizationConfig, SessionSummary, SessionSummaryMeta, SessionsConfig, GatewayEvent, NotificationEnvelope, NotificationDeliveryResult, NotificationSinkConfig, NotificationsConfig } from '@harness-engineering/types';
 import { IssueTrackerClient, Issue as Issue$1, TrackerConfig, CacheMetricsRecorder, ArchiveHooks, SkillProposal, ProposalGateFinding } from '@harness-engineering/core';
 import { EnrichedSpec, ComplexityScore, SimulationResult, IntelligencePipeline, WeightedRecommendation, AnalysisProvider } from '@harness-engineering/intelligence';
 import { GraphStore } from '@harness-engineering/graph';
 import { execFile } from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import { z } from 'zod';
 
 /**
  * Run attempt lifecycle phases (internal to orchestrator).
@@ -366,6 +368,10 @@ interface TickEvent {
     simulationResults?: Map<string, SimulationResult>;
     /** Pre-computed persona recommendations from specialization scorer (issueId -> recommendations) */
     personaRecommendations?: Map<string, WeightedRecommendation[]>;
+    /** Identity of this orchestrator. Items assigned to a different value are
+     *  filtered out of dispatch by `selectCandidates`. Omit for back-compat
+     *  (preserves today's permissive behavior). */
+    selfAssignee?: string;
 }
 interface WorkerExitEvent {
     type: 'worker_exit';
@@ -485,11 +491,11 @@ declare function sortCandidates(issues: readonly Issue[]): Issue[];
  * Check if a single issue is dispatch-eligible.
  * State comparisons are case-insensitive.
  */
-declare function isEligible(issue: Issue, state: OrchestratorState, activeStates: string[], terminalStates: string[]): boolean;
+declare function isEligible(issue: Issue, state: OrchestratorState, activeStates: string[], terminalStates: string[], selfAssignee?: string | null): boolean;
 /**
  * Select and sort eligible candidates from a list of issues.
  */
-declare function selectCandidates(issues: readonly Issue[], state: OrchestratorState, activeStates: string[], terminalStates: string[]): Issue[];
+declare function selectCandidates(issues: readonly Issue[], state: OrchestratorState, activeStates: string[], terminalStates: string[], selfAssignee?: string | null): Issue[];
 
 /**
  * Get the number of available global concurrency slots.
@@ -549,7 +555,7 @@ declare function detectScopeTier(issue: Issue, artifacts: ArtifactPresence): Sco
  * 4. If tier is in signalGated -> check concern signals
  * 5. Otherwise -> dispatch-local (safe default)
  */
-declare function routeIssue(scopeTier: ScopeTier, concernSignals: ConcernSignal[], config: EscalationConfig): RoutingDecision;
+declare function routeIssue(scopeTier: ScopeTier, concernSignals: ConcernSignal[], config: EscalationConfig): IssueRoutingDecision;
 
 /**
  * Candidate skills the orchestrator may dispatch to. Keep this set
@@ -864,9 +870,107 @@ declare class WorkflowLoader {
     loadWorkflow(filePath: string): Promise<Result<WorkflowDefinition, Error>>;
 }
 
-declare function validateWorkflowConfig(config: unknown): Result<WorkflowConfig, Error>;
+/**
+ * Cross-field check: every value in `routing` must reference a key in
+ * `backends`. Mirrors the Phase 1 standalone helper but returns a flat
+ * array of issues for synchronous consumption inside
+ * `validateWorkflowConfig` (which is hand-rolled, not a Zod parse).
+ *
+ * Exported for unit testing. Production callers should prefer
+ * `validateWorkflowConfig` (which wraps this helper with the surrounding
+ * legacy-vs-modern branching).
+ */
+declare function crossFieldRoutingIssues(backends: Record<string, BackendDef>, routing: RoutingConfig): Array<{
+    path: string[];
+    message: string;
+}>;
+/**
+ * Spec B Phase 2 / S3: produce non-blocking warnings for misconfigured
+ * routing entries that are SYNTACTICALLY valid (the cross-field check
+ * has passed) but SEMANTICALLY suspicious:
+ *
+ *  - `routing.skills.<name>` where `<name>` is not in the local skill
+ *    catalog. Likely a typo or a skill that was renamed / removed.
+ *
+ *  - `routing.modes.<mode>` where `<mode>` is not in the
+ *    STANDARD_COGNITIVE_MODES tuple. Since `CognitiveMode` allows the
+ *    `(string & {})` escape hatch, the type system accepts custom modes
+ *    — but operators are far more likely to typo a standard mode than
+ *    introduce a custom one, so we warn.
+ *
+ * Returns an empty array when `knownSkillNames` is empty (i.e., the
+ * catalog could not be discovered — most likely because `agents/skills/`
+ * is absent). Skipping is preferable to flooding the operator with
+ * false positives when the catalog itself is missing.
+ *
+ * Warnings are advisory; the loader continues to return `Ok` and the
+ * orchestrator starts normally.
+ */
+declare function routingWarnings(routing: RoutingConfig, knownSkillNames: readonly string[]): string[];
+interface ValidateWorkflowConfigOptions {
+    /**
+     * Known skill names from the local catalog. When non-empty, used to
+     * warn (S3) on `routing.skills.<name>` references that are not in
+     * the catalog. When empty, skill-name warnings are suppressed — the
+     * caller is presumed to be running without a discoverable catalog
+     * (e.g., tests, or orchestrator outside a harness project root).
+     */
+    knownSkillNames?: readonly string[];
+}
+interface ValidatedWorkflowConfig {
+    config: WorkflowConfig;
+    /**
+     * Non-blocking warnings produced during validation. Currently
+     * includes (Spec B Phase 2 / S3):
+     *   - `routing.skills.<name>` not in the local catalog
+     *   - `routing.modes.<mode>` not in `STANDARD_COGNITIVE_MODES`
+     */
+    warnings: readonly string[];
+}
+declare function validateWorkflowConfig(config: unknown, options?: ValidateWorkflowConfigOptions): Result<ValidatedWorkflowConfig, Error>;
 declare function getDefaultConfig(): WorkflowConfig;
 
+/**
+ * Spec B Phase 3: an entry in the local skill catalog.
+ *
+ * Carries the skill's catalog `name` AND optional `cognitive_mode`
+ * declaration from `skill.yaml`. Consumed by the orchestrator dispatch
+ * site to construct `{ kind: 'skill', skillName, cognitiveMode }`
+ * RoutingUseCases so per-skill / per-mode routing fires at dispatch.
+ */
+interface SkillCatalogEntry {
+    readonly name: string;
+    readonly cognitiveMode?: string;
+}
+/**
+ * Spec B Phase 3: read the local skill catalog at orchestrator startup,
+ * returning each declared skill's `name` AND optional `cognitive_mode`.
+ *
+ * Reads from EVERY host subdirectory under `agents/skills/` (claude-code,
+ * cursor, gemini, etc.). Names are deduplicated across hosts — first
+ * occurrence wins (matches Phase 2 behavior for `discoverSkillCatalogNames`).
+ *
+ * Returns an empty array when `agents/skills/` is absent (orchestrator
+ * running outside a harness project root). In that case dispatch-site
+ * routing falls through to per-tier resolution, preserving today's
+ * behavior (F11/N2).
+ *
+ * Errors reading individual skill.yaml files (malformed YAML, missing
+ * `name` field, IO errors) are swallowed silently. The catalog is
+ * advisory; a single broken skill.yaml should not block dispatch.
+ */
+declare function discoverSkillCatalog(projectRoot: string): SkillCatalogEntry[];
+/**
+ * Spec B Phase 2: read the local skill catalog at orchestrator startup
+ * for warning-level routing validation (`routing.skills.<name>` where
+ * `<name>` is not in the catalog).
+ *
+ * Spec B Phase 3: thin alias over {@link discoverSkillCatalog} — name
+ * extraction preserved for the Phase 2 WorkflowLoader → validation
+ * pipeline (no behavioral change for Phase 2 callers).
+ */
+declare function discoverSkillCatalogNames(projectRoot: string): string[];
+
 /**
  * Adapter for using a markdown roadmap file as an issue tracker.
  *
@@ -1254,6 +1358,144 @@ interface MaintenanceStatus {
     history: RunResult[];
 }
 
+interface RoutingDecisionBusFilter {
+    skillName?: string;
+    mode?: string;
+    backendName?: string;
+    limit?: number;
+}
+interface RoutingDecisionBusOptions {
+    /** Default 500. Bound on the in-memory ring buffer. */
+    capacity?: number;
+    /**
+     * Logger for the structured `routing-decision` line (O1) and for
+     * one-off warn() when a subscriber throws (S6). When omitted, the
+     * bus silently swallows subscriber errors (test-mode default).
+     */
+    logger?: StructuredLogger;
+}
+/**
+ * Spec B Phase 4 (D8): in-process bus + ring buffer for
+ * {@link RoutingDecision} events. One emit() per
+ * {@link BackendRouter.resolve} call; subscribers receive the
+ * decision synchronously after the ring buffer is updated.
+ *
+ * Subscriber errors are isolated (caught + logged, never thrown
+ * back to the emitter) so a misbehaving subscriber cannot block a
+ * dispatch. (S6)
+ *
+ * Capacity-bound (default 500) via Array.shift() — acceptable for
+ * v1 (see plan C4); switch to circular indexing if 24h dispatch
+ * volume ever pushes 10K+ records/min.
+ */
+declare class RoutingDecisionBus {
+    private readonly ringBuffer;
+    private readonly listeners;
+    private readonly capacity;
+    private readonly logger;
+    constructor(opts?: RoutingDecisionBusOptions);
+    emit(decision: RoutingDecision): void;
+    recent(filter?: RoutingDecisionBusFilter): RoutingDecision[];
+    subscribe(listener: (d: RoutingDecision) => void): () => void;
+    /**
+     * Spec B Phase 5 (review-S2 fix): release all subscriber references so
+     * teardown can complete without anchoring closures. Called from
+     * `Orchestrator.stop()` before nulling the bus reference. The bus
+     * remains usable after clear — `subscribe()` works as normal.
+     */
+    clearListeners(): void;
+}
+
+interface BackendRouterOptions {
+    backends: Record<string, BackendDef>;
+    routing: RoutingConfig;
+    /**
+     * Spec B Phase 4 (D8): when present, every resolve() emits its
+     * decision onto the bus. The bus owns the structured log line + ring
+     * buffer; the router stays a pure resolution function.
+     */
+    decisionBus?: RoutingDecisionBus;
+}
+/**
+ * BackendRouter (Spec B Phase 1)
+ *
+ * Owns the lookup from a {@link RoutingUseCase} (a discriminated query
+ * — tier, intelligence layer, maintenance, chat, isolation, **skill**,
+ * **mode**) to a {@link RoutingDecision} naming a chosen backend and
+ * the full resolution path that produced it.
+ *
+ * Resolution order (D2): invocation override -> per-skill -> per-mode
+ * -> existing per-tier/intelligence/isolation/maintenance/chat ->
+ * `routing.default`. Within each source, fallback chain entries are
+ * tried in declared order; first existing backend wins. Unknown
+ * entries are recorded with `outcome: 'unknown-backend'` and the walk
+ * continues.
+ *
+ * Construction-time validation guarantees every name referenced by
+ * `routing` is present in `backends` so the static-config case can
+ * never produce a runtime exhaustion throw. The runtime throw at the
+ * end of `resolve()` is a safety net for future dynamic-backends
+ * scenarios where a chain entry can become unknown post-construction.
+ */
+declare class BackendRouter {
+    private readonly backends;
+    private readonly routing;
+    private readonly decisionBus;
+    constructor(opts: BackendRouterOptions);
+    /**
+     * Resolve a {@link RoutingUseCase} to a {@link RoutingDecision}.
+     *
+     * @param useCase the routing query
+     * @param opts.invocationOverride if set and the named backend exists,
+     *   beats all other sources (D7 — the `--backend <name>` escape hatch)
+     */
+    resolve(useCase: RoutingUseCase, opts?: {
+        invocationOverride?: string;
+    }): RoutingDecision;
+    /**
+     * Returns the {@link BackendDef} reference for the resolved name.
+     * Identity-equal to the entry in `backends` (no copy) so callers
+     * relying on reference equality (SC21) continue to work.
+     */
+    resolveDefinition(useCase: RoutingUseCase, opts?: {
+        invocationOverride?: string;
+    }): BackendDef;
+    /**
+     * Spec B Phase 4 (closes P1-IMP-2): a single resolve() + def lookup
+     * for callers that need both. Replaces the previous pattern of
+     * `resolveDefinition(useCase) + resolve(useCase)` which produced two
+     * RoutingDecision emissions per dispatch — doubling routing-decision
+     * log volume now that Phase 4 emits.
+     *
+     * Identity-equal `BackendDef` (no copy) so callers relying on
+     * reference equality (SC21) continue to work.
+     */
+    resolveDecisionAndDef(useCase: RoutingUseCase, opts?: {
+        invocationOverride?: string;
+    }): {
+        decision: RoutingDecision;
+        def: BackendDef;
+    };
+    /**
+     * The pre-Spec-B resolution helper: returns the configured
+     * {@link RoutingValue} for tier/intelligence/isolation/maintenance/chat
+     * use cases (or `undefined` for skill/mode use cases, which are owned
+     * by the per-skill / per-mode steps in {@link resolve}). Returning
+     * `undefined` lets the caller fall through to `routing.default`.
+     */
+    private resolveExistingUseCase;
+    private validateReferences;
+}
+
+/**
+ * The central orchestrator that manages the lifecycle of coding agents.
+ *
+ * It polls an issue tracker for candidate tasks, manages ephemeral workspaces,
+ * runs agents to resolve issues, and updates the tracker with progress.
+ *
+ * @fires Orchestrator#state_change Emitted when the internal state machine transitions
+ * @fires Orchestrator#agent_event Emitted when an agent produces an output or thought
+ */
 declare class Orchestrator extends EventEmitter {
     private state;
     private config;
@@ -1278,6 +1520,14 @@ declare class Orchestrator extends EventEmitter {
      * construction time. Eliminating this fallback is autopilot Phase 4+.
      */
     private backendFactory;
+    /**
+     * Spec B Phase 4 (D8): per-orchestrator in-process bus for
+     * `RoutingDecision` events. Constructed alongside backendFactory when
+     * agent.backends synthesis succeeds; null when legacy single-backend
+     * config bypassed backends. Phase 5+ consumers (HTTP, WS, dashboard)
+     * subscribe via `getRoutingDecisionBus()`.
+     */
+    private routingDecisionBus;
     /**
      * Test-only: when overrides.backend is provided, dispatch uses this
      * instance directly (bypassing the factory). Mirrors Phase 1
@@ -1300,6 +1550,15 @@ declare class Orchestrator extends EventEmitter {
      * so this map is the single source of truth post-migration.
      */
     private localResolvers;
+    /**
+     * Spec B Phase 3: skill catalog (name + cognitiveMode) read once at
+     * construction from `projectRoot/agents/skills/`. Consulted by
+     * `buildRoutingUseCase` at dispatch start to construct
+     * `{ kind: 'skill', skillName, cognitiveMode }` RoutingUseCases.
+     * Empty when the orchestrator runs outside a harness project root
+     * (then dispatch falls through to per-tier, preserving F11/N2).
+     */
+    private readonly skillCatalog;
     /**
      * Per-resolver `onStatusChange` unsubscribe callbacks. Spec 2 Phase 5
      * (SC39): each local/pi resolver gets its own listener emitting a
@@ -1482,6 +1741,34 @@ declare class Orchestrator extends EventEmitter {
      * Returns a point-in-time snapshot of the orchestrator's internal state.
      */
     getSnapshot(): Record<string, unknown>;
+    /**
+     * Spec B Phase 4 (D8): expose the bus for Phase 5 (HTTP routes) and
+     * Phase 7 (dashboard WS broadcast). Returns null when the legacy
+     * single-backend config bypassed agent.backends synthesis.
+     */
+    getRoutingDecisionBus(): RoutingDecisionBus | null;
+    /**
+     * Spec B Phase 5: live BackendRouter for HTTP routes. The orchestrator
+     * dispatch path uses the factory-owned router directly; observability
+     * routes (config / decisions) reach it through this accessor. Returns
+     * null when the legacy single-backend config bypassed agent.backends
+     * synthesis (no backendFactory built).
+     */
+    getBackendRouter(): BackendRouter | null;
+    /**
+     * Spec B Phase 5: snapshot of the active RoutingConfig for the config
+     * route and the trace route's bus-less router construction. Returns
+     * null when the operator's harness.config.json carries no
+     * `agent.routing` block.
+     */
+    getRoutingConfig(): _harness_engineering_types.RoutingConfig | null;
+    /**
+     * Spec B Phase 5: snapshot of `agent.backends` for the config route
+     * (existence annotations) and the trace route (bus-less router
+     * construction). Returns null when no synthesized backends map exists
+     * (legacy single-backend configs).
+     */
+    getBackends(): Record<string, _harness_engineering_types.BackendDef> | null;
     /** Returns the maintenance scheduler status, or null if maintenance is not enabled. */
     getMaintenanceStatus(): MaintenanceStatus | null;
 }
@@ -1497,47 +1784,6 @@ declare function launchTUI(orchestrator: Orchestrator): {
     waitUntilExit: () => Promise<void>;
 };
 
-interface BackendRouterOptions {
-    backends: Record<string, BackendDef>;
-    routing: RoutingConfig;
-}
-/**
- * BackendRouter
- *
- * Owns the lookup from a `RoutingUseCase` (a discriminated query — tier,
- * intelligence layer, maintenance, chat) to a named backend.
- * Construction-time validation guarantees every name referenced by
- * `routing` is present in `backends` so runtime lookups are total and
- * never throw on unknown-name references (D6/D7).
- *
- * Lookups for tier/intelligence use cases that fall through to undefined
- * mappings return `routing.default` without throwing — this matches the
- * spec's "every use case inherits default unless explicitly routed"
- * semantics. The `maintenance` and `chat` kinds always resolve to
- * `routing.default` (SC19, SC20).
- */
-declare class BackendRouter {
-    private readonly backends;
-    private readonly routing;
-    constructor(opts: BackendRouterOptions);
-    /**
-     * Returns the backend name for a given use case.
-     *
-     * - `tier`: per-tier override, falling back to `routing.default`.
-     * - `intelligence`: per-layer override under `routing.intelligence`,
-     *   falling back to `routing.default`.
-     * - `maintenance` / `chat`: always `routing.default`.
-     */
-    resolve(useCase: RoutingUseCase): string;
-    /**
-     * Returns the BackendDef reference for the resolved name. Returns the
-     * exact reference held in `backends` (no copy) so identity comparisons
-     * succeed (SC21).
-     */
-    resolveDefinition(useCase: RoutingUseCase): BackendDef;
-    private validateReferences;
-}
-
 /**
  * Options for `OrchestratorBackendFactory`.
  *
@@ -1572,6 +1818,11 @@ interface OrchestratorBackendFactoryOptions {
      * `/api/v1/telemetry/cache/stats` endpoint sees the full rolling window.
      */
     cacheMetrics?: CacheMetricsRecorder;
+    /**
+     * Spec B Phase 4 (D8): forwarded to the underlying BackendRouter so
+     * every resolve() during forUseCase / resolveName emits.
+     */
+    decisionBus?: RoutingDecisionBus;
 }
 /**
  * High-level factory wrapping `BackendRouter` + `createBackend` plus
@@ -1604,8 +1855,19 @@ declare class OrchestratorBackendFactory {
      * is `undefined` for pure-modern configs. Threading the routed name
      * through dispatch eliminates that gap.
      */
-    resolveName(useCase: RoutingUseCase): string;
-    forUseCase(useCase: RoutingUseCase): AgentBackend;
+    resolveName(useCase: RoutingUseCase, opts?: {
+        invocationOverride?: string;
+    }): string;
+    /**
+     * Spec B Phase 1: expose the underlying router for callers that need
+     * it directly (e.g., {@link buildIntelligencePipeline} for the
+     * I1 SEL/PESL comparison fix). Read-only access; consumers must not
+     * mutate router state.
+     */
+    getRouter(): BackendRouter;
+    forUseCase(useCase: RoutingUseCase, opts?: {
+        invocationOverride?: string;
+    }): AgentBackend;
     /**
      * Rebuild a `local`/`pi` backend with a resolver-bound `getModel`,
      * mirroring `createBackend`'s local/pi branches but substituting the
@@ -1660,6 +1922,270 @@ interface CreateBackendOptions {
  */
 declare function createBackend(def: BackendDef, options?: CreateBackendOptions): AgentBackend;
 
+/**
+ * Zod schema for `BackendDef` (Spec 2 — multi-backend routing).
+ *
+ * Discriminated union on `type`. Per-variant validation surfaces shape
+ * mismatches (missing `model`, missing `endpoint`, etc.) at config-load
+ * time rather than at orchestrator runtime.
+ *
+ * Used in Phase 3 by `validateWorkflowConfig`; in Phase 1 it is exported
+ * for standalone unit testing.
+ */
+declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"mock">;
+}, "strict", z.ZodTypeAny, {
+    type: "mock";
+}, {
+    type: "mock";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"claude">;
+    command: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "claude";
+    command?: string | undefined;
+}, {
+    type: "claude";
+    command?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"anthropic">;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "anthropic";
+    model: string;
+    apiKey?: string | undefined;
+}, {
+    type: "anthropic";
+    model: string;
+    apiKey?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"openai">;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "openai";
+    model: string;
+    apiKey?: string | undefined;
+}, {
+    type: "openai";
+    model: string;
+    apiKey?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"gemini">;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "gemini";
+    model: string;
+    apiKey?: string | undefined;
+}, {
+    type: "gemini";
+    model: string;
+    apiKey?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"local">;
+    endpoint: z.ZodString;
+    model: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "atleastone">]>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    probeIntervalMs: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "local";
+    model: string | [string, ...string[]];
+    endpoint: string;
+    apiKey?: string | undefined;
+    timeoutMs?: number | undefined;
+    probeIntervalMs?: number | undefined;
+}, {
+    type: "local";
+    model: string | [string, ...string[]];
+    endpoint: string;
+    apiKey?: string | undefined;
+    timeoutMs?: number | undefined;
+    probeIntervalMs?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pi">;
+    endpoint: z.ZodString;
+    model: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "atleastone">]>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    probeIntervalMs: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "pi";
+    model: string | [string, ...string[]];
+    endpoint: string;
+    apiKey?: string | undefined;
+    timeoutMs?: number | undefined;
+    probeIntervalMs?: number | undefined;
+}, {
+    type: "pi";
+    model: string | [string, ...string[]];
+    endpoint: string;
+    apiKey?: string | undefined;
+    timeoutMs?: number | undefined;
+    probeIntervalMs?: number | undefined;
+}>]>;
+/**
+ * Spec B Phase 0: a routing target is either a backend name (scalar
+ * string) or a non-empty ordered fallback chain (string tuple). The
+ * scalar form is byte-compatible with pre-Spec-B configs.
+ */
+declare const RoutingValueSchema: z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>;
+/**
+ * Zod schema for `RoutingConfig`. `.strict()` rejects unknown keys at
+ * every level (per Spec 2 D7: typos in routing keys are validation
+ * errors, not silent default-fallthroughs).
+ *
+ * Spec B Phase 0: all scalar routing fields accept `RoutingValueSchema`
+ * (scalar or non-empty chain). New optional `skills` and `modes` maps
+ * accept the same.
+ *
+ * Spec B Phase 2: the `isolation` block (added to the TS interface in
+ * Hermes Phase 5 but not previously in this Zod schema) is now included
+ * here with each tier widened to `RoutingValueSchema`. This closes the
+ * Phase 0 I2 review finding (TS-vs-Zod drift) and ensures isolation
+ * chain entries are validated by the same cross-field check that
+ * covers `skills` / `modes`.
+ */
+declare const RoutingConfigSchema: z.ZodObject<{
+    default: z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>;
+    'quick-fix': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    'guided-change': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    'full-exploration': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    diagnostic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    intelligence: z.ZodOptional<z.ZodObject<{
+        sel: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+        pesl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    }, "strict", z.ZodTypeAny, {
+        sel?: string | readonly [string, ...string[]] | undefined;
+        pesl?: string | readonly [string, ...string[]] | undefined;
+    }, {
+        sel?: string | readonly [string, ...string[]] | undefined;
+        pesl?: string | readonly [string, ...string[]] | undefined;
+    }>>;
+    isolation: z.ZodOptional<z.ZodObject<{
+        none: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+        container: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+        'remote-sandbox': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>;
+    }, "strict", z.ZodTypeAny, {
+        none?: string | readonly [string, ...string[]] | undefined;
+        container?: string | readonly [string, ...string[]] | undefined;
+        'remote-sandbox'?: string | readonly [string, ...string[]] | undefined;
+    }, {
+        none?: string | readonly [string, ...string[]] | undefined;
+        container?: string | readonly [string, ...string[]] | undefined;
+        'remote-sandbox'?: string | readonly [string, ...string[]] | undefined;
+    }>>;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>>;
+    modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>>;
+}, "strict", z.ZodTypeAny, {
+    default: string | readonly [string, ...string[]];
+    'quick-fix'?: string | readonly [string, ...string[]] | undefined;
+    'guided-change'?: string | readonly [string, ...string[]] | undefined;
+    'full-exploration'?: string | readonly [string, ...string[]] | undefined;
+    diagnostic?: string | readonly [string, ...string[]] | undefined;
+    intelligence?: {
+        sel?: string | readonly [string, ...string[]] | undefined;
+        pesl?: string | readonly [string, ...string[]] | undefined;
+    } | undefined;
+    isolation?: {
+        none?: string | readonly [string, ...string[]] | undefined;
+        container?: string | readonly [string, ...string[]] | undefined;
+        'remote-sandbox'?: string | readonly [string, ...string[]] | undefined;
+    } | undefined;
+    skills?: Record<string, string | readonly [string, ...string[]]> | undefined;
+    modes?: Record<string, string | readonly [string, ...string[]]> | undefined;
+}, {
+    default: string | readonly [string, ...string[]];
+    'quick-fix'?: string | readonly [string, ...string[]] | undefined;
+    'guided-change'?: string | readonly [string, ...string[]] | undefined;
+    'full-exploration'?: string | readonly [string, ...string[]] | undefined;
+    diagnostic?: string | readonly [string, ...string[]] | undefined;
+    intelligence?: {
+        sel?: string | readonly [string, ...string[]] | undefined;
+        pesl?: string | readonly [string, ...string[]] | undefined;
+    } | undefined;
+    isolation?: {
+        none?: string | readonly [string, ...string[]] | undefined;
+        container?: string | readonly [string, ...string[]] | undefined;
+        'remote-sandbox'?: string | readonly [string, ...string[]] | undefined;
+    } | undefined;
+    skills?: Record<string, string | readonly [string, ...string[]]> | undefined;
+    modes?: Record<string, string | readonly [string, ...string[]]> | undefined;
+}>;
+
+interface ResolverLogger {
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+}
+interface LocalModelResolverOptions {
+    endpoint: string;
+    apiKey?: string;
+    /** Normalized candidate list (already turned from string|string[] into string[]). */
+    configured: string[];
+    /** Probe cadence in ms; default 30_000, minimum 1_000. */
+    probeIntervalMs?: number;
+    /**
+     * Per-request timeout for the default fetch implementation, in ms.
+     * Default: 5_000. Ignored when a custom `fetchModels` is provided
+     * (custom impls own their own timeout policy). Spec §3.1 line 136
+     * enumerates timeout as a supported failure mode.
+     */
+    timeoutMs?: number;
+    /**
+     * Injectable for tests. Default: GET `${endpoint}/models` with bearer apiKey.
+     * Resolves to detected model IDs. Rejects on network/timeout/non-2xx/malformed.
+     */
+    fetchModels?: (endpoint: string, apiKey?: string) => Promise<string[]>;
+    logger?: ResolverLogger;
+}
+declare function normalizeLocalModel(input: string | string[] | undefined): string[];
+/**
+ * Default `fetchModels` — GET `${endpoint}/models` with bearer apiKey.
+ * Throws on network failure, non-2xx, malformed body, or timeout.
+ *
+ * `timeoutMs` defaults to 5_000. A timeout aborts the in-flight request and
+ * surfaces as `Error('request timeout (Nms)')` so callers can distinguish it
+ * from generic network errors.
+ */
+declare function defaultFetchModels(endpoint: string, apiKey?: string, timeoutMs?: number): Promise<string[]>;
+declare class LocalModelResolver {
+    private readonly endpoint;
+    private readonly apiKey?;
+    private readonly configured;
+    private readonly probeIntervalMs;
+    private readonly fetchModels;
+    private readonly logger;
+    private timer;
+    private listeners;
+    /**
+     * Tracks an in-flight probe so concurrent invocations (interval tick while a
+     * slow probe is running, or a manual `probe()` call mid-flight) share the
+     * existing promise instead of racing to mutate `detected/resolved/lastError/
+     * warnings` non-atomically across `await` points. Applies to both the timer
+     * callback and direct `probe()` calls — any caller that arrives during an
+     * in-flight probe gets the same promise back. Cleared in `finally` so the
+     * next tick can start a fresh probe.
+     */
+    private probeInFlight;
+    private resolved;
+    private detected;
+    private lastProbeAt;
+    private lastError;
+    private warnings;
+    private available;
+    constructor(opts: LocalModelResolverOptions);
+    resolveModel(): string | null;
+    getStatus(): LocalModelStatus;
+    onStatusChange(handler: (status: LocalModelStatus) => void): () => void;
+    probe(): Promise<LocalModelStatus>;
+    private runProbe;
+    start(): Promise<void>;
+    stop(): void;
+    private snapshotForDiff;
+}
+
 /**
  * Function signature compatible with Node's `child_process.execFile`.
  * Allows injection for testing.
@@ -2291,4 +2817,4 @@ declare function emitProposalCreated(bus: EventEmitter, proposal: SkillProposal)
 declare function emitProposalApproved(bus: EventEmitter, proposal: SkillProposal): void;
 declare function emitProposalRejected(bus: EventEmitter, proposal: SkillProposal): void;
 
-export { type AgentUpdateEvent, AnalysisArchive, type AnalysisRecord, type ApplyEventResult, type ArtifactPresence, type AttemptStats, BUILT_IN_TASKS, BackendRouter, type BackendRouterOptions, type BaseRefFallbackEvent, type BuildArchiveHooksOptions, ClaimManager, type ClaimManagerConfig, type CleanWorkspaceEffect, type CreateTokenInput, type CreateTokenResult, type CustomTaskValidationError, type DispatchEffect, type EmitLogEffect, type EscalateEffect, type ExecFileFn$1 as ExecFileFn, type FromConfigOptions, GateNotReadyError, type GateResult, GateRunError, type Highlight, type HighlightsInfo, type IndexedDoc, InteractionQueue, type LinearGraphQLExtension, LinearGraphQLStub, type LiveSession, MAX_ATTEMPTS, type MigrationResult, MockBackend, type NotificationSink, type NotificationSinkDeliverInput, ORCHESTRATOR_IDENTITY_FILE, Orchestrator, OrchestratorBackendFactory, type OrchestratorBackendFactoryOptions, type OrchestratorContext, type OrchestratorEvent, type OrchestratorState, PRDetector, type PRDetectorLogger, type PendingInteraction, type PersistedOutputEntry, PromotionError, type PromotionResult, PromptRenderer, type ProposalApprovedData, type ProposalCreatedData, type ProposalRejectedData, type PublishedIndex, type QueueInsertInput, type QueueRow, type QueueStats, RETRY_DELAYS_MS, type RateLimitSnapshot as RateLimitComputeSnapshot, type RateLimitConfig, type RateLimitSnapshot$1 as RateLimitSnapshot, type RegistryEntry, type ReleaseClaimEffect, type RetryEntry, type RetryFiredEvent, RoadmapTrackerAdapter, type RunAttemptPhase, type RunOrigin, type RunningEntry, type ScheduleRetryEffect, type SearchOptions, type SideEffect, SinkConfigError, SinkRegistry, SlackSink, type SlackSinkOptions, SqliteSearchIndex, type StallDetectedEvent, type StopEffect, type StreamManifest, StreamRecorder, type SummarizeContext, type SummarizeResult, type SyncMainOptions, type SyncMainResult, type SyncSkipReason, type TaskDefinition, TaskOutputStore, type TaskType, type TickEvent, TokenStore, type TokenTotals, type TriageConfig, type TriageDecision, type TriageSignals, type TriageSkill, type UpdateTokensEffect, WebhookQueue, type WorkerExitEvent, WorkflowLoader, WorkspaceHooks, WorkspaceManager, type WorkspaceManagerOptions, applyEvent, artifactPresenceFromIssue, buildArchiveHooks, calculateRetryDelay, canDispatch, computeRateLimitDelay, createBackend, createEmptyState, detectScopeTier, emitProposalApproved, emitProposalCreated, emitProposalRejected, extractHighlights, extractTitlePrefix, getAvailableSlots, getDefaultConfig, getPerStateCount, indexSessionDirectory, isEligible, isSummaryEnabled, launchTUI, loadPublishedIndex, migrateAgentConfig, normalizeFts5Query, openSearchIndex, promote, reconcile, reindexFromArchive, renderAnalysisComment, renderLlmSummaryMarkdown, renderPRComment, resolveEscalationConfig, resolveOrchestratorId, routeIssue, runGate, savePublishedIndex, searchIndexPath, selectCandidates, sortCandidates, summarizeArchivedSession, syncMain, triageIssue, truncateForBudget, validateCustomTasks, validateWorkflowConfig, wireNotificationSinks, wrapAsEnvelope };
+export { type AgentUpdateEvent, AnalysisArchive, type AnalysisRecord, type ApplyEventResult, type ArtifactPresence, type AttemptStats, BUILT_IN_TASKS, BackendDefSchema, BackendRouter, type BackendRouterOptions, type BaseRefFallbackEvent, type BuildArchiveHooksOptions, ClaimManager, type ClaimManagerConfig, type CleanWorkspaceEffect, type CreateTokenInput, type CreateTokenResult, type CustomTaskValidationError, type DispatchEffect, type EmitLogEffect, type EscalateEffect, type ExecFileFn$1 as ExecFileFn, type FromConfigOptions, GateNotReadyError, type GateResult, GateRunError, type Highlight, type HighlightsInfo, type IndexedDoc, InteractionQueue, type LinearGraphQLExtension, LinearGraphQLStub, type LiveSession, LocalModelResolver, type LocalModelResolverOptions, MAX_ATTEMPTS, type MigrationResult, MockBackend, type NotificationSink, type NotificationSinkDeliverInput, ORCHESTRATOR_IDENTITY_FILE, Orchestrator, OrchestratorBackendFactory, type OrchestratorBackendFactoryOptions, type OrchestratorContext, type OrchestratorEvent, type OrchestratorState, PRDetector, type PRDetectorLogger, type PendingInteraction, type PersistedOutputEntry, PromotionError, type PromotionResult, PromptRenderer, type ProposalApprovedData, type ProposalCreatedData, type ProposalRejectedData, type PublishedIndex, type QueueInsertInput, type QueueRow, type QueueStats, RETRY_DELAYS_MS, type RateLimitSnapshot as RateLimitComputeSnapshot, type RateLimitConfig, type RateLimitSnapshot$1 as RateLimitSnapshot, type RegistryEntry, type ReleaseClaimEffect, type ResolverLogger, type RetryEntry, type RetryFiredEvent, RoadmapTrackerAdapter, RoutingConfigSchema, RoutingValueSchema, type RunAttemptPhase, type RunOrigin, type RunningEntry, type ScheduleRetryEffect, type SearchOptions, type SideEffect, SinkConfigError, SinkRegistry, type SkillCatalogEntry, SlackSink, type SlackSinkOptions, SqliteSearchIndex, type StallDetectedEvent, type StopEffect, type StreamManifest, StreamRecorder, type SummarizeContext, type SummarizeResult, type SyncMainOptions, type SyncMainResult, type SyncSkipReason, type TaskDefinition, TaskOutputStore, type TaskType, type TickEvent, TokenStore, type TokenTotals, type TriageConfig, type TriageDecision, type TriageSignals, type TriageSkill, type UpdateTokensEffect, type ValidateWorkflowConfigOptions, type ValidatedWorkflowConfig, WebhookQueue, type WorkerExitEvent, WorkflowLoader, WorkspaceHooks, WorkspaceManager, type WorkspaceManagerOptions, applyEvent, artifactPresenceFromIssue, buildArchiveHooks, calculateRetryDelay, canDispatch, computeRateLimitDelay, createBackend, createEmptyState, crossFieldRoutingIssues, defaultFetchModels, detectScopeTier, discoverSkillCatalog, discoverSkillCatalogNames, emitProposalApproved, emitProposalCreated, emitProposalRejected, extractHighlights, extractTitlePrefix, getAvailableSlots, getDefaultConfig, getPerStateCount, indexSessionDirectory, isEligible, isSummaryEnabled, launchTUI, loadPublishedIndex, migrateAgentConfig, normalizeFts5Query, normalizeLocalModel, openSearchIndex, promote, reconcile, reindexFromArchive, renderAnalysisComment, renderLlmSummaryMarkdown, renderPRComment, resolveEscalationConfig, resolveOrchestratorId, routeIssue, routingWarnings, runGate, savePublishedIndex, searchIndexPath, selectCandidates, sortCandidates, summarizeArchivedSession, syncMain, triageIssue, truncateForBudget, validateCustomTasks, validateWorkflowConfig, wireNotificationSinks, wrapAsEnvelope };