@harness-engineering/orchestrator 0.8.4 → 0.9.1

package/dist/index.js

@@ -34,13 +34,18 @@ __export(index_exports, {
   BUILT_IN_TASKS: () => BUILT_IN_TASKS,
   BackendDefSchema: () => BackendDefSchema,
   BackendRouter: () => BackendRouter,
+  CheckScriptRunner: () => CheckScriptRunner,
   ClaimManager: () => ClaimManager,
   GateNotReadyError: () => GateNotReadyError,
   GateRunError: () => GateRunError,
   InteractionQueue: () => InteractionQueue,
+  LinearGraphQLClient: () => LinearGraphQLClient,
   LinearGraphQLStub: () => LinearGraphQLStub,
   LocalModelResolver: () => LocalModelResolver,
+  MAINTENANCE_CHECK_MAX_BUFFER: () => MAINTENANCE_CHECK_MAX_BUFFER,
+  MAINTENANCE_CHECK_TIMEOUT_MS: () => MAINTENANCE_CHECK_TIMEOUT_MS,
   MAX_ATTEMPTS: () => MAX_ATTEMPTS,
+  MaintenanceReporter: () => MaintenanceReporter,
   MockBackend: () => MockBackend,
   ORCHESTRATOR_IDENTITY_FILE: () => ORCHESTRATOR_IDENTITY_FILE,
   Orchestrator: () => Orchestrator,
@@ -58,6 +63,7 @@ __export(index_exports, {
   SqliteSearchIndex: () => SqliteSearchIndex,
   StreamRecorder: () => StreamRecorder,
   TaskOutputStore: () => TaskOutputStore,
+  TaskRunner: () => TaskRunner,
   TokenStore: () => TokenStore,
   WebhookQueue: () => WebhookQueue,
   WorkflowLoader: () => WorkflowLoader,
@@ -68,7 +74,9 @@ __export(index_exports, {
   buildArchiveHooks: () => buildArchiveHooks,
   calculateRetryDelay: () => calculateRetryDelay,
   canDispatch: () => canDispatch,
+  classifyCheckExecutionFailure: () => classifyCheckExecutionFailure,
   computeRateLimitDelay: () => computeRateLimitDelay,
+  createAgentDispatcher: () => createAgentDispatcher,
   createBackend: () => createBackend,
   createEmptyState: () => createEmptyState,
   crossFieldRoutingIssues: () => crossFieldRoutingIssues,
@@ -80,22 +88,27 @@ __export(index_exports, {
   emitProposalApproved: () => emitProposalApproved,
   emitProposalCreated: () => emitProposalCreated,
   emitProposalRejected: () => emitProposalRejected,
+  explicitFindingsCount: () => explicitFindingsCount,
   extractHighlights: () => extractHighlights,
   extractTitlePrefix: () => extractTitlePrefix,
   getAvailableSlots: () => getAvailableSlots,
   getDefaultConfig: () => getDefaultConfig,
   getPerStateCount: () => getPerStateCount,
   indexSessionDirectory: () => indexSessionDirectory,
+  isCheckTimeoutError: () => isCheckTimeoutError,
   isEligible: () => isEligible,
   isSummaryEnabled: () => isSummaryEnabled,
   launchTUI: () => launchTUI,
   loadPublishedIndex: () => loadPublishedIndex,
+  makeBackendResolver: () => makeBackendResolver,
   migrateAgentConfig: () => migrateAgentConfig,
   normalizeFts5Query: () => normalizeFts5Query,
+  normalizeHarnessCommand: () => normalizeHarnessCommand,
   normalizeLocalModel: () => normalizeLocalModel,
   openSearchIndex: () => openSearchIndex,
   promote: () => promote,
   reconcile: () => reconcile,
+  recoverFindingsCount: () => recoverFindingsCount,
   reindexFromArchive: () => reindexFromArchive,
   renderAnalysisComment: () => renderAnalysisComment,
   renderLlmSummaryMarkdown: () => renderLlmSummaryMarkdown,
@@ -105,9 +118,11 @@ __export(index_exports, {
   routeIssue: () => routeIssue,
   routingWarnings: () => routingWarnings,
   runGate: () => runGate,
+  runHarnessCheck: () => runHarnessCheck,
   savePublishedIndex: () => savePublishedIndex,
   searchIndexPath: () => searchIndexPath,
   selectCandidates: () => selectCandidates,
+  selectTasks: () => selectTasks,
   sortCandidates: () => sortCandidates,
   summarizeArchivedSession: () => summarizeArchivedSession,
   syncMain: () => syncMain,
@@ -2327,7 +2342,6 @@ var WorkflowLoader = class {
 };
 
 // src/tracker/adapters/roadmap.ts
-var fs8 = __toESM(require("fs/promises"));
 var import_node_crypto2 = require("crypto");
 var import_core = require("@harness-engineering/core");
 var import_types4 = require("@harness-engineering/types");
@@ -2358,8 +2372,7 @@ var RoadmapTrackerAdapter = class {
   async fetchIssuesByStates(stateNames) {
     try {
       if (!this.config.filePath) return (0, import_types4.Err)(new Error("Missing filePath"));
-      const content = await fs8.readFile(this.config.filePath, "utf-8");
-      const roadmapResult = (0, import_core.parseRoadmap)(content);
+      const roadmapResult = await this.loadRoadmap();
       if (!roadmapResult.ok) return roadmapResult;
       const issues = [];
       for (const milestone of roadmapResult.value.milestones) {
@@ -2390,17 +2403,19 @@ var RoadmapTrackerAdapter = class {
       if (!terminal) {
         return (0, import_types4.Err)(new Error("Tracker config has no terminalStates; cannot mark complete"));
       }
-      const content = await fs8.readFile(this.config.filePath, "utf-8");
-      const roadmapResult = (0, import_core.parseRoadmap)(content);
+      const store = this.resolveStore();
+      const roadmapResult = await store.load();
       if (!roadmapResult.ok) return roadmapResult;
       const roadmap = roadmapResult.value;
+      const before = structuredClone(roadmap);
       const target = this.findFeatureById(roadmap.milestones, issueId);
       if (!target) return (0, import_types4.Ok)(void 0);
       const normalizedTerminal = this.config.terminalStates.map((s) => s.toLowerCase());
       if (normalizedTerminal.includes(target.status.toLowerCase())) return (0, import_types4.Ok)(void 0);
       const now = (/* @__PURE__ */ new Date()).toISOString();
       (0, import_core.setStatus)(roadmap, target, terminal, now.slice(0, 10));
-      await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
+      const persisted = await (0, import_core.applyRoadmapDiff)(store, before, roadmap);
+      if (!persisted.ok) return persisted;
       return (0, import_types4.Ok)(void 0);
     } catch (error) {
       return (0, import_types4.Err)(error instanceof Error ? error : new Error(String(error)));
@@ -2414,10 +2429,11 @@ var RoadmapTrackerAdapter = class {
   async claimIssue(issueId, orchestratorId) {
     try {
       if (!this.config.filePath) return (0, import_types4.Err)(new Error("Missing filePath"));
-      const content = await fs8.readFile(this.config.filePath, "utf-8");
-      const roadmapResult = (0, import_core.parseRoadmap)(content);
+      const store = this.resolveStore();
+      const roadmapResult = await store.load();
       if (!roadmapResult.ok) return roadmapResult;
       const roadmap = roadmapResult.value;
+      const before = structuredClone(roadmap);
       const target = this.findFeatureById(roadmap.milestones, issueId);
       if (!target) return (0, import_types4.Ok)(void 0);
       if (!(0, import_core.isClaimableBy)(target, orchestratorId)) {
@@ -2429,7 +2445,8 @@ var RoadmapTrackerAdapter = class {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       (0, import_core.claim)(roadmap, target, orchestratorId, now.slice(0, 10));
       target.updatedAt = now;
-      await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
+      const persisted = await (0, import_core.applyRoadmapDiff)(store, before, roadmap);
+      if (!persisted.ok) return persisted;
       return (0, import_types4.Ok)(void 0);
     } catch (error) {
       return (0, import_types4.Err)(error instanceof Error ? error : new Error(String(error)));
@@ -2446,10 +2463,11 @@ var RoadmapTrackerAdapter = class {
       if (!activeState) {
         return (0, import_types4.Err)(new Error("Tracker config has no activeStates; cannot release"));
       }
-      const content = await fs8.readFile(this.config.filePath, "utf-8");
-      const roadmapResult = (0, import_core.parseRoadmap)(content);
+      const store = this.resolveStore();
+      const roadmapResult = await store.load();
       if (!roadmapResult.ok) return roadmapResult;
       const roadmap = roadmapResult.value;
+      const before = structuredClone(roadmap);
       const target = this.findFeatureById(roadmap.milestones, issueId);
       if (!target) return (0, import_types4.Ok)(void 0);
       if (this.config.activeStates.includes(target.status) && target.assignee === null) {
@@ -2458,12 +2476,26 @@ var RoadmapTrackerAdapter = class {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       (0, import_core.setStatus)(roadmap, target, activeState, now.slice(0, 10));
       target.updatedAt = null;
-      await fs8.writeFile(this.config.filePath, (0, import_core.serializeRoadmap)(roadmap), "utf-8");
+      const persisted = await (0, import_core.applyRoadmapDiff)(store, before, roadmap);
+      if (!persisted.ok) return persisted;
       return (0, import_types4.Ok)(void 0);
     } catch (error) {
       return (0, import_types4.Err)(error instanceof Error ? error : new Error(String(error)));
     }
   }
+  /**
+   * Resolve the roadmap store anchored on the configured aggregate file path.
+   * The shard backend is chosen when a sibling `roadmap.d/` exists next to the
+   * file; otherwise the monolith file is read/written whole. Callers guard
+   * `this.config.filePath` before invoking.
+   */
+  resolveStore() {
+    return (0, import_core.resolveRoadmapStoreForFile)({ roadmapPath: this.config.filePath });
+  }
+  /** Load the roadmap via the store (sharded or monolith), returning a Result. */
+  loadRoadmap() {
+    return this.resolveStore().load();
+  }
   findFeatureById(milestones, issueId) {
     for (const milestone of milestones) {
       for (const feature of milestone.features) {
@@ -2480,8 +2512,7 @@ var RoadmapTrackerAdapter = class {
   async fetchIssueStatesByIds(issueIds) {
     try {
       if (!this.config.filePath) return (0, import_types4.Err)(new Error("Missing filePath"));
-      const content = await fs8.readFile(this.config.filePath, "utf-8");
-      const roadmapResult = (0, import_core.parseRoadmap)(content);
+      const roadmapResult = await this.loadRoadmap();
       if (!roadmapResult.ok) return roadmapResult;
       const issueMap = /* @__PURE__ */ new Map();
       for (const milestone of roadmapResult.value.milestones) {
@@ -2537,6 +2568,69 @@ var RoadmapTrackerAdapter = class {
 
 // src/tracker/extensions/linear.ts
 var import_types5 = require("@harness-engineering/types");
+var LINEAR_GRAPHQL_ENDPOINT = "https://api.linear.app/graphql";
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var LinearGraphQLClient = class {
+  apiKey;
+  endpoint;
+  fetchFn;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.endpoint = opts.endpoint ?? LINEAR_GRAPHQL_ENDPOINT;
+    this.fetchFn = opts.fetchFn ?? globalThis.fetch;
+  }
+  async query(query, variables) {
+    const sent = await this.sendRequest(query, variables);
+    if (!sent.ok) return sent;
+    const res = sent.value;
+    if (!res.ok) {
+      return (0, import_types5.Err)(await this.httpError(res));
+    }
+    const parsed = await this.parseEnvelope(res);
+    if (!parsed.ok) return parsed;
+    const envelope = parsed.value;
+    const graphqlError = envelopeError(envelope);
+    if (graphqlError) return (0, import_types5.Err)(graphqlError);
+    return (0, import_types5.Ok)(envelope.data ?? {});
+  }
+  /** POST the operation to Linear, normalizing transport throws into an `Err`. */
+  async sendRequest(query, variables) {
+    try {
+      const res = await this.fetchFn(this.endpoint, {
+        method: "POST",
+        headers: {
+          Authorization: this.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ query, variables: variables ?? {} })
+      });
+      return (0, import_types5.Ok)(res);
+    } catch (err) {
+      return (0, import_types5.Err)(new Error(`Linear GraphQL request failed: ${errorMessage(err)}`));
+    }
+  }
+  /** Build the error for a non-2xx HTTP response, including a truncated body. */
+  async httpError(res) {
+    const body = await res.text().catch(() => "");
+    const detail = body ? `: ${body.slice(0, 500)}` : "";
+    return new Error(`Linear GraphQL HTTP ${res.status}${detail}`);
+  }
+  /** Parse the JSON envelope, normalizing parse failures into an `Err`. */
+  async parseEnvelope(res) {
+    try {
+      return (0, import_types5.Ok)(await res.json());
+    } catch (err) {
+      return (0, import_types5.Err)(new Error(`Linear GraphQL response was not valid JSON: ${errorMessage(err)}`));
+    }
+  }
+};
+function envelopeError(envelope) {
+  if (!envelope.errors || envelope.errors.length === 0) return void 0;
+  const message = envelope.errors.map((e) => e.message ?? "unknown error").join("; ");
+  return new Error(`Linear GraphQL error: ${message}`);
+}
 var LinearGraphQLStub = class {
   async query(query, _variables) {
     console.log("Linear GraphQL query (stub):", query);
@@ -2545,7 +2639,7 @@ var LinearGraphQLStub = class {
 };
 
 // src/workspace/manager.ts
-var fs9 = __toESM(require("fs/promises"));
+var fs8 = __toESM(require("fs/promises"));
 var path8 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 var import_node_util2 = require("util");
@@ -2585,7 +2679,7 @@ var WorkspaceManager = class _WorkspaceManager {
   async getRepoRoot() {
     if (this.repoRoot) return this.repoRoot;
     const root = path8.resolve(this.config.root);
-    await fs9.mkdir(root, { recursive: true });
+    await fs8.mkdir(root, { recursive: true });
     const stdout = await this.git(["rev-parse", "--show-toplevel"], root);
     this.repoRoot = stdout.trim();
     return this.repoRoot;
@@ -2598,21 +2692,21 @@ var WorkspaceManager = class _WorkspaceManager {
     try {
       const workspacePath = path8.resolve(this.resolvePath(identifier));
       try {
-        await fs9.access(path8.join(workspacePath, ".git"));
+        await fs8.access(path8.join(workspacePath, ".git"));
         const repoRoot2 = await this.getRepoRoot();
         try {
           await this.git(["worktree", "remove", "--force", workspacePath], repoRoot2);
         } catch {
-          await fs9.rm(workspacePath, { recursive: true, force: true });
+          await fs8.rm(workspacePath, { recursive: true, force: true });
         }
       } catch {
         try {
-          await fs9.access(workspacePath);
+          await fs8.access(workspacePath);
           const repoRoot2 = await this.getRepoRoot();
           try {
             await this.git(["worktree", "remove", "--force", workspacePath], repoRoot2);
           } catch {
-            await fs9.rm(workspacePath, { recursive: true, force: true });
+            await fs8.rm(workspacePath, { recursive: true, force: true });
           }
         } catch {
         }
@@ -2665,13 +2759,13 @@ var WorkspaceManager = class _WorkspaceManager {
       }
       const src = path8.join(repoRoot, rel);
       try {
-        await fs9.access(src);
+        await fs8.access(src);
       } catch {
         continue;
       }
       const dest = path8.join(workspacePath, rel);
       try {
-        await fs9.cp(src, dest, { recursive: true, force: true });
+        await fs8.cp(src, dest, { recursive: true, force: true });
       } catch {
       }
     }
@@ -2747,7 +2841,7 @@ var WorkspaceManager = class _WorkspaceManager {
   async exists(identifier) {
     try {
       const workspacePath = this.resolvePath(identifier);
-      await fs9.access(workspacePath);
+      await fs8.access(workspacePath);
       return true;
     } catch {
       return false;
@@ -2762,7 +2856,7 @@ var WorkspaceManager = class _WorkspaceManager {
     try {
       const workspacePath = path8.resolve(this.resolvePath(identifier));
       try {
-        await fs9.access(path8.join(workspacePath, ".git"));
+        await fs8.access(path8.join(workspacePath, ".git"));
       } catch {
         return null;
       }
@@ -2873,7 +2967,7 @@ var WorkspaceManager = class _WorkspaceManager {
         const repoRoot = await this.getRepoRoot();
         await this.git(["worktree", "remove", "--force", workspacePath], repoRoot);
       } catch {
-        await fs9.rm(workspacePath, { recursive: true, force: true });
+        await fs8.rm(workspacePath, { recursive: true, force: true });
       }
       return (0, import_types6.Ok)(void 0);
     } catch (error) {
@@ -3014,8 +3108,8 @@ var PromptRenderer = class {
 // src/orchestrator.ts
 var import_node_events = require("events");
 var path21 = __toESM(require("path"));
-var import_node_crypto16 = require("crypto");
-var import_core14 = require("@harness-engineering/core");
+var import_node_crypto15 = require("crypto");
+var import_core15 = require("@harness-engineering/core");
 
 // src/core/stall-detector.ts
 function detectStalledIssues(running, nowMs, stallTimeoutMs) {
@@ -3591,7 +3685,7 @@ var CompletionHandler = class {
 };
 
 // src/orchestrator.ts
-var import_core15 = require("@harness-engineering/core");
+var import_core16 = require("@harness-engineering/core");
 
 // src/tracker/adapters/github-issues-issue-tracker.ts
 var import_types9 = require("@harness-engineering/types");
@@ -4724,18 +4818,18 @@ var AnthropicBackend = class {
         usage
       };
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Anthropic request failed";
+      const errorMessage2 = err instanceof Error ? err.message : "Anthropic request failed";
       yield {
         type: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        content: errorMessage,
+        content: errorMessage2,
         sessionId: session.sessionId
       };
       return {
         success: false,
         sessionId: session.sessionId,
         usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        error: errorMessage
+        error: errorMessage2
       };
     }
   }
@@ -4826,18 +4920,18 @@ var OpenAIBackend = class {
         }
       }
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "OpenAI request failed";
+      const errorMessage2 = err instanceof Error ? err.message : "OpenAI request failed";
       yield {
         type: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        content: errorMessage,
+        content: errorMessage2,
         sessionId: session.sessionId
       };
       return {
         success: false,
         sessionId: session.sessionId,
         usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        error: errorMessage
+        error: errorMessage2
       };
     }
     const usage = {
@@ -4948,11 +5042,11 @@ var GeminiBackend = class {
         }
       }
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Gemini request failed";
+      const errorMessage2 = err instanceof Error ? err.message : "Gemini request failed";
       yield {
         type: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        content: errorMessage,
+        content: errorMessage2,
         sessionId: session.sessionId
       };
       return {
@@ -4965,7 +5059,7 @@ var GeminiBackend = class {
           cacheCreationTokens,
           cacheReadTokens
         },
-        error: errorMessage
+        error: errorMessage2
       };
     }
     const usage = {
@@ -5091,18 +5185,18 @@ var LocalBackend = class {
         }
       }
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Local backend request failed";
+      const errorMessage2 = err instanceof Error ? err.message : "Local backend request failed";
       yield {
         type: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        content: errorMessage,
+        content: errorMessage2,
         sessionId: session.sessionId
       };
       return {
         success: false,
         sessionId: session.sessionId,
         usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        error: errorMessage
+        error: errorMessage2
       };
     }
     const usage = { inputTokens, outputTokens, totalTokens };
@@ -5438,30 +5532,8 @@ var SshBackend = class {
   config;
   spawnImpl;
   constructor(config) {
-    if (!config.host || typeof config.host !== "string") {
-      throw new Error("SshBackend: `host` is required");
-    }
-    if (FORBIDDEN_HOST_CHARS.test(config.host) || config.host.startsWith("-")) {
-      throw new Error(
-        `SshBackend: invalid host '${config.host}' (contains shell metacharacters or starts with '-')`
-      );
-    }
-    if (!config.remoteCommand || typeof config.remoteCommand !== "string") {
-      throw new Error("SshBackend: `remoteCommand` is required");
-    }
-    if (config.user !== void 0 && /[\s;&|`$]/.test(config.user)) {
-      throw new Error(`SshBackend: invalid user '${config.user}'`);
-    }
-    this.config = {
-      host: config.host,
-      remoteCommand: config.remoteCommand,
-      sshBinary: config.sshBinary ?? "ssh",
-      sshOptions: config.sshOptions ?? [],
-      timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
-      ...config.user !== void 0 ? { user: config.user } : {},
-      ...config.port !== void 0 ? { port: config.port } : {},
-      ...config.identityFile !== void 0 ? { identityFile: config.identityFile } : {}
-    };
+    validateSshConfig(config);
+    this.config = normalizeSshConfig(config);
     this.spawnImpl = config.spawnImpl ?? import_node_child_process5.spawn;
   }
   /**
@@ -5613,6 +5685,34 @@ var SshBackend = class {
     });
   }
 };
+function validateSshConfig(config) {
+  if (!config.host || typeof config.host !== "string") {
+    throw new Error("SshBackend: `host` is required");
+  }
+  if (FORBIDDEN_HOST_CHARS.test(config.host) || config.host.startsWith("-")) {
+    throw new Error(
+      `SshBackend: invalid host '${config.host}' (contains shell metacharacters or starts with '-')`
+    );
+  }
+  if (!config.remoteCommand || typeof config.remoteCommand !== "string") {
+    throw new Error("SshBackend: `remoteCommand` is required");
+  }
+  if (config.user !== void 0 && /[\s;&|`$]/.test(config.user)) {
+    throw new Error(`SshBackend: invalid user '${config.user}'`);
+  }
+}
+function normalizeSshConfig(config) {
+  return {
+    host: config.host,
+    remoteCommand: config.remoteCommand,
+    sshBinary: config.sshBinary ?? "ssh",
+    sshOptions: config.sshOptions ?? [],
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+    ...config.user !== void 0 ? { user: config.user } : {},
+    ...config.port !== void 0 ? { port: config.port } : {},
+    ...config.identityFile !== void 0 ? { identityFile: config.identityFile } : {}
+  };
+}
 function errResult(sessionId, message) {
   return {
     success: false,
@@ -5719,23 +5819,8 @@ var OciServerlessBackend = class extends ServerlessBackend {
   envSource;
   constructor(config) {
     super();
-    if (!config.image || typeof config.image !== "string") {
-      throw new Error("OciServerlessBackend: `image` is required");
-    }
-    if (FORBIDDEN_IMAGE_CHARS.test(config.image) || config.image.startsWith("-")) {
-      throw new Error(
-        `OciServerlessBackend: invalid image '${config.image}' (contains shell metacharacters or starts with '-')`
-      );
-    }
-    this.config = {
-      image: config.image,
-      pullPolicy: config.pullPolicy ?? "if-not-present",
-      runtime: config.runtime ?? "docker",
-      envPassthrough: config.envPassthrough ?? [],
-      timeoutMs: config.timeoutMs ?? DEFAULT_OCI_TIMEOUT_MS,
-      extraArgs: sanitizeExtraArgs(config.extraArgs),
-      ...config.registry !== void 0 ? { registry: config.registry } : {}
-    };
+    validateOciImage(config.image);
+    this.config = resolveOciConfig(config);
     this.spawnImpl = config.spawnImpl ?? import_node_child_process6.spawn;
     this.envSource = config.envSource ?? process.env;
   }
@@ -5898,6 +5983,27 @@ var OciServerlessBackend = class extends ServerlessBackend {
     });
   }
 };
+function validateOciImage(image) {
+  if (!image || typeof image !== "string") {
+    throw new Error("OciServerlessBackend: `image` is required");
+  }
+  if (FORBIDDEN_IMAGE_CHARS.test(image) || image.startsWith("-")) {
+    throw new Error(
+      `OciServerlessBackend: invalid image '${image}' (contains shell metacharacters or starts with '-')`
+    );
+  }
+}
+function resolveOciConfig(config) {
+  return {
+    image: config.image,
+    pullPolicy: config.pullPolicy ?? "if-not-present",
+    runtime: config.runtime ?? "docker",
+    envPassthrough: config.envPassthrough ?? [],
+    timeoutMs: config.timeoutMs ?? DEFAULT_OCI_TIMEOUT_MS,
+    extraArgs: sanitizeExtraArgs(config.extraArgs),
+    ...config.registry !== void 0 ? { registry: config.registry } : {}
+  };
+}
 function sanitizeExtraArgs(extraArgs) {
   if (!extraArgs) return [];
   return extraArgs.filter((arg) => !BLOCKED_DOCKER_FLAGS.some((flag) => arg.startsWith(flag)));
@@ -5969,78 +6075,96 @@ function makeGetModel(model) {
   if (Array.isArray(model) && model.length > 0) return () => model[0] ?? null;
   return () => null;
 }
+function createClaudeBackend(def, options) {
+  return new ClaudeBackend(def.command ?? "claude", {
+    ...options.cacheMetrics ? { cacheMetrics: options.cacheMetrics } : {}
+  });
+}
+function createAnthropicBackend(def) {
+  return new AnthropicBackend({
+    model: def.model,
+    ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+  });
+}
+function createOpenAIBackend(def) {
+  return new OpenAIBackend({
+    model: def.model,
+    ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+  });
+}
+function createGeminiBackend(def) {
+  return new GeminiBackend({
+    model: def.model,
+    ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
+  });
+}
+function createLocalBackend(def) {
+  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 } : {}
+  });
+}
+function createPiBackend(def) {
+  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 } : {}
+  });
+}
+function createSshBackend(def) {
+  return new SshBackend({
+    host: def.host,
+    remoteCommand: def.remoteCommand,
+    ...def.user !== void 0 ? { user: def.user } : {},
+    ...def.port !== void 0 ? { port: def.port } : {},
+    ...def.identityFile !== void 0 ? { identityFile: def.identityFile } : {},
+    ...def.sshOptions !== void 0 ? { sshOptions: def.sshOptions } : {},
+    ...def.sshBinary !== void 0 ? { sshBinary: def.sshBinary } : {}
+  });
+}
+function createServerlessBackend(def) {
+  switch (def.adapter) {
+    case "oci":
+      return new OciServerlessBackend({
+        image: def.image,
+        ...def.registry !== void 0 ? { registry: def.registry } : {},
+        ...def.pullPolicy !== void 0 ? { pullPolicy: def.pullPolicy } : {},
+        ...def.envPassthrough !== void 0 ? { envPassthrough: def.envPassthrough } : {},
+        ...def.runtime !== void 0 ? { runtime: def.runtime } : {}
+      });
+    default: {
+      const exhaustive = def.adapter;
+      throw new Error(`createBackend: unknown serverless adapter ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
 function createBackend(def, options = {}) {
   switch (def.type) {
     case "mock":
       return new MockBackend();
     case "claude":
-      return new ClaudeBackend(def.command ?? "claude", {
-        ...options.cacheMetrics ? { cacheMetrics: options.cacheMetrics } : {}
-      });
+      return createClaudeBackend(def, options);
     case "anthropic":
-      return new AnthropicBackend({
-        model: def.model,
-        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
-      });
+      return createAnthropicBackend(def);
     case "openai":
-      return new OpenAIBackend({
-        model: def.model,
-        ...def.apiKey !== void 0 ? { apiKey: def.apiKey } : {}
-      });
+      return createOpenAIBackend(def);
     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 } : {}
-      });
-    }
-    case "ssh": {
-      return new SshBackend({
-        host: def.host,
-        remoteCommand: def.remoteCommand,
-        ...def.user !== void 0 ? { user: def.user } : {},
-        ...def.port !== void 0 ? { port: def.port } : {},
-        ...def.identityFile !== void 0 ? { identityFile: def.identityFile } : {},
-        ...def.sshOptions !== void 0 ? { sshOptions: def.sshOptions } : {},
-        ...def.sshBinary !== void 0 ? { sshBinary: def.sshBinary } : {}
-      });
-    }
-    case "serverless": {
-      switch (def.adapter) {
-        case "oci":
-          return new OciServerlessBackend({
-            image: def.image,
-            ...def.registry !== void 0 ? { registry: def.registry } : {},
-            ...def.pullPolicy !== void 0 ? { pullPolicy: def.pullPolicy } : {},
-            ...def.envPassthrough !== void 0 ? { envPassthrough: def.envPassthrough } : {},
-            ...def.runtime !== void 0 ? { runtime: def.runtime } : {}
-          });
-        default: {
-          const exhaustive = def.adapter;
-          throw new Error(
-            `createBackend: unknown serverless adapter ${JSON.stringify(exhaustive)}`
-          );
-        }
-      }
-    }
+      return createGeminiBackend(def);
+    case "local":
+      return createLocalBackend(def);
+    case "pi":
+      return createPiBackend(def);
+    case "ssh":
+      return createSshBackend(def);
+    case "serverless":
+      return createServerlessBackend(def);
     default: {
       const exhaustive = def;
       throw new Error(`createBackend: unknown backend type ${JSON.stringify(exhaustive)}`);
@@ -6511,6 +6635,96 @@ var OrchestratorBackendFactory = class {
   }
 };
 
+// src/agent/backend-resolver.ts
+function makeBackendResolver(backends) {
+  return (backendName) => {
+    const def = backends?.[backendName];
+    return def ? createBackend(def) : null;
+  };
+}
+
+// src/maintenance/agent-dispatcher.ts
+function syntheticIssue(branch, skill) {
+  return {
+    id: `maintenance:${branch}`,
+    identifier: branch,
+    title: `Maintenance: ${skill}`,
+    description: null,
+    priority: null,
+    state: "in_progress",
+    branchName: branch,
+    url: null,
+    labels: ["maintenance"],
+    blockedBy: [],
+    spec: null,
+    plans: [],
+    createdAt: null,
+    updatedAt: null,
+    externalId: null
+  };
+}
+function buildPrompt(skill, promptContext) {
+  const instruction = `Run the \`${skill}\` skill to detect and fix issues in this repository. Apply the fixes and commit each logical change. If there is nothing to fix, make no commits.`;
+  return promptContext ? `${promptContext}
+
+${instruction}` : instruction;
+}
+function headOf(git2, cwd) {
+  try {
+    return git2(["rev-parse", "HEAD"], cwd) || null;
+  } catch {
+    return null;
+  }
+}
+function createAgentDispatcher(deps) {
+  const maxTurns = deps.maxTurns ?? 10;
+  const dispatch = async (skill, branch, backendName, cwd, options) => {
+    const backend = deps.resolveBackend(backendName);
+    if (!backend) {
+      deps.logger.warn(`Maintenance agent dispatch skipped: unknown backend "${backendName}"`, {
+        skill,
+        branch
+      });
+      return { producedCommits: false, fixed: 0 };
+    }
+    const before = headOf(deps.git, cwd);
+    const runner = new AgentRunner(backend, { maxTurns });
+    const session = runner.runSession(
+      syntheticIssue(branch, skill),
+      cwd,
+      buildPrompt(skill, options?.promptContext)
+    );
+    let step = await session.next();
+    while (!step.done) step = await session.next();
+    const after = headOf(deps.git, cwd);
+    let fixed = 0;
+    if (after && after !== before) {
+      if (before) {
+        try {
+          fixed = parseInt(deps.git(["rev-list", "--count", `${before}..${after}`], cwd), 10) || 0;
+        } catch {
+          fixed = 1;
+        }
+      } else {
+        fixed = 1;
+      }
+    }
+    const producedCommits = fixed > 0;
+    deps.logger.info("Maintenance agent dispatch complete", {
+      skill,
+      branch,
+      backendName,
+      producedCommits,
+      fixed
+    });
+    return { producedCommits, fixed };
+  };
+  return { dispatch };
+}
+
+// src/orchestrator.ts
+var import_node_child_process13 = require("child_process");
+
 // src/agent/intelligence-factory.ts
 var import_intelligence3 = require("@harness-engineering/intelligence");
 var import_graph = require("@harness-engineering/graph");
@@ -7012,7 +7226,7 @@ function handleV1InteractionsResolveRoute(req, res, queue) {
 
 // src/server/routes/plans.ts
 var import_zod5 = require("zod");
-var fs10 = __toESM(require("fs/promises"));
+var fs9 = __toESM(require("fs/promises"));
 var path11 = __toESM(require("path"));
 var PlanWriteSchema = import_zod5.z.object({
   filename: import_zod5.z.string().min(1),
@@ -7041,9 +7255,9 @@ function handlePlansRoute(req, res, plansDir) {
           );
           return;
         }
-        await fs10.mkdir(plansDir, { recursive: true });
+        await fs9.mkdir(plansDir, { recursive: true });
         const filePath = path11.join(plansDir, basename3);
-        await fs10.writeFile(filePath, parsed.content, "utf-8");
+        await fs9.writeFile(filePath, parsed.content, "utf-8");
         res.writeHead(201, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true, filename: basename3 }));
       } catch {
@@ -7418,7 +7632,6 @@ function handleAnalyzeRoute(req, res, pipeline) {
 }
 
 // src/server/routes/roadmap-actions.ts
-var fs11 = __toESM(require("fs/promises"));
 var path12 = __toESM(require("path"));
 var import_core7 = require("@harness-engineering/core");
 var import_zod8 = require("zod");
@@ -7500,13 +7713,14 @@ function handleRoadmapActionsRoute(req, res, roadmapPath) {
         sendJSON2(res, 400, { error: "Title must not contain newlines or markdown headings" });
         return;
       }
-      const content = await fs11.readFile(roadmapPath, "utf-8");
-      const roadmapResult = (0, import_core7.parseRoadmap)(content);
-      if (!roadmapResult.ok) {
+      const store = (0, import_core7.resolveRoadmapStoreForFile)({ roadmapPath });
+      const loaded = await store.load();
+      if (!loaded.ok) {
         sendJSON2(res, 500, { error: "Failed to parse roadmap file" });
         return;
       }
-      const roadmap = roadmapResult.value;
+      const roadmap = loaded.value;
+      const before = structuredClone(roadmap);
       let backlog = roadmap.milestones.find((m) => m.isBacklog);
       if (!backlog) {
         backlog = { name: "Backlog", isBacklog: true, features: [] };
@@ -7529,10 +7743,11 @@ function handleRoadmapActionsRoute(req, res, roadmapPath) {
         updatedAt: null
       });
       roadmap.frontmatter.lastManualEdit = (/* @__PURE__ */ new Date()).toISOString();
-      const tmpPath = roadmapPath + ".tmp";
-      const serialized = (0, import_core7.serializeRoadmap)(roadmap);
-      await fs11.writeFile(tmpPath, serialized, "utf-8");
-      await fs11.rename(tmpPath, roadmapPath);
+      const persisted = await (0, import_core7.applyRoadmapDiff)(store, before, roadmap);
+      if (!persisted.ok) {
+        sendJSON2(res, 500, { error: persisted.error.message });
+        return;
+      }
       sendJSON2(res, 201, { ok: true, featureName: parsed.title });
     } catch (err) {
       const msg = err instanceof Error ? err.message : "Failed to append to roadmap";
@@ -7798,7 +8013,6 @@ function handleV1JobsMaintenanceRoute(req, res, deps) {
 }
 
 // src/server/routes/v1/events-sse.ts
-var import_node_crypto8 = require("crypto");
 var SSE_TOPICS = [
   "state_change",
   "agent_event",
@@ -7814,8 +8028,55 @@ var SSE_TOPICS = [
   "webhook.subscription.deleted"
 ];
 var HEARTBEAT_MS = 15e3;
-function newEventId() {
-  return `evt_${(0, import_node_crypto8.randomBytes)(8).toString("hex")}`;
+var DEFAULT_REPLAY_BUFFER = 1024;
+var SseEventLog = class {
+  seq = 0;
+  buffer = [];
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(bus, cap = DEFAULT_REPLAY_BUFFER) {
+    this.cap = cap;
+    for (const topic of SSE_TOPICS) {
+      bus.on(topic, (data) => this.record(topic, data));
+    }
+  }
+  cap;
+  record(topic, data) {
+    const event = { id: ++this.seq, topic, data };
+    this.buffer.push(event);
+    if (this.buffer.length > this.cap) this.buffer.shift();
+    for (const fn of this.subscribers) fn(event);
+  }
+  /** Highest assigned id (0 when nothing has been recorded yet). */
+  currentSeq() {
+    return this.seq;
+  }
+  /** Buffered events strictly newer than `lastId`, oldest-first. */
+  replayFrom(lastId) {
+    return this.buffer.filter((e) => e.id > lastId);
+  }
+  /** Register a live listener; returns an unsubscribe function. */
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => {
+      this.subscribers.delete(fn);
+    };
+  }
+};
+var logsByBus = /* @__PURE__ */ new WeakMap();
+function getSseEventLog(bus) {
+  let log = logsByBus.get(bus);
+  if (!log) {
+    log = new SseEventLog(bus);
+    logsByBus.set(bus, log);
+  }
+  return log;
+}
+function parseLastEventId(req) {
+  const raw = req.headers["last-event-id"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (value === void 0) return null;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= 0 ? n : null;
 }
 function handleV1EventsSseRoute(req, res, bus) {
   if (req.method !== "GET" || req.url !== "/api/v1/events") return false;
@@ -7827,22 +8088,28 @@ function handleV1EventsSseRoute(req, res, bus) {
   res.write(`: harness gateway SSE \u2014 connected at ${(/* @__PURE__ */ new Date()).toISOString()}
 
 `);
-  const listeners = [];
-  for (const topic of SSE_TOPICS) {
-    const fn = (data) => {
-      try {
-        const frame = `event: ${topic}
-data: ${JSON.stringify(data)}
-id: ${newEventId()}
+  const log = getSseEventLog(bus);
+  const send = (e) => {
+    try {
+      res.write(`event: ${e.topic}
+data: ${JSON.stringify(e.data)}
+id: ${e.id}
 
-`;
-        res.write(frame);
-      } catch {
-      }
-    };
-    bus.on(topic, fn);
-    listeners.push({ topic, fn });
+`);
+    } catch {
+    }
+  };
+  const lastId = parseLastEventId(req);
+  let replayedThrough = lastId ?? log.currentSeq();
+  if (lastId !== null) {
+    for (const e of log.replayFrom(lastId)) {
+      send(e);
+      replayedThrough = e.id;
+    }
   }
+  const unsubscribe = log.subscribe((e) => {
+    if (e.id > replayedThrough) send(e);
+  });
   const heartbeat = setInterval(() => {
     try {
       res.write(": heartbeat\n\n");
@@ -7852,7 +8119,7 @@ id: ${newEventId()}
   heartbeat.unref();
   const cleanup = () => {
     clearInterval(heartbeat);
-    for (const { topic, fn } of listeners) bus.removeListener(topic, fn);
+    unsubscribe();
   };
   res.on("close", cleanup);
   res.on("finish", cleanup);
@@ -8161,7 +8428,7 @@ async function runGate(projectPath, proposalId) {
 }
 
 // src/proposals/promote.ts
-var fs12 = __toESM(require("fs"));
+var fs10 = __toESM(require("fs"));
 var path13 = __toESM(require("path"));
 var import_yaml4 = require("yaml");
 var import_core9 = require("@harness-engineering/core");
@@ -8183,7 +8450,7 @@ function skillDir(projectPath, name) {
 }
 function readIfExists(p) {
   try {
-    return fs12.readFileSync(p, "utf-8");
+    return fs10.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -8229,15 +8496,15 @@ function assertGateReady(proposal) {
 }
 async function promoteNewSkill(projectPath, proposal) {
   const target = skillDir(projectPath, proposal.content.name);
-  if (fs12.existsSync(target)) {
+  if (fs10.existsSync(target)) {
     throw new PromotionError(
       `a catalog skill already exists at ${target}; use a refinement proposal to update it`
     );
   }
-  fs12.mkdirSync(target, { recursive: true });
+  fs10.mkdirSync(target, { recursive: true });
   const yamlOut = injectProvenanceIntoYaml(proposal.content.skillYaml ?? "", proposal.id);
-  fs12.writeFileSync(path13.join(target, "skill.yaml"), yamlOut);
-  fs12.writeFileSync(path13.join(target, "SKILL.md"), proposal.content.skillMd ?? "");
+  fs10.writeFileSync(path13.join(target, "skill.yaml"), yamlOut);
+  fs10.writeFileSync(path13.join(target, "SKILL.md"), proposal.content.skillMd ?? "");
   return { skillPath: target };
 }
 async function promoteRefinement(projectPath, proposal) {
@@ -8245,7 +8512,7 @@ async function promoteRefinement(projectPath, proposal) {
     throw new PromotionError("refinement proposal is missing targetSkill");
   }
   const target = skillDir(projectPath, proposal.targetSkill);
-  if (!fs12.existsSync(target)) {
+  if (!fs10.existsSync(target)) {
     throw new PromotionError(
       `target skill ${proposal.targetSkill} does not exist at ${target}; cannot refine`
     );
@@ -8258,7 +8525,7 @@ async function promoteRefinement(projectPath, proposal) {
       "no metadata changes detected; check that the reviewer applied the proposed diff before approving"
     );
   }
-  fs12.writeFileSync(yamlPath, after);
+  fs10.writeFileSync(yamlPath, after);
   return { skillPath: target };
 }
 async function promote(projectPath, proposalId, decidedBy) {
@@ -8696,7 +8963,7 @@ function handleV1RoutingRoute(req, res, deps) {
 }
 
 // src/server/routes/sessions.ts
-var fs13 = __toESM(require("fs/promises"));
+var fs11 = __toESM(require("fs/promises"));
 var path14 = __toESM(require("path"));
 var import_zod15 = require("zod");
 var SessionCreateSchema = import_zod15.z.object({
@@ -8717,12 +8984,12 @@ function extractSessionId(url) {
 }
 async function handleList2(res, sessionsDir) {
   try {
-    const entries = await fs13.readdir(sessionsDir, { withFileTypes: true });
+    const entries = await fs11.readdir(sessionsDir, { withFileTypes: true });
     const sessions = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       try {
-        const content = await fs13.readFile(
+        const content = await fs11.readFile(
           path14.join(sessionsDir, entry.name, "session.json"),
           "utf-8"
         );
@@ -8748,7 +9015,7 @@ async function handleGet2(res, id, sessionsDir) {
     return;
   }
   try {
-    const content = await fs13.readFile(path14.join(sessionsDir, id, "session.json"), "utf-8");
+    const content = await fs11.readFile(path14.join(sessionsDir, id, "session.json"), "utf-8");
     jsonResponse(res, 200, JSON.parse(content));
   } catch (err) {
     if (err.code === "ENOENT") {
@@ -8772,8 +9039,8 @@ async function handleCreate(req, res, sessionsDir) {
       return;
     }
     const sessionDir = path14.join(sessionsDir, session.sessionId);
-    await fs13.mkdir(sessionDir, { recursive: true });
-    await fs13.writeFile(path14.join(sessionDir, "session.json"), JSON.stringify(session, null, 2));
+    await fs11.mkdir(sessionDir, { recursive: true });
+    await fs11.writeFile(path14.join(sessionDir, "session.json"), JSON.stringify(session, null, 2));
     jsonResponse(res, 200, { ok: true });
   } catch {
     jsonResponse(res, 500, { error: "Failed to save session" });
@@ -8789,8 +9056,8 @@ async function handleUpdate(req, res, url, sessionsDir) {
     const body = await readBody(req);
     const updates = import_zod15.z.record(import_zod15.z.unknown()).parse(JSON.parse(body));
     const sessionFilePath = path14.join(sessionsDir, id, "session.json");
-    const current = JSON.parse(await fs13.readFile(sessionFilePath, "utf-8"));
-    await fs13.writeFile(sessionFilePath, JSON.stringify({ ...current, ...updates }, null, 2));
+    const current = JSON.parse(await fs11.readFile(sessionFilePath, "utf-8"));
+    await fs11.writeFile(sessionFilePath, JSON.stringify({ ...current, ...updates }, null, 2));
     jsonResponse(res, 200, { ok: true });
   } catch {
     jsonResponse(res, 500, { error: "Failed to update session" });
@@ -8803,7 +9070,7 @@ async function handleDelete(res, url, sessionsDir) {
       jsonResponse(res, 400, { error: "Missing or invalid sessionId" });
       return;
     }
-    await fs13.rm(path14.join(sessionsDir, id), { recursive: true, force: true });
+    await fs11.rm(path14.join(sessionsDir, id), { recursive: true, force: true });
     jsonResponse(res, 200, { ok: true });
   } catch {
     jsonResponse(res, 500, { error: "Failed to delete session" });
@@ -9047,7 +9314,7 @@ function handleLocalModelsRoute(req, res, getStatuses) {
 }
 
 // src/server/static.ts
-var fs14 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 var path15 = __toESM(require("path"));
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -9077,11 +9344,11 @@ function handleStaticFile(req, res, dashboardDir) {
   if (!resolved.startsWith(path15.resolve(dashboardDir))) {
     return serveFile(path15.join(dashboardDir, "index.html"), res);
   }
-  if (fs14.existsSync(resolved) && fs14.statSync(resolved).isFile()) {
+  if (fs12.existsSync(resolved) && fs12.statSync(resolved).isFile()) {
     return serveFile(resolved, res);
   }
   const indexPath = path15.join(dashboardDir, "index.html");
-  if (fs14.existsSync(indexPath)) {
+  if (fs12.existsSync(indexPath)) {
     return serveFile(indexPath, res);
   }
   return false;
@@ -9090,7 +9357,7 @@ function serveFile(filePath, res) {
   const ext = path15.extname(filePath).toLowerCase();
   const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
   try {
-    const content = fs14.readFileSync(filePath);
+    const content = fs12.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
     res.end(content);
     return true;
@@ -9100,7 +9367,7 @@ function serveFile(filePath, res) {
 }
 
 // src/server/plan-watcher.ts
-var fs15 = __toESM(require("fs"));
+var fs13 = __toESM(require("fs"));
 var path16 = __toESM(require("path"));
 var PlanWatcher = class {
   plansDir;
@@ -9115,11 +9382,11 @@ var PlanWatcher = class {
    * Creates the directory if it does not exist.
    */
   start() {
-    fs15.mkdirSync(this.plansDir, { recursive: true });
-    this.watcher = fs15.watch(this.plansDir, (eventType, filename) => {
+    fs13.mkdirSync(this.plansDir, { recursive: true });
+    this.watcher = fs13.watch(this.plansDir, (eventType, filename) => {
       if (eventType === "rename" && filename && filename.endsWith(".md")) {
         const filePath = path16.join(this.plansDir, filename);
-        if (fs15.existsSync(filePath)) {
+        if (fs13.existsSync(filePath)) {
           void this.handleNewPlan(filename);
         }
       }
@@ -9150,7 +9417,7 @@ var PlanWatcher = class {
 };
 
 // src/auth/tokens.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
 var import_bcryptjs = __toESM(require("bcryptjs"));
@@ -9158,10 +9425,10 @@ var import_types26 = require("@harness-engineering/types");
 var BCRYPT_ROUNDS = 12;
 var LEGACY_ENV_ID = "tok_legacy_env";
 function genId() {
-  return `tok_${(0, import_node_crypto9.randomBytes)(8).toString("hex")}`;
+  return `tok_${(0, import_node_crypto8.randomBytes)(8).toString("hex")}`;
 }
 function genSecret() {
-  return (0, import_node_crypto9.randomBytes)(24).toString("base64url");
+  return (0, import_node_crypto8.randomBytes)(24).toString("base64url");
 }
 function parseToken(raw) {
   const dot = raw.indexOf(".");
@@ -9192,7 +9459,7 @@ var TokenStore = class {
   }
   async persist(records) {
     await (0, import_promises.mkdir)((0, import_node_path.dirname)(this.path), { recursive: true });
-    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}-${(0, import_node_crypto9.randomBytes)(4).toString("hex")}`;
+    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}-${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`;
     await (0, import_promises.writeFile)(tmp, JSON.stringify(records, null, 2), "utf8");
     await (0, import_promises.rename)(tmp, this.path);
     this.cache = records;
@@ -9261,7 +9528,7 @@ var TokenStore = class {
     const a = Buffer.from(presented);
     const b = Buffer.from(envValue);
     if (a.length !== b.length) return null;
-    if (!(0, import_node_crypto9.timingSafeEqual)(a, b)) return null;
+    if (!(0, import_node_crypto8.timingSafeEqual)(a, b)) return null;
     return {
       id: LEGACY_ENV_ID,
       name: "legacy-env",
@@ -9444,26 +9711,41 @@ function hasScope(held, required) {
   if (held.includes("admin")) return true;
   return held.includes(required);
 }
-function requiredScopeForRoute(method, path24) {
-  const bridgeScope = requiredBridgeScope(method, path24);
-  if (bridgeScope) return bridgeScope;
+function exactScopeForRoute(method, path24) {
   if (path24 === "/api/v1/auth/token" && method === "POST") return "admin";
   if (path24 === "/api/v1/auth/tokens" && method === "GET") return "admin";
   if (/^\/api\/v1\/auth\/tokens\/[^/]+$/.test(path24) && method === "DELETE") return "admin";
   if ((path24 === "/api/state" || path24 === "/api/v1/state") && method === "GET") return "read-status";
-  if (path24.startsWith("/api/interactions")) return "resolve-interaction";
-  if (path24.startsWith("/api/plans")) return "read-status";
-  if (path24.startsWith("/api/analyze") || path24.startsWith("/api/analyses")) return "read-status";
-  if (path24.startsWith("/api/roadmap-actions")) return "modify-roadmap";
-  if (path24.startsWith("/api/dispatch-actions")) return "trigger-job";
-  if (path24.startsWith("/api/local-model") || path24.startsWith("/api/local-models"))
-    return "read-status";
-  if (path24.startsWith("/api/maintenance")) return "trigger-job";
-  if (path24.startsWith("/api/streams")) return "read-status";
-  if (path24.startsWith("/api/sessions")) return "read-status";
-  if (path24 === "/api/chat" || path24.startsWith("/api/chat-proxy")) return "trigger-job";
   return null;
 }
+var PREFIX_SCOPES = [
+  ["/api/interactions", "resolve-interaction"],
+  ["/api/plans", "read-status"],
+  ["/api/analyze", "read-status"],
+  ["/api/analyses", "read-status"],
+  ["/api/roadmap-actions", "modify-roadmap"],
+  ["/api/dispatch-actions", "trigger-job"],
+  ["/api/local-model", "read-status"],
+  ["/api/local-models", "read-status"],
+  ["/api/maintenance", "trigger-job"],
+  ["/api/streams", "read-status"],
+  ["/api/sessions", "read-status"],
+  ["/api/chat-proxy", "trigger-job"]
+];
+function prefixScopeForPath(path24) {
+  if (path24 === "/api/chat") return "trigger-job";
+  for (const [prefix, scope] of PREFIX_SCOPES) {
+    if (path24.startsWith(prefix)) return scope;
+  }
+  return null;
+}
+function requiredScopeForRoute(method, path24) {
+  const bridgeScope = requiredBridgeScope(method, path24);
+  if (bridgeScope) return bridgeScope;
+  const exactScope = exactScopeForRoute(method, path24);
+  if (exactScope) return exactScope;
+  return prefixScopeForPath(path24);
+}
 
 // src/server/http.ts
 var RATE_LIMIT = Number(process.env["HARNESS_RATE_LIMIT"]) || 100;
@@ -9878,15 +10160,15 @@ var OrchestratorServer = class {
 };
 
 // src/gateway/webhooks/store.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var import_promises3 = require("fs/promises");
 var import_node_path3 = require("path");
 var import_types28 = require("@harness-engineering/types");
 
 // src/gateway/webhooks/signer.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto9 = require("crypto");
 function sign(secret, body) {
-  const hex = (0, import_node_crypto10.createHmac)("sha256", secret).update(body).digest("hex");
+  const hex = (0, import_node_crypto9.createHmac)("sha256", secret).update(body).digest("hex");
   return `sha256=${hex}`;
 }
 function eventMatches(pattern, type) {
@@ -9905,10 +10187,10 @@ function eventMatches(pattern, type) {
 
 // src/gateway/webhooks/store.ts
 function genId2() {
-  return `whk_${(0, import_node_crypto11.randomBytes)(8).toString("hex")}`;
+  return `whk_${(0, import_node_crypto10.randomBytes)(8).toString("hex")}`;
 }
 function genSecret2() {
-  return (0, import_node_crypto11.randomBytes)(32).toString("base64url");
+  return (0, import_node_crypto10.randomBytes)(32).toString("base64url");
 }
 var WebhookStore = class {
   constructor(path24) {
@@ -9933,7 +10215,7 @@ var WebhookStore = class {
     return this.cache;
   }
   async persist(records) {
-    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}-${(0, import_node_crypto11.randomBytes)(4).toString("hex")}`;
+    const tmp = `${this.path}.tmp-${process.pid}-${Date.now()}-${(0, import_node_crypto10.randomBytes)(4).toString("hex")}`;
     try {
       await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(this.path), { recursive: true });
       await (0, import_promises3.writeFile)(tmp, JSON.stringify(records, null, 2), { encoding: "utf8", mode: 384 });
@@ -9977,7 +10259,7 @@ var WebhookStore = class {
 };
 
 // src/gateway/webhooks/delivery.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto11 = require("crypto");
 
 // src/gateway/webhooks/queue.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
@@ -10187,7 +10469,7 @@ var WebhookDelivery = class {
   enqueue(sub, event) {
     const payload = JSON.stringify(event);
     this.queue.insert({
-      id: `dlv_${(0, import_node_crypto12.randomBytes)(8).toString("hex")}`,
+      id: `dlv_${(0, import_node_crypto11.randomBytes)(8).toString("hex")}`,
       subscriptionId: sub.id,
       eventType: event.type,
       payload
@@ -10295,7 +10577,7 @@ var WebhookDelivery = class {
 };
 
 // src/gateway/webhooks/events.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var WEBHOOK_TOPICS = [
   "interaction.created",
   "interaction.resolved",
@@ -10310,8 +10592,8 @@ var WEBHOOK_TOPICS = [
   "proposal.approved",
   "proposal.rejected"
 ];
-function newEventId2() {
-  return `evt_${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`;
+function newEventId() {
+  return `evt_${(0, import_node_crypto12.randomBytes)(8).toString("hex")}`;
 }
 function wireWebhookFanout({ bus, store, delivery }) {
   const handlers = [];
@@ -10322,7 +10604,7 @@ function wireWebhookFanout({ bus, store, delivery }) {
         const subs = await store.listForEvent(eventType);
         if (subs.length === 0) return;
         const event = {
-          id: newEventId2(),
+          id: newEventId(),
           type: eventType,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           data
@@ -10341,7 +10623,7 @@ function wireWebhookFanout({ bus, store, delivery }) {
 }
 
 // src/gateway/telemetry/fanout.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_core12 = require("@harness-engineering/core");
 var TOPICS = {
   MAINTENANCE_STARTED: "maintenance:started",
@@ -10364,14 +10646,14 @@ var SPAN_NAME = {
   [TOPICS.DISPATCH_DECISION]: "dispatch_decision",
   [TOPICS.SKILL_INVOCATION]: "skill_invocation"
 };
-function newEventId3() {
-  return `evt_${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`;
+function newEventId2() {
+  return `evt_${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`;
 }
 function newTraceId() {
-  return (0, import_node_crypto14.randomBytes)(16).toString("hex");
+  return (0, import_node_crypto13.randomBytes)(16).toString("hex");
 }
 function newSpanId() {
-  return (0, import_node_crypto14.randomBytes)(8).toString("hex");
+  return (0, import_node_crypto13.randomBytes)(8).toString("hex");
 }
 function nowNs() {
   return BigInt(Date.now()) * 1000000n;
@@ -10422,79 +10704,102 @@ function buildAttributes(payload, extras = {}) {
   }
   return attrs;
 }
+function extractIds(payload) {
+  const correlationId = typeof payload["correlationId"] === "string" ? payload["correlationId"] : void 0;
+  const taskId = typeof payload["taskId"] === "string" ? payload["taskId"] : void 0;
+  return { correlationId, taskId };
+}
+function resolveActiveRun(registry, correlationId, taskId) {
+  return registry.resolve({
+    ...correlationId !== void 0 ? { correlationId } : {},
+    ...taskId !== void 0 ? { taskId } : {}
+  });
+}
+function openMaintenanceSpan(registry, correlationId, taskId) {
+  const traceId = newTraceId();
+  const spanId = newSpanId();
+  const key = correlationId ?? taskId ?? `run_${spanId}`;
+  registry.open(key, { traceId, spanId });
+  return { traceId, spanId };
+}
+function closeMaintenanceSpan(registry, topic, correlationId, taskId) {
+  const existing = resolveActiveRun(registry, correlationId, taskId);
+  const traceId = existing?.traceId ?? newTraceId();
+  const spanId = existing?.spanId ?? newSpanId();
+  const statusCode = topic === TOPICS.MAINTENANCE_ERROR ? 2 : 1;
+  const key = correlationId ?? taskId ?? "";
+  if (key) registry.close(key);
+  return { traceId, spanId, statusCode };
+}
+function childSpan(registry, correlationId, taskId) {
+  const parent = resolveActiveRun(registry, correlationId, taskId);
+  const plan = {
+    traceId: parent?.traceId ?? newTraceId(),
+    spanId: newSpanId()
+  };
+  if (parent?.spanId !== void 0) plan.parentSpanId = parent.spanId;
+  return plan;
+}
+function planSpan(registry, topic, correlationId, taskId) {
+  if (topic === TOPICS.MAINTENANCE_STARTED) {
+    return openMaintenanceSpan(registry, correlationId, taskId);
+  }
+  if (topic === TOPICS.MAINTENANCE_COMPLETED || topic === TOPICS.MAINTENANCE_ERROR) {
+    return closeMaintenanceSpan(registry, topic, correlationId, taskId);
+  }
+  return childSpan(registry, correlationId, taskId);
+}
+function buildSpan(topic, plan, payload) {
+  const startNs = nowNs();
+  return {
+    traceId: plan.traceId,
+    spanId: plan.spanId,
+    ...plan.parentSpanId !== void 0 ? { parentSpanId: plan.parentSpanId } : {},
+    name: SPAN_NAME[topic],
+    kind: import_core12.SpanKind.INTERNAL,
+    startTimeNs: startNs,
+    endTimeNs: startNs,
+    attributes: buildAttributes(payload, { "harness.topic": topic }),
+    ...plan.statusCode !== void 0 ? { statusCode: plan.statusCode } : {}
+  };
+}
+function buildGatewayEvent(topic, payload, correlationId) {
+  return {
+    id: newEventId2(),
+    type: TELEMETRY_TYPE[topic],
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: payload,
+    ...correlationId !== void 0 ? { correlationId } : {}
+  };
+}
+async function enqueueToMatchingSubs(store, webhookDelivery, event) {
+  const subs = await store.listForEvent(event.type);
+  if (subs.length === 0) return;
+  const filtered = subs.filter((sub) => sub.events.some((p) => eventMatches(p, event.type)));
+  for (const sub of filtered) {
+    webhookDelivery.enqueue(sub, event);
+  }
+}
+function makeTelemetryHandler(ctx, topic) {
+  return (data) => {
+    const payload = data ?? {};
+    const { correlationId, taskId } = extractIds(payload);
+    const plan = planSpan(ctx.registry, topic, correlationId, taskId);
+    ctx.exporter.push(buildSpan(topic, plan, payload));
+    void enqueueToMatchingSubs(
+      ctx.store,
+      ctx.webhookDelivery,
+      buildGatewayEvent(topic, payload, correlationId)
+    );
+  };
+}
 function wireTelemetryFanout(params) {
   const { bus, exporter, webhookDelivery, store } = params;
   const registry = new ActiveRunRegistry();
   const handlers = [];
-  const enqueueToMatchingSubs = async (event) => {
-    const subs = await store.listForEvent(event.type);
-    if (subs.length === 0) return;
-    const filtered = subs.filter((sub) => sub.events.some((p) => eventMatches(p, event.type)));
-    for (const sub of filtered) {
-      webhookDelivery.enqueue(sub, event);
-    }
-  };
-  const makeHandler = (topic) => (data) => {
-    const payload = data ?? {};
-    const correlationId = typeof payload["correlationId"] === "string" ? payload["correlationId"] : void 0;
-    const taskId = typeof payload["taskId"] === "string" ? payload["taskId"] : void 0;
-    let traceId;
-    let spanId;
-    let parentSpanId;
-    let statusCode;
-    if (topic === TOPICS.MAINTENANCE_STARTED) {
-      traceId = newTraceId();
-      spanId = newSpanId();
-      const key = correlationId ?? taskId ?? `run_${spanId}`;
-      registry.open(key, { traceId, spanId });
-    } else if (topic === TOPICS.MAINTENANCE_COMPLETED || topic === TOPICS.MAINTENANCE_ERROR) {
-      const existing = registry.resolve({
-        ...correlationId !== void 0 ? { correlationId } : {},
-        ...taskId !== void 0 ? { taskId } : {}
-      });
-      if (existing !== void 0) {
-        traceId = existing.traceId;
-        spanId = existing.spanId;
-      } else {
-        traceId = newTraceId();
-        spanId = newSpanId();
-      }
-      statusCode = topic === TOPICS.MAINTENANCE_ERROR ? 2 : 1;
-      const key = correlationId ?? taskId ?? "";
-      if (key) registry.close(key);
-    } else {
-      const parent = registry.resolve({
-        ...correlationId !== void 0 ? { correlationId } : {},
-        ...taskId !== void 0 ? { taskId } : {}
-      });
-      traceId = parent?.traceId ?? newTraceId();
-      spanId = newSpanId();
-      parentSpanId = parent?.spanId;
-    }
-    const startNs = nowNs();
-    const span = {
-      traceId,
-      spanId,
-      ...parentSpanId !== void 0 ? { parentSpanId } : {},
-      name: SPAN_NAME[topic],
-      kind: import_core12.SpanKind.INTERNAL,
-      startTimeNs: startNs,
-      endTimeNs: startNs,
-      attributes: buildAttributes(payload, { "harness.topic": topic }),
-      ...statusCode !== void 0 ? { statusCode } : {}
-    };
-    exporter.push(span);
-    const gatewayEvent = {
-      id: newEventId3(),
-      type: TELEMETRY_TYPE[topic],
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      data: payload,
-      ...correlationId !== void 0 ? { correlationId } : {}
-    };
-    void enqueueToMatchingSubs(gatewayEvent);
-  };
+  const ctx = { registry, exporter, webhookDelivery, store };
   for (const topic of Object.values(TOPICS)) {
-    const fn = makeHandler(topic);
+    const fn = makeTelemetryHandler(ctx, topic);
     bus.on(topic, fn);
     handlers.push({ topic, fn });
   }
@@ -10679,7 +10984,7 @@ function buildSlackSink(config, options) {
 }
 
 // src/notifications/events.ts
-var import_node_crypto15 = require("crypto");
+var import_node_crypto14 = require("crypto");
 
 // src/notifications/envelope.ts
 function asObj(data) {
@@ -10810,8 +11115,8 @@ var NOTIFICATION_TOPICS = [
   "proposal.approved",
   "proposal.rejected"
 ];
-function newEventId4() {
-  return `evt_${(0, import_node_crypto15.randomBytes)(8).toString("hex")}`;
+function newEventId3() {
+  return `evt_${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`;
 }
 function dispatchToEntry(bus, entry, event) {
   const eventType = event.type;
@@ -10846,7 +11151,7 @@ function wireNotificationSinks({ bus, registry }) {
       const entries = registry.list();
       if (entries.length === 0) return;
       const event = {
-        id: newEventId4(),
+        id: newEventId3(),
         type: eventType,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data
@@ -10864,7 +11169,7 @@ function wireNotificationSinks({ bus, registry }) {
 }
 
 // src/orchestrator.ts
-var import_core16 = require("@harness-engineering/core");
+var import_core17 = require("@harness-engineering/core");
 
 // src/logging/logger.ts
 var StructuredLogger = class {
@@ -10949,6 +11254,37 @@ async function scanWorkspaceConfig(workspacePath) {
   return { exitCode: (0, import_core13.computeScanExitCode)(results), results };
 }
 
+// src/core/lane-persistence.ts
+var import_core14 = require("@harness-engineering/core");
+var import_types29 = require("@harness-engineering/types");
+var SIGNAL_TO_LANE = {
+  claim: "claimed",
+  dispatch: "in_progress",
+  success: "in_review",
+  failure: "blocked",
+  abandon: "canceled"
+};
+function mapOrchestratorLane(signal) {
+  return SIGNAL_TO_LANE[signal];
+}
+async function persistLane(projectPath, issueId, signal) {
+  try {
+    const reg = await import_core14.eventSourcing.registerTask(projectPath, issueId, []);
+    if (!reg.ok) return reg;
+    return await import_core14.eventSourcing.transitionLane(projectPath, issueId, mapOrchestratorLane(signal));
+  } catch (err) {
+    return (0, import_types29.Err)(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+async function readPersistedLanes(projectPath) {
+  try {
+    const snap = await import_core14.eventSourcing.readSnapshot(projectPath);
+    return snap.ok ? snap.value.lanes : { tasks: {} };
+  } catch {
+    return { tasks: {} };
+  }
+}
+
 // src/maintenance/task-registry.ts
 var BUILT_IN_TASKS = [
   // --- Mechanical-AI ---
@@ -11012,7 +11348,13 @@ var BUILT_IN_TASKS = [
     description: "Detect and fix cross-check violations",
     schedule: "0 6 * * 1",
     branch: "harness-maint/cross-check-fixes",
-    checkCommand: ["validate-cross-check"],
+    // `harness cross-check` is a dedicated read-only CLI subcommand that surfaces
+    // JUST cross-artifact consistency (plan→implementation coverage + staleness),
+    // mirroring the `validate_cross_check` MCP tool's core (`runCrossCheck`)
+    // WITHOUT running the full `harness validate` suite. It prints a parseable
+    // `Cross-check: N issues` line and exits 0 (clean) / 1 (N issues), so the
+    // maintenance runner reports real results instead of an honest `failure`.
+    checkCommand: ["cross-check"],
     fixSkill: "harness-cross-check-fix"
   },
   // --- Pure-AI ---
@@ -11071,7 +11413,10 @@ var BUILT_IN_TASKS = [
     description: "Assess overall project health",
     schedule: "0 6 * * *",
     branch: null,
-    checkCommand: ["assess_project"]
+    // `assess_project` is an MCP tool name, not a CLI subcommand. The CLI
+    // composite project-health report is `harness insights` (health, entropy,
+    // decay, attention, impact) — a read-only report that records metrics.
+    checkCommand: ["insights"]
   },
   {
     id: "stale-constraints",
@@ -11079,7 +11424,14 @@ var BUILT_IN_TASKS = [
     description: "Detect stale architectural constraints",
     schedule: "0 2 1 * *",
     branch: null,
-    checkCommand: ["detect_stale_constraints"]
+    // `harness stale-constraints` is a dedicated read-only CLI subcommand that
+    // surfaces the `detect_stale_constraints` MCP tool's core in-process. It is
+    // precondition-gated on the knowledge graph: with no graph it emits the
+    // "No knowledge graph found. Run `harness scan` first." signature and exits
+    // non-zero, which the runner classifies as `skipped` (not failure). With a
+    // graph it prints a parseable `Stale constraints: N findings` line and exits
+    // 0 (clean) / 1 (N stale), recorded as report-only metrics.
+    checkCommand: ["stale-constraints"]
   },
   {
     id: "graph-refresh",
@@ -11112,7 +11464,8 @@ var BUILT_IN_TASKS = [
     description: "Clean up stale orchestrator sessions",
     schedule: "0 0 * * *",
     branch: null,
-    checkCommand: ["cleanup-sessions"]
+    checkCommand: ["cleanup-sessions"],
+    excludeFromHumanSweep: true
   },
   {
     id: "perf-baselines",
@@ -11120,7 +11473,8 @@ var BUILT_IN_TASKS = [
     description: "Update performance baselines",
     schedule: "0 7 * * *",
     branch: null,
-    checkCommand: ["perf", "baselines", "update"]
+    checkCommand: ["perf", "baselines", "update"],
+    excludeFromHumanSweep: true
   },
   {
     id: "main-sync",
@@ -11128,7 +11482,8 @@ var BUILT_IN_TASKS = [
     description: "Fast-forward local default branch from origin",
     schedule: "*/15 * * * *",
     branch: null,
-    checkCommand: ["harness", "sync-main", "--json"]
+    checkCommand: ["harness", "sync-main", "--json"],
+    excludeFromHumanSweep: true
   },
   // Hermes Phase 4 — one-shot backfill that stamps `provenance: user-authored`
   // on every existing catalog skill. Schedule is Feb 31 (a date that never
@@ -11141,7 +11496,8 @@ var BUILT_IN_TASKS = [
     description: "Backfill provenance: user-authored on every existing skill (one-shot, idempotent)",
     schedule: "0 0 31 2 *",
     branch: null,
-    checkCommand: ["backfill-skill-provenance"]
+    checkCommand: ["backfill-skill-provenance"],
+    excludeFromHumanSweep: true
   }
 ];
 
@@ -11208,6 +11564,17 @@ function cronMatchesNow(expression, now) {
   const daysOfWeek = parseField(dowField, 0, 6);
   return minutes.has(minute) && hours.has(hour) && daysOfMonth.has(dayOfMonth) && months.has(month) && daysOfWeek.has(dayOfWeek);
 }
+function cronMatchesDate(expression, date) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression: expected 5 fields, got ${fields.length}`);
+  }
+  const [, , domField, monthField, dowField] = fields;
+  const daysOfMonth = parseField(domField, 1, 31);
+  const months = parseField(monthField, 1, 12);
+  const daysOfWeek = parseField(dowField, 0, 6);
+  return daysOfMonth.has(date.getDate()) && months.has(date.getMonth() + 1) && daysOfWeek.has(date.getDay());
+}
 
 // src/maintenance/scheduler.ts
 var MaintenanceScheduler = class {
@@ -11449,15 +11816,15 @@ var MaintenanceScheduler = class {
 };
 
 // src/maintenance/leader-elector.ts
-var import_types29 = require("@harness-engineering/types");
+var import_types30 = require("@harness-engineering/types");
 var SingleProcessLeaderElector = class {
   async electLeader() {
-    return (0, import_types29.Ok)("claimed");
+    return (0, import_types30.Ok)("claimed");
   }
 };
 
 // src/maintenance/reporter.ts
-var fs16 = __toESM(require("fs"));
+var fs14 = __toESM(require("fs"));
 var path18 = __toESM(require("path"));
 var import_zod17 = require("zod");
 var RunResultSchema = import_zod17.z.object({
@@ -11493,9 +11860,9 @@ var MaintenanceReporter = class {
    */
   async load() {
     try {
-      await fs16.promises.mkdir(this.persistDir, { recursive: true });
+      await fs14.promises.mkdir(this.persistDir, { recursive: true });
       const filePath = path18.join(this.persistDir, "history.json");
-      const data = await fs16.promises.readFile(filePath, "utf-8");
+      const data = await fs14.promises.readFile(filePath, "utf-8");
       const parsed = import_zod17.z.array(RunResultSchema).safeParse(JSON.parse(data));
       if (parsed.success) {
         this.history = parsed.data.slice(0, MAX_HISTORY);
@@ -11529,9 +11896,9 @@ var MaintenanceReporter = class {
    */
   async persist() {
     try {
-      await fs16.promises.mkdir(this.persistDir, { recursive: true });
+      await fs14.promises.mkdir(this.persistDir, { recursive: true });
       const filePath = path18.join(this.persistDir, "history.json");
-      await fs16.promises.writeFile(filePath, JSON.stringify(this.history, null, 2), "utf-8");
+      await fs14.promises.writeFile(filePath, JSON.stringify(this.history, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("MaintenanceReporter: failed to persist history", { error: String(err) });
     }
@@ -11571,20 +11938,20 @@ var TaskRunner = class {
    * @param origin - Hermes Phase 2 trigger-source tag; defaults to `'cron'`
    *                 when called from the scheduler path.
    */
-  async run(task, origin = "cron") {
+  async run(task, origin = "cron", mode = "fix") {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     let result;
     let captured;
     try {
       switch (task.type) {
         case "mechanical-ai": {
-          const out = await this.runMechanicalAI(task, startedAt);
+          const out = await this.runMechanicalAI(task, startedAt, mode);
           result = out.result;
           captured = out.captured;
           break;
         }
         case "pure-ai":
-          result = await this.runPureAI(task, startedAt);
+          result = await this.runPureAI(task, startedAt, mode);
           break;
         case "report-only": {
           const out = await this.runReportOnly(task, startedAt);
@@ -11593,7 +11960,7 @@ var TaskRunner = class {
           break;
         }
         case "housekeeping": {
-          const out = await this.runHousekeeping(task, startedAt);
+          const out = await this.runHousekeeping(task, startedAt, mode);
           result = out.result;
           captured = out.captured;
           break;
@@ -11657,7 +12024,8 @@ var TaskRunner = class {
         findings: r2.findings,
         stdout: r2.output,
         stderr: r2.stderr,
-        structured: r2.structured ? r2.structured : null
+        structured: r2.structured ? r2.structured : null,
+        executionFailed: false
       };
     }
     if (!task.checkCommand || task.checkCommand.length === 0) {
@@ -11669,7 +12037,8 @@ var TaskRunner = class {
       findings: r.findings,
       stdout: r.output,
       stderr: "",
-      structured: null
+      structured: null,
+      executionFailed: r.executionFailed ?? false
     };
   }
   /**
@@ -11694,7 +12063,7 @@ var TaskRunner = class {
    * only if fixable findings exist; persist captured stdout/stderr/context
    * via the output store on the way out.
    */
-  async runMechanicalAI(task, startedAt) {
+  async runMechanicalAI(task, startedAt, mode = "fix") {
     if (!task.fixSkill) {
       return wrap(this.failureResult(task.id, startedAt, "mechanical-ai task missing fixSkill"));
     }
@@ -11716,6 +12085,27 @@ var TaskRunner = class {
     } catch (err) {
       return wrap(this.failureResult(task.id, startedAt, String(err)));
     }
+    if (check.executionFailed) {
+      const cls = classifyCheckExecutionFailure(`${check.stdout}
+${check.stderr}`);
+      if (cls.kind === "unrunnable") {
+        return wrap(
+          this.failureResult(task.id, startedAt, checkExecutionError(check)),
+          captureFromCheck(check)
+        );
+      }
+      if (cls.kind === "precondition") {
+        return wrap(
+          this.skippedResult(task.id, startedAt, cls.reason ?? "precondition not met"),
+          captureFromCheck(check)
+        );
+      }
+      check = {
+        ...check,
+        executionFailed: false,
+        findings: check.findings > 0 ? check.findings : recoverFindingsCount(check.stdout)
+      };
+    }
     const promptContext = await this.composePromptContext(task);
     const baseCaptured = {
       stdout: check.stdout,
@@ -11724,13 +12114,14 @@ var TaskRunner = class {
       ...promptContext ? { context: promptContext } : {}
     };
     const wakeAgentExplicitlyFalse = check.structured !== null && typeof check.structured === "object" && check.structured.wakeAgent === false;
-    if (check.findings === 0 || wakeAgentExplicitlyFalse) {
+    if (check.findings === 0 || wakeAgentExplicitlyFalse || mode === "report") {
+      const reportedWithFindings = mode === "report" && check.findings > 0;
       return {
         result: {
           taskId: task.id,
           startedAt,
           completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          status: "no-issues",
+          status: reportedWithFindings ? "success" : "no-issues",
           findings: check.findings,
           fixed: 0,
           prUrl: null,
@@ -11800,7 +12191,19 @@ var TaskRunner = class {
   /**
    * Pure-AI: always dispatch agent with configured skill.
    */
-  async runPureAI(task, startedAt) {
+  async runPureAI(task, startedAt, mode = "fix") {
+    if (mode === "report") {
+      return {
+        taskId: task.id,
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "no-issues",
+        findings: 0,
+        fixed: 0,
+        prUrl: null,
+        prUpdated: false
+      };
+    }
     if (!task.fixSkill) {
       return this.failureResult(task.id, startedAt, "pure-ai task missing fixSkill");
     }
@@ -11874,6 +12277,27 @@ var TaskRunner = class {
       return wrap(this.failureResult(task.id, startedAt, String(err)));
     }
     const parsed = parseStatusLine(check.stdout);
+    if (parsed === null && check.executionFailed) {
+      const cls = classifyCheckExecutionFailure(`${check.stdout}
+${check.stderr}`);
+      if (cls.kind === "unrunnable") {
+        return wrap(
+          this.failureResult(task.id, startedAt, checkExecutionError(check)),
+          captureFromCheck(check)
+        );
+      }
+      if (cls.kind === "precondition") {
+        return wrap(
+          this.skippedResult(task.id, startedAt, cls.reason ?? "precondition not met"),
+          captureFromCheck(check)
+        );
+      }
+      check = {
+        ...check,
+        executionFailed: false,
+        findings: check.findings > 0 ? check.findings : recoverFindingsCount(check.stdout)
+      };
+    }
     const status = parsed?.status ?? "success";
     const findings = parsed === null ? check.findings : typeof parsed.candidatesFound === "number" ? parsed.candidatesFound : 0;
     const result = {
@@ -11907,7 +12331,20 @@ var TaskRunner = class {
    * Hermes Phase 2: a `checkScript` may replace `checkCommand` for housekeeping
    * tasks; the runner falls through to the same JSON-status parsing path.
    */
-  async runHousekeeping(task, startedAt) {
+  async runHousekeeping(task, startedAt, mode = "fix") {
+    if (mode === "report") {
+      return wrap({
+        taskId: task.id,
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "skipped",
+        findings: 0,
+        fixed: 0,
+        prUrl: null,
+        prUpdated: false,
+        error: "skipped in report mode: housekeeping may mutate and report runs are read-only"
+      });
+    }
     if (!task.checkCommand && !task.checkScript) {
       return wrap(
         this.failureResult(
@@ -11974,46 +12411,133 @@ var TaskRunner = class {
       error
     };
   }
+  /**
+   * A precondition-gated check (e.g. `predict` with <3 snapshots, or a
+   * graph-backed check before `harness scan`). The command is correctly
+   * configured; the repo just lacks the state it needs. Reported as `skipped`
+   * — distinct from a hard `failure` — carrying the refusal line as the reason
+   * (surfaced in the run-report summary column). ADR 0050.
+   */
+  skippedResult(taskId, startedAt, reason) {
+    return {
+      taskId,
+      startedAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "skipped",
+      findings: 0,
+      fixed: 0,
+      prUrl: null,
+      prUpdated: false,
+      error: reason
+    };
+  }
 };
 function wrap(result, captured) {
   return captured ? { result, captured } : { result };
 }
+function checkExecutionError(check) {
+  const detail = (check.stderr || check.stdout || "").trim();
+  return detail ? `check command failed to execute: ${detail}` : "check command failed to execute";
+}
+function captureFromCheck(check) {
+  return { stdout: check.stdout, stderr: check.stderr, structured: check.structured };
+}
+var PRECONDITION_PATTERNS = [
+  /requires at least \d+ snapshots?/i,
+  /Run ["'`]?harness snapshot/i,
+  /no knowledge graph found/i,
+  /Run ["'`]?harness scan/i,
+  /no graph (?:available|found)/i
+];
+var UNRUNNABLE_PATTERNS = [
+  /unknown command/i,
+  /unknown option/i,
+  /\bENOENT\b/,
+  /command not found/i,
+  /cannot find module/i,
+  // A timed-out check did not complete — it is a hard failure, never a
+  // "ran-no-count" success. The runners synthesize this message on SIGTERM.
+  /timed out/i,
+  /\bETIMEDOUT\b/
+];
+var TIMEOUT_SIGNATURE = /check timed out after \d+\s*ms/i;
+function explicitFindingsCount(output) {
+  const after = output.match(/(?:findings?|issues?|violations?|errors?)\s*[:=]\s*(\d+)/i);
+  if (after) return parseInt(after[1], 10);
+  const before = output.match(/(\d+)\s+(?:findings?|issues?|violations?|errors?)\b/i);
+  if (before) return parseInt(before[1], 10);
+  return null;
+}
+function recoverFindingsCount(output) {
+  return explicitFindingsCount(output) ?? 1;
+}
+function firstMeaningfulLine(output) {
+  const line = output.split("\n").map((l) => l.trim()).find(Boolean);
+  if (!line) return "precondition not met";
+  return line.replace(/^[x✗✓!-]\s*/u, "").trim();
+}
+var CLASSIFY_HEAD_LINES = 3;
+function classifyCheckExecutionFailure(output) {
+  const text = (output ?? "").trim();
+  if (text.length === 0) return { kind: "unrunnable" };
+  if (TIMEOUT_SIGNATURE.test(text)) return { kind: "unrunnable" };
+  if (explicitFindingsCount(text) !== null) return { kind: "ran-no-count" };
+  const head = text.split("\n").filter((l) => l.trim()).slice(0, CLASSIFY_HEAD_LINES).join("\n");
+  for (const re of PRECONDITION_PATTERNS) {
+    if (re.test(head)) return { kind: "precondition", reason: firstMeaningfulLine(text) };
+  }
+  for (const re of UNRUNNABLE_PATTERNS) {
+    if (re.test(head)) return { kind: "unrunnable" };
+  }
+  return { kind: "ran-no-count" };
+}
 function parseStatusLine(output) {
   const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
   for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i];
-    if (!line || !line.startsWith("{") || !line.endsWith("}")) continue;
-    try {
-      const obj = JSON.parse(line);
-      const s = obj.status;
-      if (s === "success" || s === "skipped" || s === "failure" || s === "no-issues") {
-        const parsed = { status: s, rawStatus: s };
-        if (typeof obj.candidatesFound === "number") {
-          parsed.candidatesFound = obj.candidatesFound;
-        }
-        if (typeof obj.error === "string") {
-          parsed.error = obj.error;
-        }
-        if (typeof obj.reason === "string") {
-          parsed.reason = obj.reason;
-        }
-        if (typeof obj.detail === "string" && !parsed.error) {
-          parsed.error = `${parsed.reason ?? "skipped"}: ${obj.detail}`;
-        }
-        return parsed;
-      }
-      if (s === "updated" || s === "no-op") {
-        return { status: "success", rawStatus: s };
-      }
-      if (s === "error") {
-        const message = typeof obj.message === "string" ? obj.message : "unknown error";
-        return { status: "failure", error: message, rawStatus: "error" };
-      }
-    } catch {
-    }
+    const parsed = parseStatusObjectLine(lines[i]);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+function parseStatusObjectLine(line) {
+  if (!line || !line.startsWith("{") || !line.endsWith("}")) return null;
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  return classifyStatusObject(obj);
+}
+var PHASE_STATUSES = /* @__PURE__ */ new Set(["success", "skipped", "failure", "no-issues"]);
+var SYNC_SUCCESS_STATUSES = /* @__PURE__ */ new Set(["updated", "no-op"]);
+function classifyStatusObject(obj) {
+  const s = obj.status;
+  if (typeof s !== "string") return null;
+  if (PHASE_STATUSES.has(s)) return buildPhaseStatus(s, obj);
+  if (SYNC_SUCCESS_STATUSES.has(s)) return { status: "success", rawStatus: s };
+  if (s === "error") {
+    const message = typeof obj.message === "string" ? obj.message : "unknown error";
+    return { status: "failure", error: message, rawStatus: "error" };
   }
   return null;
 }
+function buildPhaseStatus(status, obj) {
+  const parsed = { status, rawStatus: status };
+  if (typeof obj.candidatesFound === "number") {
+    parsed.candidatesFound = obj.candidatesFound;
+  }
+  if (typeof obj.error === "string") {
+    parsed.error = obj.error;
+  }
+  if (typeof obj.reason === "string") {
+    parsed.reason = obj.reason;
+  }
+  if (typeof obj.detail === "string" && !parsed.error) {
+    parsed.error = `${parsed.reason ?? "skipped"}: ${obj.detail}`;
+  }
+  return parsed;
+}
 
 // src/maintenance/check-script-runner.ts
 var import_node_child_process11 = require("child_process");
@@ -12126,8 +12650,49 @@ function heuristicResult(stdout, stderr, exitedAbnormally) {
   };
 }
 
+// src/maintenance/check-runner.ts
+var import_node_child_process12 = require("child_process");
+var import_node_util4 = require("util");
+var MAINTENANCE_CHECK_MAX_BUFFER = 64 * 1024 * 1024;
+var MAINTENANCE_CHECK_TIMEOUT_MS = 3e5;
+var FINDINGS_RE = /(\d+)\s+(?:finding|issue|violation|error)/i;
+var nodeExecFileAsync = (0, import_node_util4.promisify)(import_node_child_process12.execFile);
+function isCheckTimeoutError(e) {
+  return e.killed === true || e.signal === "SIGTERM" || e.code === "ETIMEDOUT";
+}
+async function runHarnessCheck(spawn7, cwd, opts = {}) {
+  const execFileAsync2 = opts.execFileAsync ?? nodeExecFileAsync;
+  const timeoutMs = opts.timeoutMs ?? MAINTENANCE_CHECK_TIMEOUT_MS;
+  const maxBuffer = opts.maxBuffer ?? MAINTENANCE_CHECK_MAX_BUFFER;
+  try {
+    const { stdout } = await execFileAsync2(spawn7.file, spawn7.args, {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer
+    });
+    const text = String(stdout);
+    const m = text.match(FINDINGS_RE);
+    const findings = m ? parseInt(m[1], 10) : 0;
+    return { passed: findings === 0, findings, output: text, executionFailed: false };
+  } catch (err) {
+    const e = err;
+    let output = [e.stdout, e.stderr].map((v) => v == null ? "" : String(v)).filter(Boolean).join("\n");
+    if (isCheckTimeoutError(e)) {
+      const note = `check timed out after ${timeoutMs}ms`;
+      output = output.trim() ? `${output}
+${note}` : note;
+      return { passed: false, findings: 0, output, executionFailed: true };
+    }
+    const m = output.match(FINDINGS_RE);
+    if (m) {
+      return { passed: false, findings: parseInt(m[1], 10), output, executionFailed: false };
+    }
+    return { passed: false, findings: 0, output, executionFailed: true };
+  }
+}
+
 // src/maintenance/output-store.ts
-var fs17 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var path20 = __toESM(require("path"));
 var DEFAULT_RETENTION = {
   runs: 50,
@@ -12168,13 +12733,13 @@ var TaskOutputStore = class {
   async write(taskId, entry, retention) {
     this.ensureSafeTaskId(taskId);
     const dir = this.dirFor(taskId);
-    await fs17.promises.mkdir(dir, { recursive: true });
+    await fs15.promises.mkdir(dir, { recursive: true });
     const fileName = `${sanitizeIso(entry.completedAt || (/* @__PURE__ */ new Date()).toISOString())}.json`;
     const filePath = path20.join(dir, fileName);
     const tmpPath = `${filePath}.tmp`;
     const payload = JSON.stringify(entry, null, 2);
-    await fs17.promises.writeFile(tmpPath, payload, "utf-8");
-    await fs17.promises.rename(tmpPath, filePath);
+    await fs15.promises.writeFile(tmpPath, payload, "utf-8");
+    await fs15.promises.rename(tmpPath, filePath);
     try {
       await this.applyRetention(taskId, retention);
     } catch (err) {
@@ -12225,7 +12790,7 @@ var TaskOutputStore = class {
   }
   async readEntry(filePath) {
     try {
-      const buf = await fs17.promises.readFile(filePath, "utf-8");
+      const buf = await fs15.promises.readFile(filePath, "utf-8");
       const parsed = JSON.parse(buf);
       return parsed;
     } catch {
@@ -12247,7 +12812,7 @@ var TaskOutputStore = class {
     const toRemove = /* @__PURE__ */ new Set([...overflow, ...aged]);
     for (const name of toRemove) {
       try {
-        await fs17.promises.unlink(path20.join(dir, name));
+        await fs15.promises.unlink(path20.join(dir, name));
       } catch {
       }
     }
@@ -12256,7 +12821,7 @@ var TaskOutputStore = class {
 async function listJsonFilesDescending(dir) {
   let names;
   try {
-    names = await fs17.promises.readdir(dir);
+    names = await fs15.promises.readdir(dir);
   } catch {
     return [];
   }
@@ -12365,7 +12930,7 @@ var fallbackLogger3 = {
 };
 
 // src/maintenance/custom-task-validator.ts
-var import_types30 = require("@harness-engineering/types");
+var import_types31 = require("@harness-engineering/types");
 var ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 var REQUIRED_FIELDS_BY_TYPE = {
   "mechanical-ai": ["branch", "fixSkill"],
@@ -12375,7 +12940,7 @@ var REQUIRED_FIELDS_BY_TYPE = {
 };
 function validateCustomTasks(customTasks, builtIns, deps = {}) {
   const errors = [];
-  if (!customTasks) return (0, import_types30.Ok)(void 0);
+  if (!customTasks) return (0, import_types31.Ok)(void 0);
   const builtInIds = new Set(builtIns.map((t) => t.id));
   const customIds = Object.keys(customTasks);
   const allIds = /* @__PURE__ */ new Set([...builtInIds, ...customIds]);
@@ -12385,7 +12950,7 @@ function validateCustomTasks(customTasks, builtIns, deps = {}) {
     validateOne(id, task, builtInIds, allIds, deps, errors);
   }
   detectCycles(customTasks, builtIns, errors);
-  return errors.length === 0 ? (0, import_types30.Ok)(void 0) : (0, import_types30.Err)(errors);
+  return errors.length === 0 ? (0, import_types31.Ok)(void 0) : (0, import_types31.Err)(errors);
 }
 function validateOne(id, task, builtInIds, allIds, deps, errors) {
   const prefix = `customTasks.${id}`;
@@ -12574,6 +13139,11 @@ function deriveSeedPaths(config) {
   const roadmapPath = config.tracker.kind === "roadmap" && config.tracker.filePath ? config.tracker.filePath : "docs/roadmap.md";
   return [".harness/proposals", roadmapPath];
 }
+function normalizeHarnessCommand(command) {
+  if (command.length === 0) return [];
+  if (command[0] === "harness") return command;
+  return ["harness", ...command];
+}
 var Orchestrator = class extends import_node_events.EventEmitter {
   state;
   config;
@@ -12700,6 +13270,11 @@ var Orchestrator = class extends import_node_events.EventEmitter {
   abortControllers = /* @__PURE__ */ new Map();
   /** Guards against overlapping ticks when a tick takes longer than the polling interval */
   tickInProgress = false;
+  /** Phase 4 (DLane-5): lanes read back from the durable log on first tick, for
+   *  observability only — NOT fed into reconciliation. Empty until the first tick. */
+  persistedLanes = { tasks: {} };
+  /** Ensures the lane read-back diagnostic runs at most once (first tick). */
+  laneReadbackDone = false;
   /** Timestamp of the last stale branch sweep (at most once per hour) */
   lastBranchSweepMs = 0;
   /** Current tick-phase activity visible to the dashboard */
@@ -12773,7 +13348,7 @@ var Orchestrator = class extends import_node_events.EventEmitter {
         this.localResolvers.set(name, new LocalModelResolver(resolverOpts));
       }
     }
-    this.cacheMetrics = new import_core16.CacheMetricsRecorder();
+    this.cacheMetrics = new import_core17.CacheMetricsRecorder();
     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];
@@ -12857,22 +13432,7 @@ var Orchestrator = class extends import_node_events.EventEmitter {
       });
       webhookDelivery.start();
       this.setupNotifications(config.notifications);
-      const otlpCfg = config.telemetry?.export?.otlp;
-      if (otlpCfg) {
-        this.otlpExporter = new import_core16.OTLPExporter({
-          endpoint: otlpCfg.endpoint,
-          ...otlpCfg.enabled !== void 0 ? { enabled: otlpCfg.enabled } : {},
-          ...otlpCfg.headers !== void 0 ? { headers: otlpCfg.headers } : {},
-          ...otlpCfg.flushIntervalMs !== void 0 ? { flushIntervalMs: otlpCfg.flushIntervalMs } : {},
-          ...otlpCfg.batchSize !== void 0 ? { batchSize: otlpCfg.batchSize } : {}
-        });
-        this.telemetryFanoutOff = wireTelemetryFanout({
-          bus: this,
-          exporter: this.otlpExporter,
-          webhookDelivery,
-          store: webhookStore
-        });
-      }
+      this.setupTelemetryExport(config, webhookStore, webhookDelivery);
       this.server = new OrchestratorServer(this, config.server.port, {
         interactionQueue: this.interactionQueue,
         webhooks: {
@@ -12895,24 +13455,8 @@ var Orchestrator = class extends import_node_events.EventEmitter {
         analysisArchive: this.analysisArchive,
         roadmapPath: config.tracker.filePath ?? null,
         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;
-        }
+        getLocalModelStatus: () => this.getFirstLocalModelStatus(),
+        getLocalModelStatuses: () => this.buildLocalModelStatuses()
       });
       this.server.setRecorder(this.recorder);
       this.interactionQueue.onPush((interaction) => {
@@ -12920,6 +13464,56 @@ var Orchestrator = class extends import_node_events.EventEmitter {
       });
     }
   }
+  /**
+   * Phase 5: construct the OTLP/HTTP trace exporter and wire telemetry fanout.
+   * Only fires when the operator configures `telemetry.export.otlp` in
+   * harness.config.json. Extracted from the server-init block in the
+   * constructor to keep that block's cyclomatic complexity under threshold.
+   */
+  setupTelemetryExport(config, webhookStore, webhookDelivery) {
+    const otlpCfg = config.telemetry?.export?.otlp;
+    if (!otlpCfg) return;
+    this.otlpExporter = new import_core17.OTLPExporter({
+      endpoint: otlpCfg.endpoint,
+      ...otlpCfg.enabled !== void 0 ? { enabled: otlpCfg.enabled } : {},
+      ...otlpCfg.headers !== void 0 ? { headers: otlpCfg.headers } : {},
+      ...otlpCfg.flushIntervalMs !== void 0 ? { flushIntervalMs: otlpCfg.flushIntervalMs } : {},
+      ...otlpCfg.batchSize !== void 0 ? { batchSize: otlpCfg.batchSize } : {}
+    });
+    this.telemetryFanoutOff = wireTelemetryFanout({
+      bus: this,
+      exporter: this.otlpExporter,
+      webhookDelivery,
+      store: webhookStore
+    });
+  }
+  /**
+   * Deprecated alias for /api/v1/local-model/status (Spec 1 endpoint retained
+   * as a compat shim per spec line 35; superseded by getLocalModelStatuses for
+   * the multi-local UI). Returns the first-registered resolver's status.
+   */
+  getFirstLocalModelStatus() {
+    const first = this.localResolvers.values().next();
+    return first.done ? null : first.value.getStatus();
+  }
+  /**
+   * SC38: build NamedLocalModelStatus[] from each registered resolver, tagged
+   * with its backendName + endpoint from the config.
+   */
+  buildLocalModelStatuses() {
+    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;
+  }
   createTracker() {
     if (this.config.tracker.kind === "github-issues") {
       const trackerCfg = {
@@ -12928,7 +13522,7 @@ var Orchestrator = class extends import_node_events.EventEmitter {
         ...this.config.tracker.apiKey ? { token: this.config.tracker.apiKey } : {},
         ...this.config.tracker.endpoint ? { apiBase: this.config.tracker.endpoint } : {}
       };
-      const clientResult = (0, import_core15.createTrackerClient)(trackerCfg);
+      const clientResult = (0, import_core16.createTrackerClient)(trackerCfg);
       if (!clientResult.ok) throw clientResult.error;
       return new GitHubIssuesIssueTrackerAdapter(clientResult.value, this.config.tracker);
     }
@@ -12946,48 +13540,30 @@ var Orchestrator = class extends import_node_events.EventEmitter {
     const logger = this.logger;
     const checkRunner = {
       run: async (command, cwd) => {
-        const { execFile: execFile7 } = await import("child_process");
-        const { promisify: promisify5 } = await import("util");
-        const execFileAsync2 = promisify5(execFile7);
-        const [cmd, ...args] = command;
-        if (!cmd) return { passed: true, findings: 0, output: "" };
-        try {
-          const { stdout } = await execFileAsync2(cmd, args, { cwd, timeout: 12e4 });
-          const findingsMatch = stdout.match(/(\d+)\s+(?:finding|issue|violation|error)/i);
-          const findings = findingsMatch ? parseInt(findingsMatch[1], 10) : 0;
-          return { passed: findings === 0, findings, output: stdout };
-        } catch (err) {
-          const error = err;
-          const output = [error.stdout, error.stderr].filter(Boolean).join("\n");
-          const findingsMatch = output.match(/(\d+)\s+(?:finding|issue|violation|error)/i);
-          const findings = findingsMatch ? parseInt(findingsMatch[1], 10) : 1;
-          return { passed: false, findings, output };
-        }
-      }
-    };
-    const agentDispatcher = {
-      dispatch: async (skill, branch, backendName, cwd) => {
-        logger.info(
-          "Maintenance agent dispatcher invoked (stub \u2014 skill dispatch integration pending)",
-          {
-            skill,
-            branch,
-            backendName,
-            cwd
-          }
-        );
-        return { producedCommits: false, fixed: 0 };
+        const [cmd, ...args] = normalizeHarnessCommand(command);
+        if (!cmd) return { passed: true, findings: 0, output: "", executionFailed: false };
+        return runHarnessCheck({ file: cmd, args }, cwd);
       }
     };
+    const resolveBackend2 = makeBackendResolver(this.getBackends());
+    const agentDispatcher = createAgentDispatcher({
+      resolveBackend: resolveBackend2,
+      git: (args, cwd) => (0, import_node_child_process13.execFileSync)("git", args, { cwd, encoding: "utf-8" }).toString().trim(),
+      logger
+    });
     const commandExecutor = {
       exec: async (command, cwd) => {
         const { execFile: execFile7 } = await import("child_process");
-        const { promisify: promisify5 } = await import("util");
-        const execFileAsync2 = promisify5(execFile7);
-        const [cmd, ...args] = command;
+        const { promisify: promisify6 } = await import("util");
+        const execFileAsync2 = promisify6(execFile7);
+        const [cmd, ...args] = normalizeHarnessCommand(command);
         if (!cmd) return { stdout: "" };
         try {
-          const { stdout } = await execFileAsync2(cmd, args, { cwd, timeout: 12e4 });
+          const { stdout } = await execFileAsync2(cmd, args, {
+            cwd,
+            timeout: MAINTENANCE_CHECK_TIMEOUT_MS,
+            maxBuffer: MAINTENANCE_CHECK_MAX_BUFFER
+          });
           return { stdout: String(stdout) };
         } catch (err) {
           logger.warn("Maintenance command execution failed", {
@@ -13122,6 +13698,10 @@ ${messages}`);
   async asyncTick() {
     await this.ensureClaimManager();
     await this.intelligenceRunner.loadPersistedData();
+    if (!this.laneReadbackDone) {
+      this.laneReadbackDone = true;
+      await this.readBackPersistedLanes();
+    }
     const nowMs = Date.now();
     this.setTickActivity("fetching", "Polling tracker for candidates");
     const candidatesResult = await this.tracker.fetchCandidateIssues();
@@ -13274,12 +13854,48 @@ ${messages}`);
         break;
       case "escalate":
         await this.handleEscalation(effect);
+        await this.persistLaneSafe(effect.issueId, "abandon");
         break;
       case "claim":
         await this.handleClaimEffect(effect);
         break;
     }
   }
+  /**
+   * Phase 4 (DLane-5): persist an orchestrator lane transition to the durable
+   * core event log at the effect boundary. NEVER throws — `persistLane` returns
+   * an `Err` Result on failure, which is logged and swallowed here so a
+   * lane-persistence failure can never break orchestrator dispatch.
+   */
+  async persistLaneSafe(issueId, signal) {
+    const r = await persistLane(this.projectRoot, issueId, signal);
+    if (!r.ok) {
+      this.logger.warn(`lane persist failed for ${issueId} (${signal}): ${r.error.message}`);
+    }
+  }
+  /**
+   * Phase 4 (DLane-5): read persisted task lanes back from the durable log and
+   * log a one-line summary. Stores the projection on `this.persistedLanes` for
+   * observability. Read-only — never feeds reconciliation, never throws.
+   */
+  async readBackPersistedLanes() {
+    const lanes = await readPersistedLanes(this.projectRoot);
+    this.persistedLanes = lanes;
+    const entries = Object.keys(lanes.tasks).map((id) => `${id}:${lanes.tasks[id]?.lane}`);
+    const nonTerminal = entries.filter((e) => !e.endsWith(":done") && !e.endsWith(":canceled"));
+    this.logger.info(
+      `Lane read-back on startup: ${entries.length} persisted task(s), ${nonTerminal.length} non-terminal`,
+      { nonTerminal }
+    );
+  }
+  /**
+   * Phase 4 (DLane-5): the task lanes most recently read back from the durable
+   * log on startup, exposed for external observability. Read-only — a fresh
+   * `{ tasks: {} }` until the first tick's read-back has run.
+   */
+  getPersistedLanes() {
+    return this.persistedLanes;
+  }
   /**
    * Guards workspace cleanup by checking whether the agent pushed a branch
    * that does not yet have a pull request. If so, the worktree is preserved
@@ -13312,7 +13928,7 @@ ${messages}`);
           { issueId }
         );
         await this.interactionQueue.push({
-          id: `interaction-${(0, import_node_crypto16.randomUUID)()}`,
+          id: `interaction-${(0, import_node_crypto15.randomUUID)()}`,
           issueId,
           type: "needs-human",
           reasons: [`Agent pushed branch "${branch}" but did not create a PR. Worktree preserved.`],
@@ -13388,7 +14004,7 @@ ${messages}`);
       { issueId: effect.issueId }
     );
     await this.interactionQueue.push({
-      id: `interaction-${(0, import_node_crypto16.randomUUID)()}`,
+      id: `interaction-${(0, import_node_crypto15.randomUUID)()}`,
       issueId: effect.issueId,
       type: "needs-human",
       reasons: effect.reasons,
@@ -13466,6 +14082,7 @@ ${messages}`);
       }
       return;
     }
+    await this.persistLaneSafe(effect.issue.id, "claim");
     await this.postClaimComment(effect.issue);
     await this.dispatchIssue(effect.issue, effect.attempt, effect.backend);
   }
@@ -13484,12 +14101,12 @@ ${messages}`);
   async postLifecycleComment(identifier, externalId, event) {
     try {
       if (!externalId) return;
-      const trackerConfig = (0, import_core15.loadTrackerSyncConfig)(this.projectRoot);
+      const trackerConfig = (0, import_core16.loadTrackerSyncConfig)(this.projectRoot);
       if (!trackerConfig) return;
       const token = process.env.GITHUB_TOKEN;
       if (!token) return;
       const orchestratorId = await this.orchestratorIdPromise;
-      const adapter = new import_core15.GitHubIssuesSyncAdapter({ token, config: trackerConfig });
+      const adapter = new import_core16.GitHubIssuesSyncAdapter({ token, config: trackerConfig });
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
       const actionMap = {
         claimed: "Dispatching agent for autonomous execution",
@@ -13526,6 +14143,7 @@ ${messages}`);
     this.logger.info(`Dispatching issue: ${issue.identifier} (attempt ${attempt})`, {
       issueId: issue.id
     });
+    await this.persistLaneSafe(issue.id, "dispatch");
     try {
       const workspaceResult = await this.workspace.ensureWorkspace(issue.identifier);
       if (!workspaceResult.ok) throw workspaceResult.error;
@@ -13562,7 +14180,7 @@ ${messages}`);
             ...f.line !== void 0 ? { line: f.line } : {}
           }))
         );
-        (0, import_core14.writeTaint)(
+        (0, import_core15.writeTaint)(
           workspacePath,
           issue.id,
           "Medium-severity injection patterns found in workspace config files",
@@ -13734,6 +14352,7 @@ ${messages}`);
    * Informs the state machine that an agent worker has exited.
    */
   async emitWorkerExit(issueId, reason, attempt, error) {
+    await this.persistLaneSafe(issueId, reason === "normal" ? "success" : "failure");
     await this.completionHandler.handleWorkerExit(
       issueId,
       reason,
@@ -14269,11 +14888,11 @@ function launchTUI(orchestrator) {
 }
 
 // src/maintenance/sync-main.ts
-var import_node_child_process12 = require("child_process");
-var import_node_util4 = require("util");
+var import_node_child_process14 = require("child_process");
+var import_node_util5 = require("util");
 var DEFAULT_TIMEOUT_MS3 = 6e4;
 async function git(execFileFn, args, cwd, timeoutMs) {
-  const exec = (0, import_node_util4.promisify)(execFileFn);
+  const exec = (0, import_node_util5.promisify)(execFileFn);
   const { stdout, stderr } = await exec("git", args, { cwd, timeout: timeoutMs });
   return { stdout: String(stdout), stderr: String(stderr) };
 }
@@ -14335,7 +14954,7 @@ async function isAncestor(execFileFn, a, b, cwd, timeoutMs) {
   }
 }
 async function syncMain(repoRoot, opts = {}) {
-  const execFileFn = opts.execFileFn ?? import_node_child_process12.execFile;
+  const execFileFn = opts.execFileFn ?? import_node_child_process14.execFile;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   try {
     const originRef = await resolveOriginDefault(execFileFn, repoRoot, timeoutMs);
@@ -14412,11 +15031,59 @@ async function syncMain(repoRoot, opts = {}) {
   }
 }
 
+// src/maintenance/overdue.ts
+var LOOKBACK_DAYS = 366;
+function previousFireTime(schedule, now) {
+  let day = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  for (let d = 0; d <= LOOKBACK_DAYS; d++) {
+    if (cronMatchesDate(schedule, day)) {
+      const dayStartMs = day.getTime();
+      const scanStart = d === 0 ? new Date(
+        now.getFullYear(),
+        now.getMonth(),
+        now.getDate(),
+        now.getHours(),
+        now.getMinutes()
+      ) : new Date(day.getFullYear(), day.getMonth(), day.getDate(), 23, 59);
+      for (let ms = scanStart.getTime(); ms >= dayStartMs; ms -= 6e4) {
+        const candidate = new Date(ms);
+        if (cronMatchesNow(schedule, candidate)) return candidate;
+      }
+    }
+    day = new Date(day.getFullYear(), day.getMonth(), day.getDate() - 1);
+  }
+  return null;
+}
+function isSatisfyingRun(r) {
+  return r.status === "success" || r.status === "no-issues";
+}
+function isOverdue(task, history, now) {
+  const satisfyingRuns = history.filter((r) => r.taskId === task.id && isSatisfyingRun(r));
+  const fire = previousFireTime(task.schedule, now);
+  if (fire === null) return satisfyingRuns.length === 0;
+  const fireMs = fire.getTime();
+  const satisfied = satisfyingRuns.some((r) => new Date(r.completedAt).getTime() >= fireMs);
+  return !satisfied;
+}
+function selectTasks(tasks, history, filter) {
+  const eligible = tasks.filter((t) => t.excludeFromHumanSweep !== true);
+  switch (filter.mode) {
+    case "all":
+      return eligible;
+    case "ids": {
+      const wanted = new Set(filter.ids ?? []);
+      return eligible.filter((t) => wanted.has(t.id));
+    }
+    case "overdue":
+      return eligible.filter((t) => isOverdue(t, history, filter.now));
+  }
+}
+
 // src/sessions/search-index.ts
-var fs18 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
 var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-var import_types31 = require("@harness-engineering/types");
+var import_types32 = require("@harness-engineering/types");
 var SEARCH_INDEX_FILE = "search-index.sqlite";
 var SCHEMA_SQL2 = `
   CREATE TABLE IF NOT EXISTS session_docs (
@@ -14474,7 +15141,7 @@ var SqliteSearchIndex = class {
   removeSessionStmt;
   totalStmt;
   constructor(dbPath) {
-    fs18.mkdirSync(path22.dirname(dbPath), { recursive: true });
+    fs16.mkdirSync(path22.dirname(dbPath), { recursive: true });
     this.db = new import_better_sqlite32.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
@@ -14574,18 +15241,18 @@ function openSearchIndex(projectPath) {
   return new SqliteSearchIndex(searchIndexPath(projectPath));
 }
 function indexSessionDirectory(idx, args) {
-  const kinds = args.fileKinds ?? [...import_types31.INDEXED_FILE_KINDS];
+  const kinds = args.fileKinds ?? [...import_types32.INDEXED_FILE_KINDS];
   const cap = args.maxBytesPerBody ?? 256 * 1024;
   let docsWritten = 0;
   for (const kind of kinds) {
     const fileName = FILE_KIND_TO_FILENAME[kind];
     const filePath = path22.join(args.sessionDir, fileName);
-    if (!fs18.existsSync(filePath)) continue;
-    let body = fs18.readFileSync(filePath, "utf8");
+    if (!fs16.existsSync(filePath)) continue;
+    let body = fs16.readFileSync(filePath, "utf8");
     if (Buffer.byteLength(body, "utf8") > cap) {
       body = body.slice(0, cap) + "\n\n[TRUNCATED]";
     }
-    const stat = fs18.statSync(filePath);
+    const stat = fs16.statSync(filePath);
     const relPath = path22.relative(args.projectPath, filePath).replaceAll("\\", "/");
     idx.upsertSessionDoc({
       sessionId: args.sessionId,
@@ -14607,8 +15274,8 @@ function reindexFromArchive(projectPath, opts = {}) {
     idx.resetArchived();
     let sessionsIndexed = 0;
     let docsWritten = 0;
-    if (fs18.existsSync(archiveBase)) {
-      const entries = fs18.readdirSync(archiveBase, { withFileTypes: true });
+    if (fs16.existsSync(archiveBase)) {
+      const entries = fs16.readdirSync(archiveBase, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const sessionDir = path22.join(archiveBase, entry.name);
@@ -14631,10 +15298,10 @@ function reindexFromArchive(projectPath, opts = {}) {
 }
 
 // src/sessions/summarize.ts
-var fs19 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
-var import_types32 = require("@harness-engineering/types");
 var import_types33 = require("@harness-engineering/types");
+var import_types34 = require("@harness-engineering/types");
 var LLM_SUMMARY_FILE = "llm-summary.md";
 var SUMMARY_INPUT_FILES = [
   { filename: "summary.md", kind: "summary" },
@@ -14661,9 +15328,9 @@ function readInputCorpus(archiveDir) {
   const parts = [];
   for (const { filename, kind } of SUMMARY_INPUT_FILES) {
     const p = path23.join(archiveDir, filename);
-    if (!fs19.existsSync(p)) continue;
+    if (!fs17.existsSync(p)) continue;
     try {
-      const content = fs19.readFileSync(p, "utf8");
+      const content = fs17.readFileSync(p, "utf8");
       if (content.trim().length === 0) continue;
       parts.push(`## FILE: ${kind}
 
@@ -14725,17 +15392,17 @@ status: failed
 
 - reason: ${reason}
 `;
-  fs19.writeFileSync(filePath, body, "utf8");
+  fs17.writeFileSync(filePath, body, "utf8");
   return filePath;
 }
 async function summarizeArchivedSession(ctx) {
   const writeStubOnError = ctx.writeStubOnError ?? true;
-  if (!fs19.existsSync(ctx.archiveDir)) {
-    return (0, import_types33.Err)(new Error(`archive directory not found: ${ctx.archiveDir}`));
+  if (!fs17.existsSync(ctx.archiveDir)) {
+    return (0, import_types34.Err)(new Error(`archive directory not found: ${ctx.archiveDir}`));
   }
   const corpus = readInputCorpus(ctx.archiveDir);
   if (corpus.trim().length === 0) {
-    return (0, import_types33.Err)(new Error(`no summary input files found in ${ctx.archiveDir}`));
+    return (0, import_types34.Err)(new Error(`no summary input files found in ${ctx.archiveDir}`));
   }
   const inputBudgetTokens = ctx.config?.inputBudgetTokens ?? DEFAULT_INPUT_BUDGET_TOKENS;
   const truncated = truncateForBudget(corpus, inputBudgetTokens);
@@ -14744,7 +15411,7 @@ async function summarizeArchivedSession(ctx) {
   const analyzeOpts = {
     prompt,
     systemPrompt: SYSTEM_PROMPT,
-    responseSchema: import_types32.SessionSummarySchema,
+    responseSchema: import_types33.SessionSummarySchema,
     ...ctx.config?.model && { model: ctx.config.model }
   };
   let response;
@@ -14768,11 +15435,11 @@ async function summarizeArchivedSession(ctx) {
       } catch {
       }
     }
-    return (0, import_types33.Err)(
+    return (0, import_types34.Err)(
       new Error(`session summary failed: ${reason}` + (stubPath ? ` (stub: ${stubPath})` : ""))
     );
   }
-  const parsed = import_types32.SessionSummarySchema.safeParse(response.result);
+  const parsed = import_types33.SessionSummarySchema.safeParse(response.result);
   if (!parsed.success) {
     const reason = `schema validation failed: ${parsed.error.message}`;
     ctx.logger?.warn?.("session summary: invalid provider payload", { reason });
@@ -14782,7 +15449,7 @@ async function summarizeArchivedSession(ctx) {
       } catch {
       }
     }
-    return (0, import_types33.Err)(new Error(reason));
+    return (0, import_types34.Err)(new Error(reason));
   }
   const meta = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14793,8 +15460,8 @@ async function summarizeArchivedSession(ctx) {
   };
   const filePath = path23.join(ctx.archiveDir, LLM_SUMMARY_FILE);
   const body = renderLlmSummaryMarkdown(parsed.data, meta);
-  fs19.writeFileSync(filePath, body, "utf8");
-  return (0, import_types33.Ok)({ summary: parsed.data, meta, filePath });
+  fs17.writeFileSync(filePath, body, "utf8");
+  return (0, import_types34.Ok)({ summary: parsed.data, meta, filePath });
 }
 function isSummaryEnabled(config) {
   if (!config) return false;
@@ -14874,13 +15541,18 @@ function buildArchiveHooks(opts) {
   BUILT_IN_TASKS,
   BackendDefSchema,
   BackendRouter,
+  CheckScriptRunner,
   ClaimManager,
   GateNotReadyError,
   GateRunError,
   InteractionQueue,
+  LinearGraphQLClient,
   LinearGraphQLStub,
   LocalModelResolver,
+  MAINTENANCE_CHECK_MAX_BUFFER,
+  MAINTENANCE_CHECK_TIMEOUT_MS,
   MAX_ATTEMPTS,
+  MaintenanceReporter,
   MockBackend,
   ORCHESTRATOR_IDENTITY_FILE,
   Orchestrator,
@@ -14898,6 +15570,7 @@ function buildArchiveHooks(opts) {
   SqliteSearchIndex,
   StreamRecorder,
   TaskOutputStore,
+  TaskRunner,
   TokenStore,
   WebhookQueue,
   WorkflowLoader,
@@ -14908,7 +15581,9 @@ function buildArchiveHooks(opts) {
   buildArchiveHooks,
   calculateRetryDelay,
   canDispatch,
+  classifyCheckExecutionFailure,
   computeRateLimitDelay,
+  createAgentDispatcher,
   createBackend,
   createEmptyState,
   crossFieldRoutingIssues,
@@ -14920,22 +15595,27 @@ function buildArchiveHooks(opts) {
   emitProposalApproved,
   emitProposalCreated,
   emitProposalRejected,
+  explicitFindingsCount,
   extractHighlights,
   extractTitlePrefix,
   getAvailableSlots,
   getDefaultConfig,
   getPerStateCount,
   indexSessionDirectory,
+  isCheckTimeoutError,
   isEligible,
   isSummaryEnabled,
   launchTUI,
   loadPublishedIndex,
+  makeBackendResolver,
   migrateAgentConfig,
   normalizeFts5Query,
+  normalizeHarnessCommand,
   normalizeLocalModel,
   openSearchIndex,
   promote,
   reconcile,
+  recoverFindingsCount,
   reindexFromArchive,
   renderAnalysisComment,
   renderLlmSummaryMarkdown,
@@ -14945,9 +15625,11 @@ function buildArchiveHooks(opts) {
   routeIssue,
   routingWarnings,
   runGate,
+  runHarnessCheck,
   savePublishedIndex,
   searchIndexPath,
   selectCandidates,
+  selectTasks,
   sortCandidates,
   summarizeArchivedSession,
   syncMain,