@harness-engineering/orchestrator 0.2.16 → 0.3.0

package/dist/index.mjs

@@ -1771,8 +1771,92 @@ import { parse } from "yaml";
 import { Ok as Ok3, Err as Err2 } from "@harness-engineering/types";
 
 // src/workflow/config.ts
-import { Ok as Ok2, Err } from "@harness-engineering/types";
+import { z as z2 } from "zod";
+import {
+  Ok as Ok2,
+  Err
+} from "@harness-engineering/types";
+
+// src/workflow/schema.ts
+import { z } from "zod";
+var ModelSchema = z.union([z.string().min(1), z.array(z.string().min(1)).nonempty()], {
+  errorMap: () => ({
+    message: "model must be a non-empty string or array of strings"
+  })
+});
+var BackendDefSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("mock") }).strict(),
+  z.object({
+    type: z.literal("claude"),
+    command: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("anthropic"),
+    model: z.string().min(1),
+    apiKey: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("openai"),
+    model: z.string().min(1),
+    apiKey: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("gemini"),
+    model: z.string().min(1),
+    apiKey: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("local"),
+    endpoint: z.string().url(),
+    model: ModelSchema,
+    apiKey: z.string().optional(),
+    timeoutMs: z.number().int().positive().optional(),
+    probeIntervalMs: z.number().int().min(1e3).optional()
+  }).strict(),
+  z.object({
+    type: z.literal("pi"),
+    endpoint: z.string().url(),
+    model: ModelSchema,
+    apiKey: z.string().optional(),
+    timeoutMs: z.number().int().positive().optional(),
+    probeIntervalMs: z.number().int().min(1e3).optional()
+  }).strict()
+]);
+var RoutingConfigSchema = z.object({
+  default: z.string().min(1),
+  "quick-fix": z.string().optional(),
+  "guided-change": z.string().optional(),
+  "full-exploration": z.string().optional(),
+  diagnostic: z.string().optional(),
+  intelligence: z.object({
+    sel: z.string().optional(),
+    pesl: z.string().optional()
+  }).strict().optional()
+}).strict();
+
+// src/workflow/config.ts
 var REQUIRED_SECTIONS = ["tracker", "polling", "workspace", "hooks", "agent", "server"];
