@harness-engineering/orchestrator 0.2.16 → 0.3.0

package/dist/index.js

@@ -31,12 +31,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AnalysisArchive: () => AnalysisArchive,
+  BackendRouter: () => BackendRouter,
   ClaimManager: () => ClaimManager,
   InteractionQueue: () => InteractionQueue,
   LinearGraphQLStub: () => LinearGraphQLStub,
   MockBackend: () => MockBackend,
   ORCHESTRATOR_IDENTITY_FILE: () => ORCHESTRATOR_IDENTITY_FILE,
   Orchestrator: () => Orchestrator,
+  OrchestratorBackendFactory: () => OrchestratorBackendFactory,
   PRDetector: () => PRDetector,
   PromptRenderer: () => PromptRenderer,
   RoadmapTrackerAdapter: () => RoadmapTrackerAdapter,
@@ -49,6 +51,7 @@ __export(index_exports, {
   calculateRetryDelay: () => calculateRetryDelay,
   canDispatch: () => canDispatch,
   computeRateLimitDelay: () => computeRateLimitDelay,
+  createBackend: () => createBackend,
   createEmptyState: () => createEmptyState,
   detectScopeTier: () => detectScopeTier,
   extractHighlights: () => extractHighlights,
@@ -59,6 +62,7 @@ __export(index_exports, {
   isEligible: () => isEligible,
   launchTUI: () => launchTUI,
   loadPublishedIndex: () => loadPublishedIndex,
+  migrateAgentConfig: () => migrateAgentConfig,
   reconcile: () => reconcile,
   renderAnalysisComment: () => renderAnalysisComment,
   renderPRComment: () => renderPRComment,
@@ -1846,8 +1850,89 @@ var import_yaml = require("yaml");
 var import_types3 = require("@harness-engineering/types");
 
 // src/workflow/config.ts
+var import_zod2 = require("zod");
 var import_types2 = require("@harness-engineering/types");
+
+// src/workflow/schema.ts
+var import_zod = require("zod");
+var ModelSchema = import_zod.z.union([import_zod.z.string().min(1), import_zod.z.array(import_zod.z.string().min(1)).nonempty()], {
+  errorMap: () => ({
+    message: "model must be a non-empty string or array of strings"
+  })
+});
+var BackendDefSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("mock") }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("claude"),
+    command: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("anthropic"),
+    model: import_zod.z.string().min(1),
+    apiKey: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("openai"),
+    model: import_zod.z.string().min(1),
+    apiKey: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("gemini"),
+    model: import_zod.z.string().min(1),
+    apiKey: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("local"),
+    endpoint: import_zod.z.string().url(),
+    model: ModelSchema,
+    apiKey: import_zod.z.string().optional(),
+    timeoutMs: import_zod.z.number().int().positive().optional(),
+    probeIntervalMs: import_zod.z.number().int().min(1e3).optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("pi"),
+    endpoint: import_zod.z.string().url(),
+    model: ModelSchema,
+    apiKey: import_zod.z.string().optional(),
+    timeoutMs: import_zod.z.number().int().positive().optional(),
+    probeIntervalMs: import_zod.z.number().int().min(1e3).optional()
+  }).strict()
+]);
+var RoutingConfigSchema = import_zod.z.object({
+  default: import_zod.z.string().min(1),
+  "quick-fix": import_zod.z.string().optional(),
+  "guided-change": import_zod.z.string().optional(),
+  "full-exploration": import_zod.z.string().optional(),
+  diagnostic: import_zod.z.string().optional(),
+  intelligence: import_zod.z.object({
+    sel: import_zod.z.string().optional(),
+    pesl: import_zod.z.string().optional()
+  }).strict().optional()
+}).strict();
+
+// src/workflow/config.ts
 var REQUIRED_SECTIONS = ["tracker", "polling", "workspace", "hooks", "agent", "server"];