+var BackendsMapSchema = z2.record(z2.string(), BackendDefSchema);
+function crossFieldRoutingIssues(backends, routing) {
+  const issues = [];
+  const names = new Set(Object.keys(backends));
+  const checkRef = (path16, name) => {
+    if (name !== void 0 && !names.has(name)) {
+      issues.push({
+        path: path16,
+        message: `routing.${path16.join(".")} references unknown backend '${name}'. Defined: [${[...names].join(", ")}].`
+      });
+    }
+  };
+  checkRef(["default"], routing.default);
+  checkRef(["quick-fix"], routing["quick-fix"]);
+  checkRef(["guided-change"], routing["guided-change"]);
+  checkRef(["full-exploration"], routing["full-exploration"]);
+  checkRef(["diagnostic"], routing.diagnostic);
+  checkRef(["intelligence", "sel"], routing.intelligence?.sel);
+  checkRef(["intelligence", "pesl"], routing.intelligence?.pesl);
+  return issues;
+}
 function validateWorkflowConfig(config) {
   if (!config || typeof config !== "object")
     return Err(new Error("Config is missing or not an object"));
@@ -1783,6 +1867,35 @@ function validateWorkflowConfig(config) {
   if (c.intelligence !== void 0 && (typeof c.intelligence !== "object" || c.intelligence === null)) {
     return Err(new Error("Config intelligence section must be an object if present"));
   }
+  const agent = c.agent ?? {};
+  const hasLegacyBackend = typeof agent.backend === "string" && agent.backend.length > 0;
+  const hasModernBackends = agent.backends !== void 0 && typeof agent.backends === "object" && agent.backends !== null;
+  if (!hasLegacyBackend && !hasModernBackends) {
+    return Err(new Error("Config must define agent.backend or agent.backends."));
+  }
+  if (hasModernBackends) {
+    const backendsParsed = BackendsMapSchema.safeParse(agent.backends);
+    if (!backendsParsed.success) {
+      return Err(new Error(`agent.backends: ${backendsParsed.error.message}`));
+    }
+    const routingParsed = RoutingConfigSchema.optional().safeParse(agent.routing);
+    if (!routingParsed.success) {
+      return Err(new Error(`agent.routing: ${routingParsed.error.message}`));
+    }
+    if (routingParsed.data) {
+      const cross = crossFieldRoutingIssues(
+        backendsParsed.data,
+        routingParsed.data
+      );
+      if (cross.length > 0) {
+        return Err(
+          new Error(
+            `Cross-field: ${cross.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+          )
+        );
+      }
+    }
+  }
   return Ok2(config);
 }
 function getDefaultConfig() {
@@ -2493,9 +2606,9 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { writeTaint } from "@harness-engineering/core";
 import {
   IntelligencePipeline,
-  AnthropicAnalysisProvider,
-  OpenAICompatibleAnalysisProvider,
-  ClaudeCliAnalysisProvider
+  AnthropicAnalysisProvider as AnthropicAnalysisProvider2,
+  OpenAICompatibleAnalysisProvider as OpenAICompatibleAnalysisProvider2,
+  ClaudeCliAnalysisProvider as ClaudeCliAnalysisProvider2
 } from "@harness-engineering/intelligence";
 import { GraphStore } from "@harness-engineering/graph";
 
@@ -3180,6 +3293,428 @@ var AgentRunner = class {
   }
 };
 
+// src/agent/local-model-resolver.ts
+var DEFAULT_PROBE_INTERVAL_MS = 3e4;
+var MIN_PROBE_INTERVAL_MS = 1e3;
+var DEFAULT_API_KEY = "lm-studio";
+var DEFAULT_FETCH_TIMEOUT_MS = 5e3;
+var noopLogger = {
+  info: () => void 0,
+  warn: () => void 0
+};
+async function defaultFetchModels(endpoint, apiKey, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  const url = `${endpoint.replace(/\/$/, "")}/models`;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Authorization: `Bearer ${apiKey ?? DEFAULT_API_KEY}` },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+      throw new Error(`request timeout (${timeoutMs}ms)`, { cause: err });
+    }
+    throw err;
+  }
+  if (!res.ok) {
+    throw new Error(`probe failed: ${res.status} ${res.statusText}`);
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error("malformed /v1/models response");
+  }
+  if (!body || typeof body !== "object" || !Array.isArray(body.data)) {
+    throw new Error("malformed /v1/models response");
+  }
+  const data = body.data;
+  const ids = [];
+  for (const entry of data) {
+    if (!entry || typeof entry !== "object" || typeof entry.id !== "string") {
+      throw new Error("malformed /v1/models response");
+    }
+    ids.push(entry.id);
+  }
+  return ids;
+}
+var LocalModelResolver = class {
+  endpoint;
+  apiKey;
+  configured;
+  probeIntervalMs;
+  fetchModels;
+  logger;
+  timer = null;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * 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.
+   */
+  probeInFlight = null;
+  // Mutable status fields (composed into LocalModelStatus on demand).
+  resolved = null;
+  detected = [];
+  lastProbeAt = null;
+  lastError = null;
+  warnings = [];
+  available = false;
+  constructor(opts) {
+    this.endpoint = opts.endpoint;
+    if (opts.apiKey !== void 0) {
+      this.apiKey = opts.apiKey;
+    }
+    this.configured = [...opts.configured];
+    const interval = opts.probeIntervalMs ?? DEFAULT_PROBE_INTERVAL_MS;
+    this.probeIntervalMs = Math.max(MIN_PROBE_INTERVAL_MS, interval);
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    this.fetchModels = opts.fetchModels ?? ((endpoint, apiKey) => defaultFetchModels(endpoint, apiKey, timeoutMs));
+    this.logger = opts.logger ?? noopLogger;
+  }
+  resolveModel() {
+    return this.resolved;
+  }
+  getStatus() {
+    return {
+      available: this.available,
+      resolved: this.resolved,
+      configured: [...this.configured],
+      detected: [...this.detected],
+      lastProbeAt: this.lastProbeAt,
+      lastError: this.lastError,
+      warnings: [...this.warnings]
+    };
+  }
+  onStatusChange(handler) {
+    this.listeners.add(handler);
+    return () => {
+      this.listeners.delete(handler);
+    };
+  }
+  async probe() {
+    if (this.probeInFlight !== null) {
+      return this.probeInFlight;
+    }
+    const inFlight = this.runProbe().finally(() => {
+      this.probeInFlight = null;
+    });
+    this.probeInFlight = inFlight;
+    return inFlight;
+  }
+  async runProbe() {
+    const before = this.snapshotForDiff();
+    try {
+      const detected = await this.fetchModels(this.endpoint, this.apiKey);
+      this.detected = [...detected];
+      this.lastError = null;
+      this.lastProbeAt = (/* @__PURE__ */ new Date()).toISOString();
+      const match = this.configured.find((id) => detected.includes(id)) ?? null;
+      this.resolved = match;
+      this.available = match !== null;
+      this.warnings = match ? [] : [
+        `No configured local model is loaded. Configured: [${this.configured.join(", ")}]. Detected: [${detected.join(", ")}].`
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "probe failed";
+      this.lastError = message;
+      this.available = false;
+      this.resolved = null;
+      this.warnings = [`Local model probe failed against ${this.endpoint}: ${message}.`];
+      this.logger.warn("local-model-resolver probe failed", {
+        endpoint: this.endpoint,
+        error: message
+      });
+    }
+    const after = this.snapshotForDiff();
+    const status = this.getStatus();
+    if (before !== after) {
+      for (const listener of this.listeners) {
+        try {
+          listener(status);
+        } catch (err) {
+          this.logger.warn("local-model-resolver listener threw", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+    return status;
+  }
+  async start() {
+    if (this.timer !== null) {
+      return;
+    }
+    await this.probe();
+    this.timer = setInterval(() => {
+      void this.probe();
+    }, this.probeIntervalMs);
+    const handle = this.timer;
+    handle.unref?.();
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  snapshotForDiff() {
+    return JSON.stringify({
+      available: this.available,
+      resolved: this.resolved,
+      configured: this.configured,
+      detected: this.detected,
+      lastError: this.lastError,
+      warnings: this.warnings
+    });
+  }
+};
+
+// src/agent/config-migration.ts
+var MIGRATION_GUIDE = "docs/guides/multi-backend-routing.md";
+function migrateAgentConfig(agent) {
+  const warnings = [];
+  const legacyFields = [
+    { path: "agent.backend", present: agent.backend !== void 0 && agent.backend !== "" },
+    { path: "agent.command", present: agent.command !== void 0 },
+    { path: "agent.model", present: agent.model !== void 0 },
+    { path: "agent.apiKey", present: agent.apiKey !== void 0 },
+    { path: "agent.localBackend", present: agent.localBackend !== void 0 },
+    { path: "agent.localEndpoint", present: agent.localEndpoint !== void 0 },
+    { path: "agent.localModel", present: agent.localModel !== void 0 },
+    { path: "agent.localApiKey", present: agent.localApiKey !== void 0 },
+    { path: "agent.localTimeoutMs", present: agent.localTimeoutMs !== void 0 },
+    { path: "agent.localProbeIntervalMs", present: agent.localProbeIntervalMs !== void 0 }
+  ];
+  const presentLegacy = legacyFields.filter((f) => f.present).map((f) => f.path);
+  const CASE1_ALWAYS_SUPPRESS = /* @__PURE__ */ new Set(["agent.backend"]);
+  const CASE1_LOCAL_GROUP = /* @__PURE__ */ new Set([
+    "agent.localBackend",
+    "agent.localEndpoint",
+    "agent.localModel",
+    "agent.localApiKey",
+    "agent.localTimeoutMs",
+    "agent.localProbeIntervalMs"
+  ]);
+  const suppressLocalGroup = agent.localBackend !== void 0;
+  if (agent.backends !== void 0) {
+    for (const path16 of presentLegacy) {
+      if (CASE1_ALWAYS_SUPPRESS.has(path16)) continue;
+      if (suppressLocalGroup && CASE1_LOCAL_GROUP.has(path16)) continue;
+      warnings.push(
+        `Ignoring legacy field '${path16}': 'agent.backends' is set and takes precedence. See ${MIGRATION_GUIDE}.`
+      );
+    }
+    return { config: agent, warnings };
+  }
+  if (presentLegacy.length === 0) {
+    return { config: agent, warnings };
+  }
+  const backends = {};
+  const routing = { default: "primary" };
+  backends.primary = synthesizePrimary(agent);
+  if (agent.localBackend !== void 0) {
+    backends.local = synthesizeLocal(agent);
+  }
+  const autoExec = agent.escalation?.autoExecute ?? [];
+  if (backends.local !== void 0) {
+    for (const tier of autoExec) {
+      routing[tier] = "local";
+    }
+  }
+  for (const path16 of presentLegacy) {
+    warnings.push(
+      `Deprecated config field '${path16}' is in use. Migrate to 'agent.backends' / 'agent.routing'. See ${MIGRATION_GUIDE}.`
+    );
+  }
+  return {
+    config: {
+      ...agent,
+      backends,
+      routing
+    },
+    warnings
+  };
+}
+function synthesizePrimary(agent) {
+  const backend = agent.backend;
+  switch (backend) {
+    case "mock":
+      return { type: "mock" };
+    case "claude": {
+      const def = { type: "claude" };
+      if (agent.command !== void 0) def.command = agent.command;
+      return def;
+    }
+    case "anthropic": {
+      if (agent.model === void 0) {
+        throw new Error("migrateAgentConfig: agent.backend='anthropic' requires agent.model");
+      }
+      const def = { type: "anthropic", model: agent.model };
+      if (agent.apiKey !== void 0) def.apiKey = agent.apiKey;
+      return def;
+    }
+    case "openai": {
+      if (agent.model === void 0) {
+        throw new Error("migrateAgentConfig: agent.backend='openai' requires agent.model");
+      }
+      const def = { type: "openai", model: agent.model };
+      if (agent.apiKey !== void 0) def.apiKey = agent.apiKey;
+      return def;
+    }
+    case "gemini": {
+      if (agent.model === void 0) {
+        throw new Error("migrateAgentConfig: agent.backend='gemini' requires agent.model");
+      }
+      const def = { type: "gemini", model: agent.model };
+      if (agent.apiKey !== void 0) def.apiKey = agent.apiKey;
+      return def;
+    }
+    case "local": {
+      if (agent.localEndpoint === void 0 || agent.localModel === void 0) {
+        throw new Error(
+          "migrateAgentConfig: agent.backend='local' requires agent.localEndpoint and agent.localModel"
+        );
+      }
+      const def = {
+        type: "local",
+        endpoint: agent.localEndpoint,
+        model: agent.localModel
+      };
+      if (agent.localApiKey !== void 0) def.apiKey = agent.localApiKey;
+      if (agent.localTimeoutMs !== void 0) def.timeoutMs = agent.localTimeoutMs;
+      if (agent.localProbeIntervalMs !== void 0)
+        def.probeIntervalMs = agent.localProbeIntervalMs;
+      return def;
+    }
+    case "pi": {
+      if (agent.localEndpoint === void 0 || agent.localModel === void 0) {
+        throw new Error(
+          "migrateAgentConfig: agent.backend='pi' requires agent.localEndpoint and agent.localModel"
+        );
+      }
+      const def = {
+        type: "pi",
+        endpoint: agent.localEndpoint,
+        model: agent.localModel
+      };
+      if (agent.localApiKey !== void 0) def.apiKey = agent.localApiKey;
+      if (agent.localTimeoutMs !== void 0) def.timeoutMs = agent.localTimeoutMs;
+      if (agent.localProbeIntervalMs !== void 0)
+        def.probeIntervalMs = agent.localProbeIntervalMs;
+      return def;
+    }
+    default:
+      throw new Error(
+        `migrateAgentConfig: unknown legacy backend '${String(backend)}'. Expected one of: mock, claude, anthropic, openai, gemini, local, pi.`
+      );
+  }
+}
+function synthesizeLocal(agent) {
+  if (agent.localBackend === void 0) {
+    throw new Error("synthesizeLocal called without agent.localBackend");
+  }
+  if (agent.localEndpoint === void 0 || agent.localModel === void 0) {
+    throw new Error(
+      "migrateAgentConfig: agent.localBackend requires agent.localEndpoint and agent.localModel"
+    );
+  }
+  if (agent.localBackend === "pi") {
+    const def2 = {
+      type: "pi",
+      endpoint: agent.localEndpoint,
+      model: agent.localModel
+    };
+    if (agent.localApiKey !== void 0) def2.apiKey = agent.localApiKey;
+    if (agent.localTimeoutMs !== void 0) def2.timeoutMs = agent.localTimeoutMs;
+    if (agent.localProbeIntervalMs !== void 0) def2.probeIntervalMs = agent.localProbeIntervalMs;
+    return def2;
+  }
+  const def = {
+    type: "local",
+    endpoint: agent.localEndpoint,
+    model: agent.localModel
+  };
+  if (agent.localApiKey !== void 0) def.apiKey = agent.localApiKey;
+  if (agent.localTimeoutMs !== void 0) def.timeoutMs = agent.localTimeoutMs;
+  if (agent.localProbeIntervalMs !== void 0) def.probeIntervalMs = agent.localProbeIntervalMs;
+  return def;
+}
+
+// src/agent/backend-router.ts
+var BackendRouter = class {
+  backends;
+  routing;
+  constructor(opts) {
+    this.backends = opts.backends;
+    this.routing = opts.routing;
+    this.validateReferences();
+  }
+  /**
+   * 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) {
+    switch (useCase.kind) {
+      case "tier": {
+        const named = this.routing[useCase.tier];
+        return named ?? this.routing.default;
+      }
+      case "intelligence": {
+        const intel = this.routing.intelligence;
+        return intel?.[useCase.layer] ?? this.routing.default;
+      }
+      case "maintenance":
+      case "chat":
+        return this.routing.default;
+    }
+  }
+  /**
+   * Returns the BackendDef reference for the resolved name. Returns the
+   * exact reference held in `backends` (no copy) so identity comparisons
+   * succeed (SC21).
+   */
+  resolveDefinition(useCase) {
+    const name = this.resolve(useCase);
+    const def = this.backends[name];
+    if (!def) {
+      throw new Error(
+        `BackendRouter.resolveDefinition: routing target '${name}' is not in backends (useCase=${JSON.stringify(useCase)}).`
+      );
+    }
+    return def;
+  }
+  validateReferences() {
+    const known = new Set(Object.keys(this.backends));
+    const missing = [];
+    const check = (path16, name) => {
+      if (name !== void 0 && !known.has(name)) missing.push({ path: path16, name });
+    };
+    check("default", this.routing.default);
+    check("quick-fix", this.routing["quick-fix"]);
+    check("guided-change", this.routing["guided-change"]);
+    check("full-exploration", this.routing["full-exploration"]);
+    check("diagnostic", this.routing.diagnostic);
+    check("intelligence.sel", this.routing.intelligence?.sel);
+    check("intelligence.pesl", this.routing.intelligence?.pesl);
+    if (missing.length > 0) {
+      const detail = missing.map(({ path: path16, name }) => `routing.${path16} -> '${name}'`).join("; ");
+      const known_ = [...known].join(", ") || "(none)";
+      throw new Error(
+        `BackendRouter: routing references unknown backend(s): ${detail}. Defined backends: [${known_}].`
+      );
+    }
+  }
+};
+
 // src/agent/backends/claude.ts
 import { spawn as spawn2 } from "child_process";
 import * as readline from "readline";
@@ -3535,12 +4070,125 @@ var ClaudeBackend = class {
   }
 };
 
-// src/agent/backends/openai.ts
-import OpenAI from "openai";
+// src/agent/backends/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
 import {
   Ok as Ok10,
   Err as Err7
 } from "@harness-engineering/types";
+import { AnthropicCacheAdapter } from "@harness-engineering/core";
+var AnthropicBackend = class {
+  name = "anthropic";
+  config;
+  client;
+  cacheAdapter;
+  constructor(config = {}) {
+    this.config = {
+      model: config.model ?? "claude-sonnet-4-20250514",
+      apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "",
+      maxTokens: config.maxTokens ?? 4096
+    };
+    this.client = new Anthropic({ apiKey: this.config.apiKey });
+    this.cacheAdapter = new AnthropicCacheAdapter();
+  }
+  async startSession(params) {
+    if (!this.config.apiKey) {
+      return Err7({
+        category: "agent_not_found",
+        message: "ANTHROPIC_API_KEY is not set"
+      });
+    }
+    const session = {
+      sessionId: `anthropic-session-${Date.now()}`,
+      workspacePath: params.workspacePath,
+      backendName: this.name,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
+    };
+    return Ok10(session);
+  }
+  async *runTurn(session, params) {
+    const anthropicSession = session;
+    const systemBlocks = anthropicSession.systemPrompt ? [
+      this.cacheAdapter.wrapSystemBlock(
+        anthropicSession.systemPrompt,
+        "session"
+      )
+    ] : void 0;
+    try {
+      const stream = this.client.messages.stream({
+        model: this.config.model,
+        max_tokens: this.config.maxTokens,
+        ...systemBlocks && { system: systemBlocks },
+        messages: [{ role: "user", content: params.prompt }]
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && "text" in event.delta) {
+          yield {
+            type: "text",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            content: event.delta.text,
+            sessionId: session.sessionId
+          };
+        }
+      }
+      const finalMessage = await stream.finalMessage();
+      const { input_tokens, output_tokens } = finalMessage.usage;
+      const cacheUsage = this.cacheAdapter.parseCacheUsage(finalMessage);
+      const usage = {
+        inputTokens: input_tokens,
+        outputTokens: output_tokens,
+        totalTokens: input_tokens + output_tokens,
+        cacheCreationTokens: cacheUsage.cacheCreationTokens,
+        cacheReadTokens: cacheUsage.cacheReadTokens
+      };
+      yield {
+        type: "usage",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: session.sessionId,
+        usage
+      };
+      return {
+        success: true,
+        sessionId: session.sessionId,
+        usage
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Anthropic request failed";
+      yield {
+        type: "error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        content: errorMessage,
+        sessionId: session.sessionId
+      };
+      return {
+        success: false,
+        sessionId: session.sessionId,
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        error: errorMessage
+      };
+    }
+  }
+  async stopSession(_session) {
+    return Ok10(void 0);
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) {
+      return Err7({
+        category: "response_error",
+        message: "ANTHROPIC_API_KEY is not set"
+      });
+    }
+    return Ok10(void 0);
+  }
+};
+
+// src/agent/backends/openai.ts
+import OpenAI from "openai";
+import {
+  Ok as Ok11,
+  Err as Err8
+} from "@harness-engineering/types";
 import { OpenAICacheAdapter } from "@harness-engineering/core";
 var OpenAIBackend = class {
   name = "openai";
@@ -3557,7 +4205,7 @@ var OpenAIBackend = class {
   }
   async startSession(params) {
     if (!this.config.apiKey) {
-      return Err7({
+      return Err8({
         category: "agent_not_found",
         message: "OPENAI_API_KEY is not set"
       });
@@ -3569,7 +4217,7 @@ var OpenAIBackend = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
     };
-    return Ok10(session);
+    return Ok11(session);
   }
   async *runTurn(session, params) {
     const openAISession = session;
@@ -3645,14 +4293,14 @@ var OpenAIBackend = class {
     };
   }
   async stopSession(_session) {
-    return Ok10(void 0);
+    return Ok11(void 0);
   }
   async healthCheck() {
     try {
       await this.client.models.list();
-      return Ok10(void 0);
+      return Ok11(void 0);
     } catch (err) {
-      return Err7({
+      return Err8({
         category: "response_error",
         message: err instanceof Error ? err.message : "OpenAI health check failed"
       });
@@ -3663,8 +4311,8 @@ var OpenAIBackend = class {
 // src/agent/backends/gemini.ts
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import {
-  Ok as Ok11,
-  Err as Err8
+  Ok as Ok12,
+  Err as Err9
 } from "@harness-engineering/types";
 import { GeminiCacheAdapter } from "@harness-engineering/core";
 var GeminiBackend = class {
@@ -3680,7 +4328,7 @@ var GeminiBackend = class {
   }
   async startSession(params) {
     if (!this.config.apiKey) {
-      return Err8({
+      return Err9({
         category: "agent_not_found",
         message: "GEMINI_API_KEY is not set"
       });
@@ -3692,7 +4340,7 @@ var GeminiBackend = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
     };
-    return Ok11(session);
+    return Ok12(session);
   }
   async *runTurn(session, params) {
     const geminiSession = session;
@@ -3762,135 +4410,22 @@ var GeminiBackend = class {
       success: true,
       sessionId: session.sessionId,
       usage
-    };
-  }
-  async stopSession(_session) {
-    return Ok11(void 0);
-  }
-  async healthCheck() {
-    try {
-      const genAI = new GoogleGenerativeAI(this.config.apiKey);
-      genAI.getGenerativeModel({ model: this.config.model });
-      return Ok11(void 0);
-    } catch (err) {
-      return Err8({
-        category: "response_error",
-        message: err instanceof Error ? err.message : "Gemini health check failed"
-      });
-    }
-  }
-};
-
-// src/agent/backends/anthropic.ts
-import Anthropic from "@anthropic-ai/sdk";
-import {
-  Ok as Ok12,
-  Err as Err9
-} from "@harness-engineering/types";
-import { AnthropicCacheAdapter } from "@harness-engineering/core";
-var AnthropicBackend = class {
-  name = "anthropic";
-  config;
-  client;
-  cacheAdapter;
-  constructor(config = {}) {
-    this.config = {
-      model: config.model ?? "claude-sonnet-4-20250514",
-      apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "",
-      maxTokens: config.maxTokens ?? 4096
-    };
-    this.client = new Anthropic({ apiKey: this.config.apiKey });
-    this.cacheAdapter = new AnthropicCacheAdapter();
-  }
-  async startSession(params) {
-    if (!this.config.apiKey) {
-      return Err9({
-        category: "agent_not_found",
-        message: "ANTHROPIC_API_KEY is not set"
-      });
-    }
-    const session = {
-      sessionId: `anthropic-session-${Date.now()}`,
-      workspacePath: params.workspacePath,
-      backendName: this.name,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
-    };
-    return Ok12(session);
-  }
-  async *runTurn(session, params) {
-    const anthropicSession = session;
-    const systemBlocks = anthropicSession.systemPrompt ? [
-      this.cacheAdapter.wrapSystemBlock(
-        anthropicSession.systemPrompt,
-        "session"
-      )
-    ] : void 0;
-    try {
-      const stream = this.client.messages.stream({
-        model: this.config.model,
-        max_tokens: this.config.maxTokens,
-        ...systemBlocks && { system: systemBlocks },
-        messages: [{ role: "user", content: params.prompt }]
-      });
-      for await (const event of stream) {
-        if (event.type === "content_block_delta" && "text" in event.delta) {
-          yield {
-            type: "text",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            content: event.delta.text,
-            sessionId: session.sessionId
-          };
-        }
-      }
-      const finalMessage = await stream.finalMessage();
-      const { input_tokens, output_tokens } = finalMessage.usage;
-      const cacheUsage = this.cacheAdapter.parseCacheUsage(finalMessage);
-      const usage = {
-        inputTokens: input_tokens,
-        outputTokens: output_tokens,
-        totalTokens: input_tokens + output_tokens,
-        cacheCreationTokens: cacheUsage.cacheCreationTokens,
-        cacheReadTokens: cacheUsage.cacheReadTokens
-      };
-      yield {
-        type: "usage",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        sessionId: session.sessionId,
-        usage
-      };
-      return {
-        success: true,
-        sessionId: session.sessionId,
-        usage
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Anthropic request failed";
-      yield {
-        type: "error",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        content: errorMessage,
-        sessionId: session.sessionId
-      };
-      return {
-        success: false,
-        sessionId: session.sessionId,
-        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        error: errorMessage
-      };
-    }
+    };
   }
   async stopSession(_session) {
     return Ok12(void 0);
   }
   async healthCheck() {
-    if (!this.config.apiKey) {
+    try {
+      const genAI = new GoogleGenerativeAI(this.config.apiKey);
+      genAI.getGenerativeModel({ model: this.config.model });
+      return Ok12(void 0);
+    } catch (err) {
       return Err9({
         category: "response_error",
-        message: "ANTHROPIC_API_KEY is not set"
+        message: err instanceof Error ? err.message : "Gemini health check failed"
       });
     }
-    return Ok12(void 0);
   }
 };
 
@@ -3904,6 +4439,7 @@ var DEFAULT_TIMEOUT_MS = 9e4;
 var LocalBackend = class {
   name = "local";
   config;
+  getModel;
   client;
   constructor(config = {}) {
     this.config = {
@@ -3912,6 +4448,7 @@ var LocalBackend = class {
       apiKey: config.apiKey ?? "ollama",
       timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
     };
+    this.getModel = config.getModel;
     this.client = new OpenAI2({
       apiKey: this.config.apiKey,
       baseURL: this.config.endpoint,
@@ -3919,11 +4456,25 @@ var LocalBackend = class {
     });
   }
   async startSession(params) {
+    let resolvedModel;
+    if (this.getModel) {
+      const candidate = this.getModel();
+      if (candidate === null) {
+        return Err10({
+          category: "agent_not_found",
+          message: "No local model available; check dashboard for details."
+        });
+      }
+      resolvedModel = candidate;
+    } else {
+      resolvedModel = this.config.model;
+    }
     const session = {
       sessionId: `local-session-${Date.now()}`,
       workspacePath: params.workspacePath,
       backendName: this.name,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resolvedModel,
       ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
     };
     return Ok13(session);
@@ -3940,7 +4491,7 @@ var LocalBackend = class {
     let totalTokens = 0;
     try {
       const stream = await this.client.chat.completions.create({
-        model: this.config.model,
+        model: localSession.resolvedModel,
         messages,
         stream: true,
         stream_options: { include_usage: true }
@@ -4108,13 +4659,41 @@ function buildLocalModel(config) {
 var PiBackend = class {
   name = "pi";
   config;
+  /**
+   * Per-request timeout in ms (default 90_000). Spec 2 P2-I1: enforced at
+   * the request boundary by `runTurn` racing `piSession.prompt()` against
+   * an `AbortController + setTimeout(timeoutMs)`. On timeout the
+   * underlying pi session is aborted and the turn returns a failed
+   * `TurnResult` carrying a timeout-tagged error message. Setting
+   * `timeoutMs: 0` disables the watchdog (preserves the pre-fix-up
+   * "no enforcement" behavior for callers that want the SDK default).
+   */
+  timeoutMs;
   constructor(config = {}) {
     this.config = config;
+    this.timeoutMs = config.timeoutMs ?? 9e4;
   }
   async startSession(params) {
     try {
+      let resolvedModelName;
+      if (this.config.getModel) {
+        const candidate = this.config.getModel();
+        if (candidate === null) {
+          return Err11({
+            category: "agent_not_found",
+            message: "No local model available; check dashboard for details."
+          });
+        }
+        resolvedModelName = candidate;
+      } else {
+        resolvedModelName = this.config.model;
+      }
       const piSdk = await import("@mariozechner/pi-coding-agent");
-      const model = buildLocalModel(this.config);
+      const model = buildLocalModel({
+        model: resolvedModelName,
+        endpoint: this.config.endpoint,
+        apiKey: this.config.apiKey
+      });
       const { session: piSession } = await piSdk.createAgentSession({
         cwd: params.workspacePath,
         ...model !== void 0 && { model },
@@ -4154,15 +4733,45 @@ var PiBackend = class {
       signal();
     });
     session.unsubscribe = unsubscribe;
-    const promptPromise = piSession.prompt(params.prompt).then(
-      () => {
+    let timeoutHandle = null;
+    let timedOut = false;
+    if (this.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        promptErrorMsg = `Pi backend request timed out after ${this.timeoutMs}ms`;
         promptDone = true;
+        try {
+          const maybeAbort = piSession.abort?.();
+          if (maybeAbort && typeof maybeAbort.catch === "function") {
+            maybeAbort.catch(() => {
+            });
+          }
+        } catch {
+        }
         signal();
+      }, this.timeoutMs);
+    }
+    const clearTimeoutHandle = () => {
+      if (timeoutHandle !== null) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+      }
+    };
+    const promptPromise = piSession.prompt(params.prompt).then(
+      () => {
+        if (!timedOut) {
+          clearTimeoutHandle();
+          promptDone = true;
+          signal();
+        }
       },
       (err) => {
-        promptErrorMsg = err.message;
-        promptDone = true;
-        signal();
+        if (!timedOut) {
+          clearTimeoutHandle();
+          promptErrorMsg = err.message;
+          promptDone = true;
+          signal();
+        }
       }
     );
     let inputTokens = 0;
@@ -4178,12 +4787,15 @@ var PiBackend = class {
         })
       });
     } finally {
+      clearTimeoutHandle();
       resolveWait?.();
       resolveWait = null;
       unsubscribe();
       session.unsubscribe = null;
-      await promptPromise.catch(() => {
-      });
+      if (!timedOut) {
+        await promptPromise.catch(() => {
+        });
+      }
     }
     const totalTokens = inputTokens + outputTokens;
     if (promptErrorMsg) {
@@ -4243,6 +4855,60 @@ var PiBackend = class {
   }
 };
 
+// src/agent/backend-factory.ts
+function makeGetModel(model) {
+  if (typeof model === "string") return () => model;
+  if (Array.isArray(model) && model.length > 0) return () => model[0] ?? null;
+  return () => null;
+}
+function createBackend(def) {
+  switch (def.type) {
+    case "mock":
+      return new MockBackend();
+    case "claude":
+      return new ClaudeBackend(def.command ?? "claude");
+    case "anthropic":
+      return new AnthropicBackend({
+        model: def.model,
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+      });
+    case "openai":
+      return new OpenAIBackend({
+        model: def.model,
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+      });
+    case "gemini":
+      return new GeminiBackend({
+        model: def.model,
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+      });
+    case "local": {
+      const isArray = Array.isArray(def.model);
+      return new LocalBackend({
+        endpoint: def.endpoint,
+        ...typeof def.model === "string" ? { model: def.model } : {},
+        ...isArray ? { getModel: makeGetModel(def.model) } : {},
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {},
+        ...def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}
+      });
+    }
+    case "pi": {
+      const isArray = Array.isArray(def.model);
+      return new PiBackend({
+        endpoint: def.endpoint,
+        ...typeof def.model === "string" ? { model: def.model } : {},
+        ...isArray ? { getModel: makeGetModel(def.model) } : {},
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {},
+        ...def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}
+      });
+    }
+    default: {
+      const exhaustive = def;
+      throw new Error(`createBackend: unknown backend type ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
 // src/agent/backends/container.ts
 import {
   Err as Err12
@@ -4606,6 +5272,195 @@ function createSecretBackend(config) {
   }
 }
 
+// src/agent/orchestrator-backend-factory.ts
+var OrchestratorBackendFactory = class {
+  router;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.router = new BackendRouter({ backends: opts.backends, routing: opts.routing });
+  }
+  /**
+   * Resolve `useCase` to a backend name, materialize a fresh
+   * `AgentBackend`, optionally rebind its model resolver, and apply
+   * sandbox wrapping. Idempotent across calls (no caching) — the AgentRunner
+   * holds the per-dispatch reference and discards it when the run ends.
+   */
+  /**
+   * Resolve `useCase` to its routed backend name, exposing the
+   * router lookup without materializing a backend. Used by callers
+   * (e.g., the orchestrator's dispatch site) that need to label
+   * telemetry with the routed name BEFORE constructing the backend.
+   *
+   * Spec 2 P2-I2: previously the orchestrator labelled `LiveSession`
+   * + `StreamRecorder` with the legacy `agent.backend` field, which
+   * is `undefined` for pure-modern configs. Threading the routed name
+   * through dispatch eliminates that gap.
+   */
+  resolveName(useCase) {
+    return this.router.resolve(useCase);
+  }
+  forUseCase(useCase) {
+    const def = this.router.resolveDefinition(useCase);
+    const name = this.router.resolve(useCase);
+    let backend;
+    if ((def.type === "local" || def.type === "pi") && this.opts.getResolverModelFor) {
+      const getModel = this.opts.getResolverModelFor(name);
+      backend = getModel ? this.buildLocalLikeWithResolver(def, getModel) : createBackend(def);
+    } else {
+      backend = createBackend(def);
+    }
+    if (this.opts.sandboxPolicy === "docker" && this.opts.container) {
+      backend = this.wrapInContainer(backend);
+    }
+    return backend;
+  }
+  /**
+   * Rebuild a `local`/`pi` backend with a resolver-bound `getModel`,
+   * mirroring `createBackend`'s local/pi branches but substituting the
+   * head-of-array placeholder with the orchestrator-owned resolver.
+   */
+  buildLocalLikeWithResolver(def, getModel) {
+    if (def.type === "local") {
+      return new LocalBackend({
+        endpoint: def.endpoint,
+        getModel,
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {},
+        ...def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}
+      });
+    }
+    if (def.type === "pi") {
+      return new PiBackend({
+        endpoint: def.endpoint,
+        getModel,
+        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {},
+        ...def.timeoutMs !== void 0 ? { timeoutMs: def.timeoutMs } : {}
+      });
+    }
+    throw new Error(
+      `OrchestratorBackendFactory.buildLocalLikeWithResolver called with non-local def.type='${def.type}'`
+    );
+  }
+  /**
+   * Apply ContainerBackend wrapping (PFC-3). Pulls the runtime + secret
+   * backend per call so each dispatch sees a fresh container handle map
+   * (ContainerBackend keeps its own per-instance Map<sessionId, handle>).
+   */
+  wrapInContainer(inner) {
+    const runtime = new DockerRuntime();
+    const secretBackend = this.opts.secrets ? createSecretBackend(this.opts.secrets) : null;
+    const secretKeys = this.opts.secrets?.keys ?? [];
+    return new ContainerBackend(
+      inner,
+      runtime,
+      secretBackend,
+      this.opts.container,
+      secretKeys
+    );
+  }
+};
+
+// src/agent/analysis-provider-factory.ts
+import {
+  AnthropicAnalysisProvider,
+  ClaudeCliAnalysisProvider,
+  OpenAICompatibleAnalysisProvider
+} from "@harness-engineering/intelligence";
+function buildAnalysisProvider(args) {
+  const { def, backendName, layer, intelligence, logger } = args;
+  const layerModel = layer === "sel" ? intelligence?.models?.sel : intelligence?.models?.pesl;
+  switch (def.type) {
+    case "local":
+    case "pi":
+      return buildLocalLikeProvider(def, args, layerModel);
+    case "anthropic":
+      return buildAnthropicProvider(def, args, layerModel);
+    case "openai":
+      return buildOpenAIProvider(def, args, layerModel);
+    case "claude":
+      return buildClaudeCliProvider(def, args, layerModel);
+    case "mock":
+    case "gemini":
+      logger.warn(
+        `Intelligence pipeline disabled for layer '${layer}': routed backend '${backendName}' has type '${def.type}' which has no AnalysisProvider implementation.`
+      );
+      return null;
+  }
+}
+function buildLocalLikeProvider(def, args, layerModel) {
+  const { backendName, getResolverStatusSnapshot, intelligence, logger } = args;
+  const snapshot = getResolverStatusSnapshot();
+  if (!snapshot || !snapshot.available) {
+    const configured = snapshot?.configured ?? [];
+    const detected = snapshot?.detected ?? [];
+    logger.warn(
+      `Intelligence pipeline disabled for backend '${backendName}' at ${def.endpoint}: no configured local model loaded. Configured: [${configured.join(", ")}]. Detected: [${detected.join(", ")}].`
+    );
+    return null;
+  }
+  const model = layerModel ?? snapshot.resolved ?? void 0;
+  const apiKey = def.apiKey ?? "ollama";
+  logger.info(
+    `Intelligence pipeline using backend '${backendName}' (${def.type}) at ${def.endpoint} (model: ${model ?? "(default)"})`
+  );
+  return new OpenAICompatibleAnalysisProvider({
+    apiKey,
+    baseUrl: def.endpoint,
+    ...model !== void 0 && { defaultModel: model },
+    ...intelligence?.requestTimeoutMs !== void 0 && {
+      timeoutMs: intelligence.requestTimeoutMs
+    },
+    ...intelligence?.promptSuffix !== void 0 && { promptSuffix: intelligence.promptSuffix },
+    ...intelligence?.jsonMode !== void 0 && { jsonMode: intelligence.jsonMode }
+  });
+}
+function buildAnthropicProvider(def, args, layerModel) {
+  const apiKey = def.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  const model = layerModel ?? def.model;
+  if (apiKey) {
+    return new AnthropicAnalysisProvider({
+      apiKey,
+      ...model !== void 0 && { defaultModel: model }
+    });
+  }
+  args.logger.info(
+    `Intelligence pipeline routed to '${args.backendName}' (anthropic) without API key \u2014 using Claude CLI fallback.`
+  );
+  return new ClaudeCliAnalysisProvider({
+    ...model !== void 0 && { defaultModel: model },
+    ...args.intelligence?.requestTimeoutMs !== void 0 && {
+      timeoutMs: args.intelligence.requestTimeoutMs
+    }
+  });
+}
+function buildOpenAIProvider(def, args, layerModel) {
+  const apiKey = def.apiKey ?? process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    args.logger.warn(
+      `Intelligence pipeline disabled for backend '${args.backendName}' (openai): no API key configured.`
+    );
+    return null;
+  }
+  const model = layerModel ?? def.model;
+  return new OpenAICompatibleAnalysisProvider({
+    apiKey,
+    baseUrl: "https://api.openai.com/v1",
+    ...model !== void 0 && { defaultModel: model },
+    ...args.intelligence?.requestTimeoutMs !== void 0 && {
+      timeoutMs: args.intelligence.requestTimeoutMs
+    }
+  });
+}
+function buildClaudeCliProvider(def, args, layerModel) {
+  return new ClaudeCliAnalysisProvider({
+    ...def.command !== void 0 && { command: def.command },
+    ...layerModel !== void 0 && { defaultModel: layerModel },
+    ...args.intelligence?.requestTimeoutMs !== void 0 && {
+      timeoutMs: args.intelligence.requestTimeoutMs
+    }
+  });
+}
+
 // src/server/http.ts
 import * as http from "http";
 import * as path13 from "path";
@@ -4665,7 +5520,7 @@ var WebSocketBroadcaster = class {
 };
 
 // src/server/routes/interactions.ts
-import { z } from "zod";
+import { z as z3 } from "zod";
 
 // src/server/utils.ts
 var DEFAULT_MAX_BYTES = 1048576;
@@ -4688,8 +5543,8 @@ function readBody(req, maxBytes = DEFAULT_MAX_BYTES) {
 }
 
 // src/server/routes/interactions.ts
-var InteractionUpdateSchema = z.object({
-  status: z.enum(["pending", "claimed", "resolved"])
+var InteractionUpdateSchema = z3.object({
+  status: z3.enum(["pending", "claimed", "resolved"])
 });
 var SAFE_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function sendJson(res, status, body) {
@@ -4740,12 +5595,12 @@ function handleInteractionsRoute(req, res, queue) {
 }
 
 // src/server/routes/plans.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 import * as fs9 from "fs/promises";
 import * as path9 from "path";
-var PlanWriteSchema = z2.object({
-  filename: z2.string().min(1),
-  content: z2.string().min(1)
+var PlanWriteSchema = z4.object({
+  filename: z4.string().min(1),
+  content: z4.string().min(1)
 });
 function handlePlansRoute(req, res, plansDir) {
   const { method, url } = req;
@@ -4789,7 +5644,7 @@ function handlePlansRoute(req, res, plansDir) {
 import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 import * as readline2 from "readline";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var SAFE_ENV_PREFIXES = [
   "PATH",
@@ -4824,10 +5679,10 @@ function buildChildEnv() {
   }
   return env;
 }
-var ChatRequestSchema = z3.object({
-  prompt: z3.string().min(1),
-  system: z3.string().optional(),
-  sessionId: z3.string().regex(UUID_RE).optional()
+var ChatRequestSchema = z5.object({
+  prompt: z5.string().min(1),
+  system: z5.string().optional(),
+  sessionId: z5.string().regex(UUID_RE).optional()
 });
 function handleChatProxyRoute(req, res, command = "claude") {
   const { method, url } = req;
@@ -5037,11 +5892,11 @@ function extractChunks(event) {
 
 // src/server/routes/analyze.ts
 import { manualToRawWorkItem, scoreToConcernSignals } from "@harness-engineering/intelligence";
-import { z as z4 } from "zod";
-var AnalyzeRequestSchema = z4.object({
-  title: z4.string().min(1),
-  description: z4.string().optional(),
-  labels: z4.array(z4.string()).optional()
+import { z as z6 } from "zod";
+var AnalyzeRequestSchema = z6.object({
+  title: z6.string().min(1),
+  description: z6.string().optional(),
+  labels: z6.array(z6.string()).optional()
 });
 function emit2(res, event) {
   res.write(`data: ${JSON.stringify(event)}
@@ -5149,19 +6004,19 @@ function handleAnalyzeRoute(req, res, pipeline) {
 // src/server/routes/roadmap-actions.ts
 import * as fs10 from "fs/promises";
 import { parseRoadmap as parseRoadmap2, serializeRoadmap as serializeRoadmap2 } from "@harness-engineering/core";
-import { z as z5 } from "zod";
-var AppendRoadmapRequestSchema = z5.object({
-  title: z5.string().min(1),
-  summary: z5.string().optional(),
-  labels: z5.array(z5.string()).optional(),
-  enrichedSpec: z5.object({
-    intent: z5.string(),
-    unknowns: z5.array(z5.string()),
-    ambiguities: z5.array(z5.string()),
-    riskSignals: z5.array(z5.string()),
-    affectedSystems: z5.array(z5.object({ name: z5.string() }))
+import { z as z7 } from "zod";
+var AppendRoadmapRequestSchema = z7.object({
+  title: z7.string().min(1),
+  summary: z7.string().optional(),
+  labels: z7.array(z7.string()).optional(),
+  enrichedSpec: z7.object({
+    intent: z7.string(),
+    unknowns: z7.array(z7.string()),
+    ambiguities: z7.array(z7.string()),
+    riskSignals: z7.array(z7.string()),
+    affectedSystems: z7.array(z7.object({ name: z7.string() }))
   }).optional(),
-  cmlRecommendedRoute: z5.enum(["local", "human", "simulation-required"]).optional()
+  cmlRecommendedRoute: z7.enum(["local", "human", "simulation-required"]).optional()
 });
 function sendJSON(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5232,11 +6087,11 @@ function handleRoadmapActionsRoute(req, res, roadmapPath) {
 
 // src/server/routes/dispatch-actions.ts
 import { createHash as createHash3 } from "crypto";
-import { z as z6 } from "zod";
-var DispatchAdHocRequestSchema = z6.object({
-  title: z6.string().min(1),
-  description: z6.string().optional(),
-  labels: z6.array(z6.string()).optional()
+import { z as z8 } from "zod";
+var DispatchAdHocRequestSchema = z8.object({
+  title: z8.string().min(1),
+  description: z8.string().optional(),
+  labels: z8.array(z8.string()).optional()
 });
 function sendJSON2(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5333,9 +6188,9 @@ function handleAnalysesRoute(req, res, archive) {
 }
 
 // src/server/routes/maintenance.ts
-import { z as z7 } from "zod";
-var TriggerRequestSchema = z7.object({
-  taskId: z7.string().min(1)
+import { z as z9 } from "zod";
+var TriggerRequestSchema = z9.object({
+  taskId: z9.string().min(1)
 });
 function sendJSON3(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5414,9 +6269,9 @@ function handleMaintenanceRoute(req, res, deps) {
 // src/server/routes/sessions.ts
 import * as fs11 from "fs/promises";
 import * as path10 from "path";
-import { z as z8 } from "zod";
-var SessionCreateSchema = z8.object({
-  sessionId: z8.string().min(1)
+import { z as z10 } from "zod";
+var SessionCreateSchema = z10.object({
+  sessionId: z10.string().min(1)
 }).passthrough();
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isSafeId(id) {
@@ -5503,7 +6358,7 @@ async function handleUpdate(req, res, url, sessionsDir) {
       return;
     }
     const body = await readBody(req);
-    const updates = z8.record(z8.unknown()).parse(JSON.parse(body));
+    const updates = z10.record(z10.unknown()).parse(JSON.parse(body));
     const sessionFilePath = path10.join(sessionsDir, id, "session.json");
     const current = JSON.parse(await fs11.readFile(sessionFilePath, "utf-8"));
     await fs11.writeFile(sessionFilePath, JSON.stringify({ ...current, ...updates }, null, 2));
@@ -5622,6 +6477,42 @@ function handleStreamsRoute(req, res, recorder) {
   return true;
 }
 
+// src/server/routes/local-model.ts
+function sendJSON4(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function handleLocalModelRoute(req, res, getStatus) {
+  const { method, url } = req;
+  if (url !== "/api/v1/local-model/status") return false;
+  if (method !== "GET") {
+    sendJSON4(res, 405, { error: "Method not allowed" });
+    return true;
+  }
+  if (!getStatus) {
+    sendJSON4(res, 503, { error: "Local backend not configured" });
+    return true;
+  }
+  const status = getStatus();
+  if (!status) {
+    sendJSON4(res, 503, { error: "Local backend not configured" });
+    return true;
+  }
+  sendJSON4(res, 200, status);
+  return true;
+}
+function handleLocalModelsRoute(req, res, getStatuses) {
+  const { method, url } = req;
+  if (url !== "/api/v1/local-models/status") return false;
+  if (method !== "GET") {
+    sendJSON4(res, 405, { error: "Method not allowed" });
+    return true;
+  }
+  const statuses = getStatuses ? getStatuses() : [];
+  sendJSON4(res, 200, statuses);
+  return true;
+}
+
 // src/server/static.ts
 import * as fs12 from "fs";
 import * as path11 from "path";
@@ -5775,6 +6666,8 @@ var OrchestratorServer = class {
   dispatchAdHoc;
   sessionsDir;
   maintenanceDeps = null;
+  getLocalModelStatus = null;
+  getLocalModelStatuses = null;
   recorder = null;
   planWatcher = null;
   stateChangeListener;
@@ -5801,6 +6694,8 @@ var OrchestratorServer = class {
     this.dispatchAdHoc = deps?.dispatchAdHoc ?? null;
     this.sessionsDir = deps?.sessionsDir ?? path13.resolve(".harness", "sessions");
     this.maintenanceDeps = deps?.maintenanceDeps ?? null;
+    this.getLocalModelStatus = deps?.getLocalModelStatus ?? null;
+    this.getLocalModelStatuses = deps?.getLocalModelStatuses ?? null;
   }
   wireEvents() {
     this.stateChangeListener = (snapshot) => {
@@ -5827,6 +6722,31 @@ var OrchestratorServer = class {
   broadcastMaintenance(type, data) {
     this.broadcaster.broadcast(type, data);
   }
+  /**
+   * Broadcast a local-model status change to dashboard clients.
+   *
+   * Phase 3 routes status events through the existing WebSocket broadcaster
+   * on topic `local-model:status` so test fixtures and dashboard consumers
+   * observe payloads immediately. The project broadcasts via WebSocket; the
+   * spec's "SSE topic" wording is approximate. Phase 5 widens the payload
+   * to `NamedLocalModelStatus` (with `backendName` + `endpoint`); the channel
+   * and bind-before-probe ordering are unchanged.
+   */
+  broadcastLocalModelStatus(status) {
+    this.broadcaster.broadcast("local-model:status", status);
+  }
+  /**
+   * Update the intelligence pipeline reference after construction.
+   *
+   * The orchestrator constructs the pipeline lazily inside `start()` (the
+   * resolver must observe the server before pipeline construction). The
+   * server is built in the orchestrator constructor with `pipeline: null`,
+   * so it must be told the real pipeline once it's been created — otherwise
+   * `/api/analyze` would always see a null pipeline and return 503.
+   */
+  setPipeline(pipeline) {
+    this.pipeline = pipeline;
+  }
   /**
    * Set (or update) the maintenance route dependencies after construction.
    * Called by the Orchestrator once the scheduler and reporter are ready.
@@ -5903,6 +6823,12 @@ var OrchestratorServer = class {
     if (handleDispatchActionsRoute(req, res, this.dispatchAdHoc)) {
       return true;
     }
+    if (handleLocalModelRoute(req, res, this.getLocalModelStatus)) {
+      return true;
+    }
+    if (handleLocalModelsRoute(req, res, this.getLocalModelStatuses)) {
+      return true;
+    }
     if (handleMaintenanceRoute(req, res, this.maintenanceDeps)) {
       return true;
     }
@@ -6475,17 +7401,17 @@ var MaintenanceScheduler = class {
 // src/maintenance/reporter.ts
 import * as fs14 from "fs";
 import * as path14 from "path";
-import { z as z9 } from "zod";
-var RunResultSchema = z9.object({
-  taskId: z9.string(),
-  startedAt: z9.string(),
-  completedAt: z9.string(),
-  status: z9.enum(["success", "failure", "skipped", "no-issues"]),
-  findings: z9.number(),
-  fixed: z9.number(),
-  prUrl: z9.string().nullable(),
-  prUpdated: z9.boolean(),
-  error: z9.string().optional()
+import { z as z11 } from "zod";
+var RunResultSchema = z11.object({
+  taskId: z11.string(),
+  startedAt: z11.string(),
+  completedAt: z11.string(),
+  status: z11.enum(["success", "failure", "skipped", "no-issues"]),
+  findings: z11.number(),
+  fixed: z11.number(),
+  prUrl: z11.string().nullable(),
+  prUpdated: z11.boolean(),
+  error: z11.string().optional()
 });
 var MAX_HISTORY = 500;
 var fallbackLogger = {
@@ -6512,7 +7438,7 @@ var MaintenanceReporter = class {
       await fs14.promises.mkdir(this.persistDir, { recursive: true });
       const filePath = path14.join(this.persistDir, "history.json");
       const data = await fs14.promises.readFile(filePath, "utf-8");
-      const parsed = z9.array(RunResultSchema).safeParse(JSON.parse(data));
+      const parsed = z11.array(RunResultSchema).safeParse(JSON.parse(data));
       if (parsed.success) {
         this.history = parsed.data.slice(0, MAX_HISTORY);
       }
@@ -6795,13 +7721,43 @@ var TaskRunner = class {
 };
 
 // src/orchestrator.ts
+function useCaseForBackendParam(issue, backendParam) {
+  if (backendParam === "local") return { kind: "tier", tier: "quick-fix" };
+  const tier = detectScopeTier(issue, artifactPresenceFromIssue(issue));
+  return { kind: "tier", tier };
+}
 var Orchestrator = class extends EventEmitter {
   state;
   config;
   tracker;
   workspace;
   hooks;
-  runner;
+  /**
+   * Spec 2 SC30 / Task 11: per-dispatch backend factory replaces the
+   * Phase 1 `runner` / `localRunner` two-runner split. Each
+   * `dispatchIssue()` call asks the factory for a `RoutingUseCase`-routed
+   * `AgentBackend`, then wraps it in a fresh `AgentRunner`.
+   *
+   * `AgentRunner` is stateless (just `{ backend, options }`), so
+   * per-dispatch construction is safe and avoids the cross-call state
+   * the old two-runner split had to coordinate.
+   *
+   * Null only in the legacy fallback path: when `migrateAgentConfig`
+   * throws (legacy configs missing supplemental fields, e.g.
+   * `agent.backend='anthropic'` with no `agent.model`) AND no
+   * `overrides.backend` is supplied, factory construction is skipped to
+   * preserve the prior behavior of failing at dispatch time rather than
+   * construction time. Eliminating this fallback is autopilot Phase 4+.
+   */
+  backendFactory;
+  /**
+   * Test-only: when overrides.backend is provided, dispatch uses this
+   * instance directly (bypassing the factory). Mirrors Phase 1
+   * `overrides.backend → this.runner.backend` behavior so existing
+   * MockBackend-injection tests keep working without touching the
+   * factory's routing path.
+   */
+  overrideBackend;
   renderer;
   promptTemplate;
   server;
@@ -6809,7 +7765,22 @@ var Orchestrator = class extends EventEmitter {
   heartbeatInterval;
   logger;
   interactionQueue;
-  localRunner;
+  /**
+   * Per-named-backend resolver map (Spec 2 SC37). Each `local`/`pi` entry
+   * in `agent.backends` spawns one `LocalModelResolver`. Legacy
+   * single-backend configs converge here via `migrateAgentConfig` (Task 9),
+   * so this map is the single source of truth post-migration.
+   */
+  localResolvers = /* @__PURE__ */ new Map();
+  /**
+   * Per-resolver `onStatusChange` unsubscribe callbacks. Spec 2 Phase 5
+   * (SC39): each local/pi resolver gets its own listener emitting a
+   * `NamedLocalModelStatus` event tagged with `backendName` + `endpoint`.
+   * The previous single-resolver field (`localModelStatusUnsubscribe`)
+   * is replaced by this list so multi-local configs can teardown all
+   * listeners on `stop()` without a Map mutation.
+   */
+  localModelStatusUnsubscribes = [];
   pipeline;
   analysisArchive;
   graphStore = null;
@@ -6851,20 +7822,60 @@ var Orchestrator = class extends EventEmitter {
     this.promptTemplate = promptTemplate;
     this.state = createEmptyState(config);
     this.logger = new StructuredLogger();
+    try {
+      const migrationResult = migrateAgentConfig(this.config.agent);
+      if (migrationResult.warnings.length > 0) {
+        for (const w of migrationResult.warnings) this.logger.warn(w);
+      }
+      this.config = { ...this.config, agent: migrationResult.config };
+    } catch (err) {
+      this.logger.warn(
+        `migrateAgentConfig failed; continuing with legacy fields. Error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     this.tracker = overrides?.tracker || this.createTracker();
     this.workspace = new WorkspaceManager(config.workspace);
     this.hooks = new WorkspaceHooks(config.hooks);
     this.renderer = new PromptRenderer();
-    this.runner = new AgentRunner(overrides?.backend || this.createBackend(), {
-      maxTurns: config.agent.maxTurns
-    });
+    this.overrideBackend = overrides?.backend ?? null;
     this.interactionQueue = new InteractionQueue(
       path15.join(config.workspace.root, "..", "interactions")
     );
     this.analysisArchive = new AnalysisArchive(path15.join(config.workspace.root, "..", "analyses"));
-    const localBackend = this.createLocalBackend();
-    this.localRunner = localBackend ? new AgentRunner(localBackend, { maxTurns: config.agent.maxTurns }) : null;
-    this.pipeline = this.createIntelligencePipeline();
+    const backendsMap = this.config.agent.backends ?? {};
+    for (const [name, def] of Object.entries(backendsMap)) {
+      if (def.type === "local" || def.type === "pi") {
+        const resolverOpts = {
+          endpoint: def.endpoint,
+          configured: typeof def.model === "string" ? [def.model] : def.model,
+          logger: this.logger
+        };
+        if (def.apiKey !== void 0) resolverOpts.apiKey = def.apiKey;
+        if (def.probeIntervalMs !== void 0) resolverOpts.probeIntervalMs = def.probeIntervalMs;
+        this.localResolvers.set(name, new LocalModelResolver(resolverOpts));
+      }
+    }
+    if (this.config.agent.backends !== void 0 && Object.keys(this.config.agent.backends).length > 0) {
+      const sandboxPolicy = this.config.agent.sandboxPolicy === "docker" ? "docker" : "none";
+      const firstBackendName = Object.keys(this.config.agent.backends)[0];
+      const routing = this.config.agent.routing ?? {
+        default: firstBackendName ?? "primary"
+      };
+      this.backendFactory = new OrchestratorBackendFactory({
+        backends: this.config.agent.backends,
+        routing,
+        sandboxPolicy,
+        ...this.config.agent.container !== void 0 ? { container: this.config.agent.container } : {},
+        ...this.config.agent.secrets !== void 0 ? { secrets: this.config.agent.secrets } : {},
+        getResolverModelFor: (name) => {
+          const resolver = this.localResolvers.get(name);
+          return resolver ? () => resolver.resolveModel() : void 0;
+        }
+      });
+    } else {
+      this.backendFactory = null;
+    }
+    this.pipeline = null;
     this.orchestratorIdPromise = resolveOrchestratorId(config.orchestratorId);
     this.prDetector = new PRDetector({
       logger: this.logger,
@@ -6908,7 +7919,25 @@ var Orchestrator = class extends EventEmitter {
         pipeline: this.pipeline,
         analysisArchive: this.analysisArchive,
         roadmapPath: config.tracker.filePath ?? null,
-        dispatchAdHoc: this.dispatchAdHoc.bind(this)
+        dispatchAdHoc: this.dispatchAdHoc.bind(this),
+        getLocalModelStatus: () => {
+          const first = this.localResolvers.values().next();
+          return first.done ? null : first.value.getStatus();
+        },
+        getLocalModelStatuses: () => {
+          const backends = this.config.agent.backends ?? {};
+          const out = [];
+          for (const [name, resolver] of this.localResolvers) {
+            const def = backends[name];
+            if (!def || def.type !== "local" && def.type !== "pi") continue;
+            out.push({
+              ...resolver.getStatus(),
+              backendName: name,
+              endpoint: def.endpoint
+            });
+          }
+          return out;
+        }
       });
       this.server.setRecorder(this.recorder);
       this.interactionQueue.onPush((interaction) => {
@@ -6922,44 +7951,6 @@ var Orchestrator = class extends EventEmitter {
     }
     throw new Error(`Unsupported tracker kind: ${this.config.tracker.kind}`);
   }
-  createBackend() {
-    let backend;
-    if (this.config.agent.backend === "mock") {
-      backend = new MockBackend();
-    } else if (this.config.agent.backend === "claude") {
-      backend = new ClaudeBackend(this.config.agent.command);
-    } else if (this.config.agent.backend === "openai") {
-      backend = new OpenAIBackend({
-        ...this.config.agent.model !== void 0 && { model: this.config.agent.model },
-        ...this.config.agent.apiKey !== void 0 && { apiKey: this.config.agent.apiKey }
-      });
-    } else if (this.config.agent.backend === "gemini") {
-      backend = new GeminiBackend({
-        ...this.config.agent.model !== void 0 && { model: this.config.agent.model },
-        ...this.config.agent.apiKey !== void 0 && { apiKey: this.config.agent.apiKey }
-      });
-    } else if (this.config.agent.backend === "anthropic") {
-      backend = new AnthropicBackend({
-        ...this.config.agent.model !== void 0 && { model: this.config.agent.model },
-        ...this.config.agent.apiKey !== void 0 && { apiKey: this.config.agent.apiKey }
-      });
-    } else {
-      throw new Error(`Unsupported agent backend: ${this.config.agent.backend}`);
-    }
-    if (this.config.agent.sandboxPolicy === "docker" && this.config.agent.container) {
-      const runtime = new DockerRuntime();
-      const secretBackend = this.config.agent.secrets ? createSecretBackend(this.config.agent.secrets) : null;
-      const secretKeys = this.config.agent.secrets?.keys ?? [];
-      backend = new ContainerBackend(
-        backend,
-        runtime,
-        secretBackend,
-        this.config.agent.container,
-        secretKeys
-      );
-    }
-    return backend;
-  }
   /**
    * Creates a TaskRunner for the maintenance scheduler.
    * CheckCommandRunner and CommandExecutor use real child_process execution.
@@ -7085,97 +8076,98 @@ var Orchestrator = class extends EventEmitter {
       });
     }
   }
-  createLocalBackend() {
-    if (this.config.agent.localBackend === "openai-compatible") {
-      const localConfig = {};
-      if (this.config.agent.localEndpoint) localConfig.endpoint = this.config.agent.localEndpoint;
-      if (this.config.agent.localModel) localConfig.model = this.config.agent.localModel;
-      if (this.config.agent.localApiKey) localConfig.apiKey = this.config.agent.localApiKey;
-      if (this.config.agent.localTimeoutMs)
-        localConfig.timeoutMs = this.config.agent.localTimeoutMs;
-      return new LocalBackend(localConfig);
-    }
-    if (this.config.agent.localBackend === "pi") {
-      return new PiBackend({
-        model: this.config.agent.localModel,
-        endpoint: this.config.agent.localEndpoint,
-        apiKey: this.config.agent.localApiKey
-      });
-    }
-    return null;
-  }
   createIntelligencePipeline() {
     const intel = this.config.intelligence;
     if (!intel?.enabled) return null;
-    const provider = this.createAnalysisProvider();
-    if (!provider) return null;
+    const selProvider = this.createAnalysisProvider("sel");
+    if (!selProvider) return null;
+    const routing = this.config.agent.routing;
+    const peslName = routing?.intelligence?.pesl;
+    const selName = routing?.intelligence?.sel ?? routing?.default;
+    const peslProvider = peslName !== void 0 && peslName !== selName ? this.createAnalysisProvider("pesl") : null;
     const peslModel = intel.models?.pesl ?? this.config.agent.model;
     const store = new GraphStore();
     this.graphStore = store;
-    return new IntelligencePipeline(provider, store, {
-      ...peslModel !== void 0 && { peslModel }
+    return new IntelligencePipeline(selProvider, store, {
+      ...peslModel !== void 0 && { peslModel },
+      ...peslProvider !== null && peslProvider !== void 0 && { peslProvider }
     });
   }
   /**
-   * Create the AnalysisProvider for the intelligence pipeline.
+   * Create the AnalysisProvider for an intelligence-pipeline layer
+   * (`sel` by default; `pesl` when constructing a distinct PESL
+   * provider per Spec 2 SC35).
+   *
+   * Spec 2 Phase 4 (SC31–SC36) — resolution order:
+   *   1. Explicit `intelligence.provider` config wins (preserves Phase 0–3 behavior; SC33).
+   *   2. Otherwise, consult `agent.routing.intelligence.<layer>` (or
+   *      `routing.default`) to pick a `BackendDef` from `agent.backends`,
+   *      then translate via `buildAnalysisProvider` (the per-type factory).
    *
-   * Resolution order:
-   * 1. Explicit `intelligence.provider` config (separate key/endpoint)
-   * 2. Local backend config (agent.localBackend + localEndpoint/localModel)
-   * 3. Primary agent backend config (agent.apiKey + agent.backend)
+   * Closes the Phase 2 deferral (P2-DEF-638): the legacy
+   * `this.config.agent.backend` read at the bottom of this method is
+   * removed; routing is the sole source for non-explicit configs.
+   *
+   * Cyclomatic complexity: pre-Phase-4 was 33 (factory dispatch was
+   * inlined here). Phase 4 extracts the per-type tree into
+   * `buildAnalysisProvider`, dropping this method to ≤ 5 branches
+   * (under the 15 threshold).
    */
-  createAnalysisProvider() {
+  createAnalysisProvider(layer = "sel") {
     const intel = this.config.intelligence;
-    const selModel = intel?.models?.sel ?? this.config.agent.model;
-    if (intel?.provider) {
-      return this.createProviderFromExplicitConfig(intel.provider, selModel);
-    }
-    if (this.config.agent.localBackend === "openai-compatible" || this.config.agent.localBackend === "pi") {
-      const endpoint = this.config.agent.localEndpoint ?? "http://localhost:11434/v1";
-      const apiKey = this.config.agent.localApiKey ?? "ollama";
-      const model = selModel ?? this.config.agent.localModel;
-      this.logger.info(`Intelligence pipeline using local backend at ${endpoint}`);
-      return new OpenAICompatibleAnalysisProvider({
-        apiKey,
-        baseUrl: endpoint,
-        ...model !== void 0 && { defaultModel: model },
-        ...intel?.requestTimeoutMs !== void 0 && { timeoutMs: intel.requestTimeoutMs },
-        ...intel?.promptSuffix !== void 0 && { promptSuffix: intel.promptSuffix },
-        ...intel?.jsonMode !== void 0 && { jsonMode: intel.jsonMode }
-      });
-    }
-    const backend = this.config.agent.backend;
-    if (backend === "anthropic" || backend === "claude") {
-      const apiKey = this.config.agent.apiKey ?? process.env.ANTHROPIC_API_KEY;
-      if (apiKey) {
-        return new AnthropicAnalysisProvider({
-          apiKey,
-          ...selModel !== void 0 && { defaultModel: selModel }
-        });
-      }
-    }
-    if (backend === "openai") {
-      const apiKey = this.config.agent.apiKey ?? process.env.OPENAI_API_KEY;
-      if (apiKey) {
-        return new OpenAICompatibleAnalysisProvider({
-          apiKey,
-          baseUrl: "https://api.openai.com/v1",
-          ...selModel !== void 0 && { defaultModel: selModel }
-        });
-      }
+    if (!intel?.enabled) return null;
+    if (intel.provider) {
+      const layerModel = layer === "sel" ? intel.models?.sel : intel.models?.pesl;
+      return this.createProviderFromExplicitConfig(
+        intel.provider,
+        layerModel ?? this.config.agent.model
+      );
     }
-    if (backend === "claude" || backend === "anthropic") {
-      this.logger.info("Intelligence pipeline using Claude CLI (no API key configured)");
-      return new ClaudeCliAnalysisProvider({
-        command: this.config.agent.command,
-        ...selModel !== void 0 && { defaultModel: selModel },
-        ...intel?.requestTimeoutMs !== void 0 && { timeoutMs: intel.requestTimeoutMs }
-      });
+    const routed = this.resolveRoutedBackendForIntelligence(layer);
+    if (!routed) return null;
+    const { name, def } = routed;
+    const resolver = this.localResolvers.get(name);
+    return buildAnalysisProvider({
+      def,
+      backendName: name,
+      layer,
+      // Spec 2 P3-IMP-1: a single snapshot read feeds the factory's
+      // unavailable-warn diagnostic (Configured/Detected lists) and
+      // collapses the two `getStatus()` calls flagged by P3-SUG-2.
+      getResolverStatusSnapshot: () => {
+        if (!resolver) return null;
+        const status = resolver.getStatus();
+        return {
+          available: status.available,
+          resolved: status.resolved,
+          configured: status.configured,
+          detected: status.detected
+        };
+      },
+      intelligence: intel,
+      logger: this.logger
+    });
+  }
+  /**
+   * Look up the routed BackendDef for an intelligence layer, falling
+   * back through `routing.intelligence.<layer>` → `routing.default`
+   * → null. Returns the resolved name alongside the def so callers can
+   * key into the per-name resolver map.
+   */
+  resolveRoutedBackendForIntelligence(layer) {
+    const routing = this.config.agent.routing;
+    const backends = this.config.agent.backends;
+    if (!routing || !backends) return null;
+    const layerName = routing.intelligence?.[layer];
+    const name = layerName ?? routing.default;
+    const def = backends[name];
+    if (!def) {
+      this.logger.warn(
+        `Intelligence pipeline: routed backend '${name}' for layer '${layer}' is not in agent.backends.`
+      );
+      return null;
     }
-    this.logger.warn(
-      `Intelligence pipeline: unsupported backend "${backend}". Supported: anthropic, claude, openai, or localBackend: openai-compatible / pi.`
-    );
-    return null;
+    return { name, def };
   }
   createProviderFromExplicitConfig(provider, selModel) {
     if (provider.kind === "anthropic") {
@@ -7183,13 +8175,13 @@ var Orchestrator = class extends EventEmitter {
       if (!apiKey2) {
         throw new Error("Intelligence pipeline: no Anthropic API key found.");
       }
-      return new AnthropicAnalysisProvider({
+      return new AnthropicAnalysisProvider2({
         apiKey: apiKey2,
         ...selModel !== void 0 && { defaultModel: selModel }
       });
     }
     if (provider.kind === "claude-cli") {
-      return new ClaudeCliAnalysisProvider({
+      return new ClaudeCliAnalysisProvider2({
         command: this.config.agent.command,
         ...selModel !== void 0 && { defaultModel: selModel },
         ...this.config.intelligence?.requestTimeoutMs !== void 0 && {
@@ -7200,7 +8192,7 @@ var Orchestrator = class extends EventEmitter {
     const apiKey = provider.apiKey ?? this.config.agent.apiKey ?? "ollama";
     const baseUrl = provider.baseUrl ?? "http://localhost:11434/v1";
     const intel = this.config.intelligence;
-    return new OpenAICompatibleAnalysisProvider({
+    return new OpenAICompatibleAnalysisProvider2({
       apiKey,
       baseUrl,
       ...selModel !== void 0 && { defaultModel: selModel },
@@ -7682,9 +8674,18 @@ var Orchestrator = class extends EventEmitter {
         issue,
         attempt: attempt || 1
       });
+      const useCase = useCaseForBackendParam(issue, backend);
+      let routedBackendName;
+      if (this.overrideBackend !== null) {
+        routedBackendName = this.overrideBackend.name;
+      } else if (this.backendFactory !== null) {
+        routedBackendName = this.backendFactory.resolveName(useCase);
+      } else {
+        routedBackendName = this.config.agent.routing?.default ?? this.config.agent.backend ?? "unknown";
+      }
       const session = {
         sessionId: `pending-${Date.now()}`,
-        backendName: this.config.agent.backend,
+        backendName: routedBackendName,
         agentPid: null,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         lastEvent: "Dispatching",
@@ -7711,11 +8712,23 @@ var Orchestrator = class extends EventEmitter {
         issue.id,
         issue.externalId ?? null,
         issue.identifier,
-        this.config.agent.backend,
+        routedBackendName,
         attempt ?? 1,
         issue.title
       );
-      const activeRunner = backend === "local" && this.localRunner ? this.localRunner : this.runner;
+      let agentBackend;
+      if (this.overrideBackend !== null) {
+        agentBackend = this.overrideBackend;
+      } else if (this.backendFactory !== null) {
+        agentBackend = this.backendFactory.forUseCase(useCase);
+      } else {
+        throw new Error(
+          `Cannot dispatch ${issue.identifier}: agent.backends not synthesized (migration failed) and no override backend supplied. Migrate to agent.backends/agent.routing per docs/guides/multi-backend-routing.md.`
+        );
+      }
+      const activeRunner = new AgentRunner(agentBackend, {
+        maxTurns: this.config.agent.maxTurns
+      });
       this.runAgentInBackgroundTask(issue, workspacePath, prompt, attempt, activeRunner);
     } catch (error) {
       this.logger.error(`Dispatch failed for ${issue.identifier}`, { error: String(error) });
@@ -7748,7 +8761,7 @@ var Orchestrator = class extends EventEmitter {
     }
   }
   runAgentInBackgroundTask(issue, workspacePath, prompt, attempt, runner) {
-    const activeRunner = runner ?? this.runner;
+    const activeRunner = runner;
     this.logger.info(`Starting background task for ${issue.identifier}`);
     const abortController = new AbortController();
     this.abortControllers.set(issue.id, { controller: abortController, pid: null });
@@ -7869,6 +8882,42 @@ var Orchestrator = class extends EventEmitter {
     this.emit("state_change", this.getSnapshot());
     await this.dispatchIssue(issue, 1, "local");
   }
+  /**
+   * Initialize the LocalModelResolver and intelligence pipeline.
+   *
+   * Runs the initial probe (so resolver state reflects server availability)
+   * before constructing the intelligence pipeline. Subscribes the dashboard
+   * broadcast stub to status changes. Called exactly once from start().
+   */
+  async initLocalModelAndPipeline() {
+    if (this.localResolvers.size > 0) {
+      const backends = this.config.agent.backends ?? {};
+      for (const [name, resolver] of this.localResolvers) {
+        const def = backends[name];
+        if (!def || def.type !== "local" && def.type !== "pi") {
+          this.logger.warn("Resolver without matching backend def \u2014 broadcast skipped", {
+            name
+          });
+          continue;
+        }
+        const endpoint = def.endpoint;
+        const unsubscribe = resolver.onStatusChange((status) => {
+          const named = {
+            ...status,
+            backendName: name,
+            endpoint
+          };
+          this.server?.broadcastLocalModelStatus(named);
+        });
+        this.localModelStatusUnsubscribes.push(unsubscribe);
+      }
+      for (const resolver of this.localResolvers.values()) {
+        await resolver.start();
+      }
+    }
+    this.pipeline = this.createIntelligencePipeline();
+    this.server?.setPipeline(this.pipeline);
+  }
   /**
    * Starts the polling loop and the internal HTTP server.
    * Runs startup reconciliation to release orphaned claims before the first tick.
@@ -7877,6 +8926,7 @@ var Orchestrator = class extends EventEmitter {
     if (this.server) {
       void this.server.start();
     }
+    await this.initLocalModelAndPipeline();
     await this.ensureClaimManager();
     const runningIssueIds = new Set(this.state.running.keys());
     const reconcileResult = await this.claimManager.reconcileOnStartup(runningIssueIds);
@@ -7928,6 +8978,13 @@ var Orchestrator = class extends EventEmitter {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = void 0;
     }
+    for (const unsub of this.localModelStatusUnsubscribes) {
+      unsub();
+    }
+    this.localModelStatusUnsubscribes = [];
+    for (const resolver of this.localResolvers.values()) {
+      resolver.stop();
+    }
     if (this.maintenanceScheduler) {
       this.maintenanceScheduler.stop();
       this.maintenanceScheduler = null;
@@ -8204,12 +9261,14 @@ function launchTUI(orchestrator) {
 }
 export {
   AnalysisArchive,
+  BackendRouter,
   ClaimManager,
   InteractionQueue,
   LinearGraphQLStub,
   MockBackend,
   ORCHESTRATOR_IDENTITY_FILE,
   Orchestrator,
+  OrchestratorBackendFactory,
   PRDetector,
   PromptRenderer,
   RoadmapTrackerAdapter,
@@ -8222,6 +9281,7 @@ export {
   calculateRetryDelay,
   canDispatch,
   computeRateLimitDelay,
+  createBackend,
   createEmptyState,
   detectScopeTier,
   extractHighlights,
@@ -8232,6 +9292,7 @@ export {
   isEligible,
   launchTUI,
   loadPublishedIndex,
+  migrateAgentConfig,
   reconcile,
   renderAnalysisComment,
   renderPRComment,