+var BackendsMapSchema = import_zod2.z.record(import_zod2.z.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 (0, import_types2.Err)(new Error("Config is missing or not an object"));
@@ -1858,6 +1943,35 @@ function validateWorkflowConfig(config) {
   if (c.intelligence !== void 0 && (typeof c.intelligence !== "object" || c.intelligence === null)) {
     return (0, import_types2.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 (0, import_types2.Err)(new Error("Config must define agent.backend or agent.backends."));
+  }
+  if (hasModernBackends) {
+    const backendsParsed = BackendsMapSchema.safeParse(agent.backends);
+    if (!backendsParsed.success) {
+      return (0, import_types2.Err)(new Error(`agent.backends: ${backendsParsed.error.message}`));
+    }
+    const routingParsed = RoutingConfigSchema.optional().safeParse(agent.routing);
+    if (!routingParsed.success) {
+      return (0, import_types2.Err)(new Error(`agent.routing: ${routingParsed.error.message}`));
+    }
+    if (routingParsed.data) {
+      const cross = crossFieldRoutingIssues(
+        backendsParsed.data,
+        routingParsed.data
+      );
+      if (cross.length > 0) {
+        return (0, import_types2.Err)(
+          new Error(
+            `Cross-field: ${cross.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+          )
+        );
+      }
+    }
+  }
   return (0, import_types2.Ok)(config);
 }
 function getDefaultConfig() {
@@ -2561,7 +2675,7 @@ var import_node_events = require("events");
 var path15 = __toESM(require("path"));
 var import_node_crypto7 = require("crypto");
 var import_core9 = require("@harness-engineering/core");
-var import_intelligence3 = require("@harness-engineering/intelligence");
+var import_intelligence4 = require("@harness-engineering/intelligence");
 var import_graph = require("@harness-engineering/graph");
 
 // src/intelligence/pipeline-runner.ts
@@ -3242,6 +3356,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
 var import_node_child_process4 = require("child_process");
 var readline = __toESM(require("readline"));
@@ -3594,10 +4130,120 @@ var ClaudeBackend = class {
   }
 };
 
-// src/agent/backends/openai.ts
-var import_openai = __toESM(require("openai"));
+// src/agent/backends/anthropic.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_types10 = require("@harness-engineering/types");
 var import_core4 = require("@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 import_sdk.default({ apiKey: this.config.apiKey });
+    this.cacheAdapter = new import_core4.AnthropicCacheAdapter();
+  }
+  async startSession(params) {
+    if (!this.config.apiKey) {
+      return (0, import_types10.Err)({
+        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 (0, import_types10.Ok)(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 (0, import_types10.Ok)(void 0);
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) {
+      return (0, import_types10.Err)({
+        category: "response_error",
+        message: "ANTHROPIC_API_KEY is not set"
+      });
+    }
+    return (0, import_types10.Ok)(void 0);
+  }
+};
+
+// src/agent/backends/openai.ts
+var import_openai = __toESM(require("openai"));
+var import_types11 = require("@harness-engineering/types");
+var import_core5 = require("@harness-engineering/core");
 var OpenAIBackend = class {
   name = "openai";
   config;
@@ -3609,11 +4255,11 @@ var OpenAIBackend = class {
       apiKey: config.apiKey ?? process.env.OPENAI_API_KEY ?? ""
     };
     this.client = new import_openai.default({ apiKey: this.config.apiKey });
-    this.cacheAdapter = new import_core4.OpenAICacheAdapter();
+    this.cacheAdapter = new import_core5.OpenAICacheAdapter();
   }
   async startSession(params) {
     if (!this.config.apiKey) {
-      return (0, import_types10.Err)({
+      return (0, import_types11.Err)({
         category: "agent_not_found",
         message: "OPENAI_API_KEY is not set"
       });
@@ -3625,7 +4271,7 @@ var OpenAIBackend = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
     };
-    return (0, import_types10.Ok)(session);
+    return (0, import_types11.Ok)(session);
   }
   async *runTurn(session, params) {
     const openAISession = session;
@@ -3701,14 +4347,14 @@ var OpenAIBackend = class {
     };
   }
   async stopSession(_session) {
-    return (0, import_types10.Ok)(void 0);
+    return (0, import_types11.Ok)(void 0);
   }
   async healthCheck() {
     try {
       await this.client.models.list();
-      return (0, import_types10.Ok)(void 0);
+      return (0, import_types11.Ok)(void 0);
     } catch (err) {
-      return (0, import_types10.Err)({
+      return (0, import_types11.Err)({
         category: "response_error",
         message: err instanceof Error ? err.message : "OpenAI health check failed"
       });
@@ -3718,8 +4364,8 @@ var OpenAIBackend = class {
 
 // src/agent/backends/gemini.ts
 var import_generative_ai = require("@google/generative-ai");
-var import_types11 = require("@harness-engineering/types");
-var import_core5 = require("@harness-engineering/core");
+var import_types12 = require("@harness-engineering/types");
+var import_core6 = require("@harness-engineering/core");
 var GeminiBackend = class {
   name = "gemini";
   config;
@@ -3729,11 +4375,11 @@ var GeminiBackend = class {
       model: config.model ?? "gemini-2.0-flash",
       apiKey: config.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY ?? ""
     };
-    this.cacheAdapter = new import_core5.GeminiCacheAdapter();
+    this.cacheAdapter = new import_core6.GeminiCacheAdapter();
   }
   async startSession(params) {
     if (!this.config.apiKey) {
-      return (0, import_types11.Err)({
+      return (0, import_types12.Err)({
         category: "agent_not_found",
         message: "GEMINI_API_KEY is not set"
       });
@@ -3745,7 +4391,7 @@ var GeminiBackend = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...params.systemPrompt !== void 0 && { systemPrompt: params.systemPrompt }
     };
-    return (0, import_types11.Ok)(session);
+    return (0, import_types12.Ok)(session);
   }
   async *runTurn(session, params) {
     const geminiSession = session;
@@ -3815,132 +4461,22 @@ var GeminiBackend = class {
       success: true,
       sessionId: session.sessionId,
       usage
-    };
-  }
-  async stopSession(_session) {
-    return (0, import_types11.Ok)(void 0);
-  }
-  async healthCheck() {
-    try {
-      const genAI = new import_generative_ai.GoogleGenerativeAI(this.config.apiKey);
-      genAI.getGenerativeModel({ model: this.config.model });
-      return (0, import_types11.Ok)(void 0);
-    } catch (err) {
-      return (0, import_types11.Err)({
-        category: "response_error",
-        message: err instanceof Error ? err.message : "Gemini health check failed"
-      });
-    }
-  }
-};
-
-// src/agent/backends/anthropic.ts
-var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_types12 = require("@harness-engineering/types");
-var import_core6 = require("@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 import_sdk.default({ apiKey: this.config.apiKey });
-    this.cacheAdapter = new import_core6.AnthropicCacheAdapter();
-  }
-  async startSession(params) {
-    if (!this.config.apiKey) {
-      return (0, import_types12.Err)({
-        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 (0, import_types12.Ok)(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 (0, import_types12.Ok)(void 0);
   }
   async healthCheck() {
-    if (!this.config.apiKey) {
+    try {
+      const genAI = new import_generative_ai.GoogleGenerativeAI(this.config.apiKey);
+      genAI.getGenerativeModel({ model: this.config.model });
+      return (0, import_types12.Ok)(void 0);
+    } catch (err) {
       return (0, import_types12.Err)({
         category: "response_error",
-        message: "ANTHROPIC_API_KEY is not set"
+        message: err instanceof Error ? err.message : "Gemini health check failed"
       });
     }
-    return (0, import_types12.Ok)(void 0);
   }
 };
 
@@ -3951,6 +4487,7 @@ var DEFAULT_TIMEOUT_MS = 9e4;
 var LocalBackend = class {
   name = "local";
   config;
+  getModel;
   client;
   constructor(config = {}) {
     this.config = {
@@ -3959,6 +4496,7 @@ var LocalBackend = class {
       apiKey: config.apiKey ?? "ollama",
       timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
     };
+    this.getModel = config.getModel;
     this.client = new import_openai2.default({
       apiKey: this.config.apiKey,
       baseURL: this.config.endpoint,
@@ -3966,11 +4504,25 @@ var LocalBackend = class {
     });
   }
   async startSession(params) {
+    let resolvedModel;
+    if (this.getModel) {
+      const candidate = this.getModel();
+      if (candidate === null) {
+        return (0, import_types13.Err)({
+          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 (0, import_types13.Ok)(session);
@@ -3987,7 +4539,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 }
@@ -4152,13 +4704,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 (0, import_types14.Err)({
+            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 },
@@ -4198,15 +4778,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;
@@ -4222,12 +4832,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) {
@@ -4287,6 +4900,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
 var import_types15 = require("@harness-engineering/types");
 function toAgentError(message, details) {
@@ -4648,6 +5315,191 @@ 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
+var import_intelligence2 = require("@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 import_intelligence2.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 import_intelligence2.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 import_intelligence2.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 import_intelligence2.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 import_intelligence2.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
 var http = __toESM(require("http"));
 var path13 = __toESM(require("path"));
@@ -4707,7 +5559,7 @@ var WebSocketBroadcaster = class {
 };
 
 // src/server/routes/interactions.ts
-var import_zod = require("zod");
+var import_zod3 = require("zod");
 
 // src/server/utils.ts
 var DEFAULT_MAX_BYTES = 1048576;
@@ -4730,8 +5582,8 @@ function readBody(req, maxBytes = DEFAULT_MAX_BYTES) {
 }
 
 // src/server/routes/interactions.ts
-var InteractionUpdateSchema = import_zod.z.object({
-  status: import_zod.z.enum(["pending", "claimed", "resolved"])
+var InteractionUpdateSchema = import_zod3.z.object({
+  status: import_zod3.z.enum(["pending", "claimed", "resolved"])
 });
 var SAFE_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function sendJson(res, status, body) {
@@ -4782,12 +5634,12 @@ function handleInteractionsRoute(req, res, queue) {
 }
 
 // src/server/routes/plans.ts
-var import_zod2 = require("zod");
+var import_zod4 = require("zod");
 var fs9 = __toESM(require("fs/promises"));
 var path9 = __toESM(require("path"));
-var PlanWriteSchema = import_zod2.z.object({
-  filename: import_zod2.z.string().min(1),
-  content: import_zod2.z.string().min(1)
+var PlanWriteSchema = import_zod4.z.object({
+  filename: import_zod4.z.string().min(1),
+  content: import_zod4.z.string().min(1)
 });
 function handlePlansRoute(req, res, plansDir) {
   const { method, url } = req;
@@ -4831,7 +5683,7 @@ function handlePlansRoute(req, res, plansDir) {
 var import_node_child_process8 = require("child_process");
 var import_node_crypto5 = require("crypto");
 var readline2 = __toESM(require("readline"));
-var import_zod3 = require("zod");
+var import_zod5 = require("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",
@@ -4866,10 +5718,10 @@ function buildChildEnv() {
   }
   return env;
 }
-var ChatRequestSchema = import_zod3.z.object({
-  prompt: import_zod3.z.string().min(1),
-  system: import_zod3.z.string().optional(),
-  sessionId: import_zod3.z.string().regex(UUID_RE).optional()
+var ChatRequestSchema = import_zod5.z.object({
+  prompt: import_zod5.z.string().min(1),
+  system: import_zod5.z.string().optional(),
+  sessionId: import_zod5.z.string().regex(UUID_RE).optional()
 });
 function handleChatProxyRoute(req, res, command = "claude") {
   const { method, url } = req;
@@ -5078,12 +5930,12 @@ function extractChunks(event) {
 }
 
 // src/server/routes/analyze.ts
-var import_intelligence2 = require("@harness-engineering/intelligence");
-var import_zod4 = require("zod");
-var AnalyzeRequestSchema = import_zod4.z.object({
-  title: import_zod4.z.string().min(1),
-  description: import_zod4.z.string().optional(),
-  labels: import_zod4.z.array(import_zod4.z.string()).optional()
+var import_intelligence3 = require("@harness-engineering/intelligence");
+var import_zod6 = require("zod");
+var AnalyzeRequestSchema = import_zod6.z.object({
+  title: import_zod6.z.string().min(1),
+  description: import_zod6.z.string().optional(),
+  labels: import_zod6.z.array(import_zod6.z.string()).optional()
 });
 function emit2(res, event) {
   res.write(`data: ${JSON.stringify(event)}
@@ -5108,7 +5960,7 @@ async function runPipeline(res, pipeline, parsed) {
     disconnected = true;
   });
   emit2(res, { type: "status", text: "Converting to work item..." });
-  const rawItem = (0, import_intelligence2.manualToRawWorkItem)({
+  const rawItem = (0, import_intelligence3.manualToRawWorkItem)({
     title: parsed.title,
     description: parsed.description ?? "",
     labels: parsed.labels ?? []
@@ -5151,7 +6003,7 @@ async function runPipeline(res, pipeline, parsed) {
     }
   }
   if (disconnected) return;
-  const signals = (0, import_intelligence2.scoreToConcernSignals)(score);
+  const signals = (0, import_intelligence3.scoreToConcernSignals)(score);
   if (signals.length > 0) {
     emit2(res, { type: "signals", data: signals });
   }
@@ -5191,19 +6043,19 @@ function handleAnalyzeRoute(req, res, pipeline) {
 // src/server/routes/roadmap-actions.ts
 var fs10 = __toESM(require("fs/promises"));
 var import_core7 = require("@harness-engineering/core");
-var import_zod5 = require("zod");
-var AppendRoadmapRequestSchema = import_zod5.z.object({
-  title: import_zod5.z.string().min(1),
-  summary: import_zod5.z.string().optional(),
-  labels: import_zod5.z.array(import_zod5.z.string()).optional(),
-  enrichedSpec: import_zod5.z.object({
-    intent: import_zod5.z.string(),
-    unknowns: import_zod5.z.array(import_zod5.z.string()),
-    ambiguities: import_zod5.z.array(import_zod5.z.string()),
-    riskSignals: import_zod5.z.array(import_zod5.z.string()),
-    affectedSystems: import_zod5.z.array(import_zod5.z.object({ name: import_zod5.z.string() }))
+var import_zod7 = require("zod");
+var AppendRoadmapRequestSchema = import_zod7.z.object({
+  title: import_zod7.z.string().min(1),
+  summary: import_zod7.z.string().optional(),
+  labels: import_zod7.z.array(import_zod7.z.string()).optional(),
+  enrichedSpec: import_zod7.z.object({
+    intent: import_zod7.z.string(),
+    unknowns: import_zod7.z.array(import_zod7.z.string()),
+    ambiguities: import_zod7.z.array(import_zod7.z.string()),
+    riskSignals: import_zod7.z.array(import_zod7.z.string()),
+    affectedSystems: import_zod7.z.array(import_zod7.z.object({ name: import_zod7.z.string() }))
   }).optional(),
-  cmlRecommendedRoute: import_zod5.z.enum(["local", "human", "simulation-required"]).optional()
+  cmlRecommendedRoute: import_zod7.z.enum(["local", "human", "simulation-required"]).optional()
 });
 function sendJSON(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5274,11 +6126,11 @@ function handleRoadmapActionsRoute(req, res, roadmapPath) {
 
 // src/server/routes/dispatch-actions.ts
 var import_node_crypto6 = require("crypto");
-var import_zod6 = require("zod");
-var DispatchAdHocRequestSchema = import_zod6.z.object({
-  title: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().optional(),
-  labels: import_zod6.z.array(import_zod6.z.string()).optional()
+var import_zod8 = require("zod");
+var DispatchAdHocRequestSchema = import_zod8.z.object({
+  title: import_zod8.z.string().min(1),
+  description: import_zod8.z.string().optional(),
+  labels: import_zod8.z.array(import_zod8.z.string()).optional()
 });
 function sendJSON2(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5375,9 +6227,9 @@ function handleAnalysesRoute(req, res, archive) {
 }
 
 // src/server/routes/maintenance.ts
-var import_zod7 = require("zod");
-var TriggerRequestSchema = import_zod7.z.object({
-  taskId: import_zod7.z.string().min(1)
+var import_zod9 = require("zod");
+var TriggerRequestSchema = import_zod9.z.object({
+  taskId: import_zod9.z.string().min(1)
 });
 function sendJSON3(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -5456,9 +6308,9 @@ function handleMaintenanceRoute(req, res, deps) {
 // src/server/routes/sessions.ts
 var fs11 = __toESM(require("fs/promises"));
 var path10 = __toESM(require("path"));
-var import_zod8 = require("zod");
-var SessionCreateSchema = import_zod8.z.object({
-  sessionId: import_zod8.z.string().min(1)
+var import_zod10 = require("zod");
+var SessionCreateSchema = import_zod10.z.object({
+  sessionId: import_zod10.z.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) {
@@ -5545,7 +6397,7 @@ async function handleUpdate(req, res, url, sessionsDir) {
       return;
     }
     const body = await readBody(req);
-    const updates = import_zod8.z.record(import_zod8.z.unknown()).parse(JSON.parse(body));
+    const updates = import_zod10.z.record(import_zod10.z.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));
@@ -5664,6 +6516,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
 var fs12 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
@@ -5817,6 +6705,8 @@ var OrchestratorServer = class {
   dispatchAdHoc;
   sessionsDir;
   maintenanceDeps = null;
+  getLocalModelStatus = null;
+  getLocalModelStatuses = null;
   recorder = null;
   planWatcher = null;
   stateChangeListener;
@@ -5843,6 +6733,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) => {
@@ -5869,6 +6761,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.
@@ -5945,6 +6862,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;
     }
@@ -6509,17 +7432,17 @@ var MaintenanceScheduler = class {
 // src/maintenance/reporter.ts
 var fs14 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
-var import_zod9 = require("zod");
-var RunResultSchema = import_zod9.z.object({
-  taskId: import_zod9.z.string(),
-  startedAt: import_zod9.z.string(),
-  completedAt: import_zod9.z.string(),
-  status: import_zod9.z.enum(["success", "failure", "skipped", "no-issues"]),
-  findings: import_zod9.z.number(),
-  fixed: import_zod9.z.number(),
-  prUrl: import_zod9.z.string().nullable(),
-  prUpdated: import_zod9.z.boolean(),
-  error: import_zod9.z.string().optional()
+var import_zod11 = require("zod");
+var RunResultSchema = import_zod11.z.object({
+  taskId: import_zod11.z.string(),
+  startedAt: import_zod11.z.string(),
+  completedAt: import_zod11.z.string(),
+  status: import_zod11.z.enum(["success", "failure", "skipped", "no-issues"]),
+  findings: import_zod11.z.number(),
+  fixed: import_zod11.z.number(),
+  prUrl: import_zod11.z.string().nullable(),
+  prUpdated: import_zod11.z.boolean(),
+  error: import_zod11.z.string().optional()
 });
 var MAX_HISTORY = 500;
 var fallbackLogger = {
@@ -6546,7 +7469,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 = import_zod9.z.array(RunResultSchema).safeParse(JSON.parse(data));
+      const parsed = import_zod11.z.array(RunResultSchema).safeParse(JSON.parse(data));
       if (parsed.success) {
         this.history = parsed.data.slice(0, MAX_HISTORY);
       }
@@ -6829,13 +7752,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 import_node_events.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;
@@ -6843,7 +7796,22 @@ var Orchestrator = class extends import_node_events.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;
@@ -6885,20 +7853,60 @@ var Orchestrator = class extends import_node_events.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,
@@ -6942,7 +7950,25 @@ var Orchestrator = class extends import_node_events.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) => {
@@ -6956,44 +7982,6 @@ var Orchestrator = class extends import_node_events.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.
@@ -7119,97 +8107,98 @@ var Orchestrator = class extends import_node_events.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 import_graph.GraphStore();
     this.graphStore = store;
-    return new import_intelligence3.IntelligencePipeline(provider, store, {
-      ...peslModel !== void 0 && { peslModel }
+    return new import_intelligence4.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 import_intelligence3.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 import_intelligence3.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 import_intelligence3.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 import_intelligence3.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") {
@@ -7217,13 +8206,13 @@ var Orchestrator = class extends import_node_events.EventEmitter {
       if (!apiKey2) {
         throw new Error("Intelligence pipeline: no Anthropic API key found.");
       }
-      return new import_intelligence3.AnthropicAnalysisProvider({
+      return new import_intelligence4.AnthropicAnalysisProvider({
         apiKey: apiKey2,
         ...selModel !== void 0 && { defaultModel: selModel }
       });
     }
     if (provider.kind === "claude-cli") {
-      return new import_intelligence3.ClaudeCliAnalysisProvider({
+      return new import_intelligence4.ClaudeCliAnalysisProvider({
         command: this.config.agent.command,
         ...selModel !== void 0 && { defaultModel: selModel },
         ...this.config.intelligence?.requestTimeoutMs !== void 0 && {
@@ -7234,7 +8223,7 @@ var Orchestrator = class extends import_node_events.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 import_intelligence3.OpenAICompatibleAnalysisProvider({
+    return new import_intelligence4.OpenAICompatibleAnalysisProvider({
       apiKey,
       baseUrl,
       ...selModel !== void 0 && { defaultModel: selModel },
@@ -7716,9 +8705,18 @@ var Orchestrator = class extends import_node_events.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",
@@ -7745,11 +8743,23 @@ var Orchestrator = class extends import_node_events.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) });
@@ -7782,7 +8792,7 @@ var Orchestrator = class extends import_node_events.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 });
@@ -7903,6 +8913,42 @@ var Orchestrator = class extends import_node_events.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.
@@ -7911,6 +8957,7 @@ var Orchestrator = class extends import_node_events.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);
@@ -7962,6 +9009,13 @@ var Orchestrator = class extends import_node_events.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;
@@ -8239,12 +9293,14 @@ function launchTUI(orchestrator) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnalysisArchive,
+  BackendRouter,
   ClaimManager,
   InteractionQueue,
   LinearGraphQLStub,
   MockBackend,
   ORCHESTRATOR_IDENTITY_FILE,
   Orchestrator,
+  OrchestratorBackendFactory,
   PRDetector,
   PromptRenderer,
   RoadmapTrackerAdapter,
@@ -8257,6 +9313,7 @@ function launchTUI(orchestrator) {
   calculateRetryDelay,
   canDispatch,
   computeRateLimitDelay,
+  createBackend,
   createEmptyState,
   detectScopeTier,
   extractHighlights,
@@ -8267,6 +9324,7 @@ function launchTUI(orchestrator) {
   isEligible,
   launchTUI,
   loadPublishedIndex,
+  migrateAgentConfig,
   reconcile,
   renderAnalysisComment,
   renderPRComment,