@xdevops/issue-auto-finish 1.0.85 → 1.0.87

package/dist/{chunk-K2OTLYJI.js → chunk-QZZGIZWC.js}

@@ -1,16 +1,19 @@
 import {
   BraindumpOrchestrator,
   BraindumpTracker
-} from "./chunk-4QV6D34Y.js";
+} from "./chunk-M5C2WILQ.js";
 import {
   createSetupRouter
-} from "./chunk-HOFYJEJ4.js";
+} from "./chunk-UBQLXQ7I.js";
 import {
   buildLockNoteBody,
   buildReleaseNoteBody,
   findAllLockNotes,
   findLockNote
 } from "./chunk-GXFG4JU6.js";
+import {
+  TerminalManager
+} from "./chunk-KC5S66OZ.js";
 import {
   BrainstormService,
   GongfengClient,
@@ -33,7 +36,7 @@ import {
   setE2eOverride,
   setNoteSyncOverride,
   validatePhaseRegistry
-} from "./chunk-5UPYA6KH.js";
+} from "./chunk-IP3QTP5A.js";
 import {
   AsyncMutex,
   BaseTracker,
@@ -42,12 +45,15 @@ import {
   getExternalId,
   getIid,
   getTitle
-} from "./chunk-P4O4ZXEC.js";
+} from "./chunk-2YQHKXLL.js";
 import {
   IwikiImporter,
   getProjectKnowledge,
   loadKnowledge
 } from "./chunk-ACVOOHAR.js";
+import {
+  collectStaticInfo
+} from "./chunk-B7TVVODN.js";
 import {
   setLocale,
   t
@@ -55,23 +61,15 @@ import {
 import {
   loadConfig,
   reloadConfig
-} from "./chunk-FWEW5E3B.js";
+} from "./chunk-NZHKAPU6.js";
 import {
   resolveDisplayHost
 } from "./chunk-AKXDQH25.js";
-import {
-  collectStaticInfo
-} from "./chunk-B7TVVODN.js";
 import {
   ensureDir,
   resolveDataDir
 } from "./chunk-TN2SYADO.js";
 import {
-  KnowledgeStore
-} from "./chunk-DAX3FD2O.js";
-import {
-  SessionLimitError,
-  SessionNotFoundError,
   createAIRunner,
   getDefaultBinary,
   isBinaryAvailable,
@@ -80,7 +78,14 @@ import {
   resolveModelForRunner,
   setShuttingDown,
   validateRunnerRegistry
-} from "./chunk-4LFNFRCL.js";
+} from "./chunk-SAMTXC4A.js";
+import {
+  SessionLimitError,
+  SessionNotFoundError
+} from "./chunk-AVGZH64A.js";
+import {
+  KnowledgeStore
+} from "./chunk-DAX3FD2O.js";
 import {
   logger
 } from "./chunk-GF2RRYHB.js";
@@ -170,6 +175,7 @@ ${sections.join("\n\n")}`;
 };
 
 // src/poller/IssuePoller.ts
+import crypto from "crypto";
 var logger3 = logger.child("IssuePoller");
 var AUTO_FINISH_LABEL = "auto-finish";
 var AUTO_APPROVE_CHECK_INTERVAL_MS = 3e4;
@@ -225,6 +231,7 @@ var IssuePoller = class {
       this.activeIssues.delete(issueIid);
       logger3.info("Force-released issue from activeIssues", { issueIid });
     }
+    this.tracker.clearProcessingLock(issueIid);
     return had;
   }
   pauseDiscovery() {
@@ -287,8 +294,14 @@ var IssuePoller = class {
       max: maxConcurrent
     });
     for (const record of batch) {
-      this.activeIssues.add(getIid(record));
-      this.processInBackground(record);
+      const iid = getIid(record);
+      const correlationId = crypto.randomUUID();
+      if (!this.tracker.acquireProcessingLock(iid, correlationId)) {
+        logger3.warn("Failed to acquire processing lock, skipping", { issueIid: iid });
+        continue;
+      }
+      this.activeIssues.add(iid);
+      this.processInBackground(record, correlationId);
     }
   }
   maybeAutoApproveWaiting() {
@@ -331,7 +344,7 @@ var IssuePoller = class {
       }
     }
   }
-  async processInBackground(record) {
+  async processInBackground(record, correlationId) {
     const iid = getIid(record);
     try {
       const issue = await this.resolveIssue(getExternalId(record));
@@ -367,6 +380,7 @@ var IssuePoller = class {
       });
     } finally {
       this.activeIssues.delete(iid);
+      this.tracker.releaseProcessingLock(iid, correlationId);
     }
   }
   async resolveIssue(issueId) {
@@ -681,7 +695,7 @@ function generateNodeId() {
 }
 
 // src/web/WebServer.ts
-import express12 from "express";
+import express13 from "express";
 import fs6 from "fs";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -869,7 +883,7 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
       res.status(404).json({ error: "Issue not found" });
       return;
     }
-    const progress = await readProgress(iid, cfg, tracker, git);
+    const progress = record.phaseProgress ? { phases: record.phaseProgress, currentPhase: record.currentPhase } : await readProgress(iid, cfg, tracker, git);
     const preview = buildPreviewInfo(iid, orch);
     res.json({ ...record, progress, preview });
   });
@@ -898,6 +912,11 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
       return;
     }
     if (filename.endsWith(".json")) {
+      if (req.query.format === "html") {
+        const html = await marked("```json\n" + JSON.stringify(JSON.parse(content), null, 2) + "\n```");
+        res.type("html").send(html);
+        return;
+      }
       res.json(JSON.parse(content));
       return;
     }
@@ -957,8 +976,8 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
           await claimer.releaseClaim(getExternalId(record), iid, "cancelled");
         }
       }
-      poller?.forceReleaseIssue(iid);
       await orch.restartIssue(iid);
+      poller?.forceReleaseIssue(iid);
       res.json({ success: true, message: `Issue #${iid} restarted` });
     } catch (err) {
       const msg = err.message;
@@ -977,6 +996,7 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
       return;
     }
     try {
+      poller?.forceReleaseIssue(iid);
       orch.retryFromPhase(iid, phase);
       res.json({ success: true, message: `Issue #${iid} reset to phase: ${phase}` });
     } catch (err) {
@@ -1390,7 +1410,7 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
   });
   router.put("/api/system/feature-toggle", (req, res) => {
     const { feature, enabled } = req.body;
-    const validFeatures = ["brainstorm", "chat", "braindump", "knowledge", "distill"];
+    const validFeatures = ["brainstorm", "chat", "braindump", "knowledge", "distill", "terminal"];
     if (!feature || !validFeatures.includes(feature) || typeof enabled !== "boolean") {
       res.status(400).json({ error: "Invalid feature or enabled value" });
       return;
@@ -1440,6 +1460,8 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
         braindumpEnabled: getFeatureEnabled("braindump", cfg),
         knowledgeEnabled: getFeatureEnabled("knowledge", cfg),
         distillEnabled: getFeatureEnabled("distill", cfg),
+        terminalEnabled: getFeatureEnabled("terminal", cfg),
+        terminalWorkDir: cfg.project.workDir,
         knowledgeSyncEnabled: true,
         multiRepoEnabled: wsConfig ? isMultiRepo(wsConfig) : false,
         linkedRepos: wsConfig?.associates.map((a) => ({
@@ -1706,7 +1728,7 @@ data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
       const scenariosDir = path3.join(outputsDir, "scenarios");
       let scenarios = [];
       if (fs3.existsSync(scenariosDir) && fs3.statSync(scenariosDir).isDirectory()) {
-        scenarios = collectArtifactFiles(scenariosDir, scenariosDir);
+        scenarios = collectArtifactFiles(scenariosDir, scenariosDir).filter((f) => !f.name.startsWith("config.") && !f.name.startsWith("config-"));
       }
       res.json({ configured: true, runs, scenarios });
     } catch (err) {
@@ -2404,7 +2426,7 @@ function createKnowledgeRouter(deps) {
         heartbeat = setInterval(() => {
           sendProgress({ step: "analyzing", current: 2, total, message: "AI \u5206\u6790\u4E2D...", elapsed: Date.now() - aiStart });
         }, 3e3);
-        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-SVUNA3FX.js");
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-HLA44WI6.js");
         const runner = createAIRunner2(config.ai);
         const { analyze } = await import("./KnowledgeAnalyzer-MTTTSSHX.js");
         const knowledge = await analyze({ workDir, aiRunner: runner, syncToProject: config.sync.knowledgeToProject });
@@ -2449,7 +2471,7 @@ function createKnowledgeRouter(deps) {
     (async () => {
       try {
         sendProgress({ step: "collecting", current: 1, total, message: "\u68C0\u6D4B\u53D8\u66F4\u5E76\u6536\u96C6\u4FE1\u606F..." });
-        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-SVUNA3FX.js");
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-HLA44WI6.js");
         const { analyzeIncremental } = await import("./KnowledgeAnalyzer-MTTTSSHX.js");
         const runner = createAIRunner2(config.ai);
         sendProgress({ step: "analyzing", current: 2, total, message: "\u589E\u91CF\u5206\u6790\u4E2D..." });
@@ -2733,7 +2755,7 @@ function createDomainModelRouter(deps) {
     }
     (async () => {
       try {
-        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-SVUNA3FX.js");
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-HLA44WI6.js");
         const runner = createAIRunner2(config.ai);
         const model = await analyzer.analyze({
           workDir: config.project.workDir,
@@ -2947,7 +2969,7 @@ function createSystemUseCaseRouter(deps) {
     }
     (async () => {
       try {
-        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-SVUNA3FX.js");
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-HLA44WI6.js");
         const runner = createAIRunner2(config.ai);
         const model = await analyzer.analyze({
           workDir: config.project.workDir,
@@ -3137,7 +3159,7 @@ function createSystemUseCaseRouter(deps) {
         res.status(404).json({ error: "No domain model loaded \u2014 run domain analysis first" });
         return;
       }
-      const { createAIRunner: createAIRunner2 } = await import("./ai-runner-SVUNA3FX.js");
+      const { createAIRunner: createAIRunner2 } = await import("./ai-runner-HLA44WI6.js");
       const runner = createAIRunner2(config.ai);
       const associations = await analyzer.suggestDomainAssociations(
         useCaseModel,
@@ -3968,6 +3990,79 @@ function createAnalyticsRouter(deps) {
   return router;
 }
 
+// src/web/routes/terminal.ts
+import express12 from "express";
+var { Router: Router12 } = express12;
+var logger21 = logger.child("TerminalRoutes");
+function createTerminalRouter(deps) {
+  const router = Router12();
+  const { terminalManager, config } = deps;
+  router.use("/api/terminal", (_req, res, next) => {
+    if (!getFeatureEnabled("terminal", config)) {
+      res.status(503).json({ error: "Terminal feature is disabled" });
+      return;
+    }
+    next();
+  });
+  router.get("/api/terminal/sessions", (_req, res) => {
+    try {
+      const sessions = terminalManager.list();
+      res.json({ success: true, sessions });
+    } catch (err) {
+      logger21.error("Failed to list terminal sessions", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/api/terminal/sessions", (req, res) => {
+    try {
+      const { workDir, issueIid, cols, rows } = req.body;
+      if (!workDir?.trim()) {
+        res.status(400).json({ error: "workDir is required" });
+        return;
+      }
+      const session = terminalManager.create({
+        workDir: workDir.trim(),
+        issueIid,
+        cols,
+        rows
+      });
+      res.json({ success: true, session });
+    } catch (err) {
+      logger21.error("Failed to create terminal session", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/terminal/sessions/by-issue/:iid", (req, res) => {
+    try {
+      const iid = parseInt(req.params.iid, 10);
+      if (isNaN(iid)) {
+        res.status(400).json({ error: "Invalid issue IID" });
+        return;
+      }
+      const sessions = terminalManager.list().filter((s) => s.issueIid === iid);
+      res.json({ success: true, sessions });
+    } catch (err) {
+      logger21.error("Failed to find terminal sessions by issue", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.delete("/api/terminal/sessions/:id", (req, res) => {
+    try {
+      const session = terminalManager.get(req.params.id);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      terminalManager.destroy(req.params.id);
+      res.json({ success: true });
+    } catch (err) {
+      logger21.error("Failed to destroy terminal session", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  return router;
+}
+
 // src/knowledge/DomainModelAnalyzer.ts
 import fs5 from "fs";
 import path6 from "path";
@@ -4097,7 +4192,7 @@ ${feedback}
 }
 
 // src/knowledge/DomainModelAnalyzer.ts
-var logger21 = logger.child("DomainModelAnalyzer");
+var logger22 = logger.child("DomainModelAnalyzer");
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -4314,7 +4409,7 @@ var DomainModelAnalyzer = class {
     }
     this.currentModel = model;
     emit({ type: "complete", data: model });
-    logger21.info("Domain model analysis complete", {
+    logger22.info("Domain model analysis complete", {
       contexts: model.boundedContexts.length,
       elements: model.elements.length,
       relationships: model.relationships.length
@@ -4340,7 +4435,7 @@ var DomainModelAnalyzer = class {
         tags: ["domain-model", "auto-generated"]
       });
     }
-    logger21.info("Domain model confirmed to knowledge store");
+    logger22.info("Domain model confirmed to knowledge store");
   }
   /**
    * Load a previously stored domain model from KnowledgeStore.
@@ -4355,7 +4450,7 @@ var DomainModelAnalyzer = class {
       this.currentModel = model;
       return model;
     } catch {
-      logger21.warn("Failed to parse stored domain model");
+      logger22.warn("Failed to parse stored domain model");
       return null;
     }
   }
@@ -4579,7 +4674,7 @@ ${domainModelJson}
 }
 
 // src/knowledge/SystemUseCaseAnalyzer.ts
-var logger22 = logger.child("SystemUseCaseAnalyzer");
+var logger23 = logger.child("SystemUseCaseAnalyzer");
 function parseJsonFromOutput2(output) {
   const jsonBlockMatch = output.match(/```json\s*\n([\s\S]*?)```/);
   if (jsonBlockMatch) {
@@ -4704,7 +4799,7 @@ var SystemUseCaseAnalyzer = class {
     }
     this.currentModel = model;
     emit({ type: "complete", data: model });
-    logger22.info("Use case analysis complete", {
+    logger23.info("Use case analysis complete", {
       useCases: model.useCases.length,
       relationships: model.relationships.length
     });
@@ -4725,12 +4820,12 @@ var SystemUseCaseAnalyzer = class {
     });
     const associations = /* @__PURE__ */ new Map();
     if (!result.success) {
-      logger22.warn("AI domain association failed", { output: result.output.slice(0, 200) });
+      logger23.warn("AI domain association failed", { output: result.output.slice(0, 200) });
       return associations;
     }
     const parsed = parseJsonFromOutput2(result.output);
     if (!parsed || !parsed.associations) {
-      logger22.warn("Failed to parse domain association output");
+      logger23.warn("Failed to parse domain association output");
       return associations;
     }
     const rawAssociations = parsed.associations;
@@ -4760,7 +4855,7 @@ var SystemUseCaseAnalyzer = class {
         tags: ["system-usecase", "auto-generated"]
       });
     }
-    logger22.info("Use case model confirmed to knowledge store");
+    logger23.info("Use case model confirmed to knowledge store");
   }
   /**
    * Load a previously stored use case model from KnowledgeStore.
@@ -4775,7 +4870,7 @@ var SystemUseCaseAnalyzer = class {
       this.currentModel = model;
       return model;
     } catch {
-      logger22.warn("Failed to parse stored use case model");
+      logger23.warn("Failed to parse stored use case model");
       return null;
     }
   }
@@ -4842,7 +4937,7 @@ ${knowledgeSection}${entriesSection}
 }
 
 // src/services/ChatService.ts
-var logger23 = logger.child("Chat");
+var logger24 = logger.child("Chat");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -4878,7 +4973,7 @@ var ChatService = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger23.info("Created chat session", { sessionId: session.id });
+    logger24.info("Created chat session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -4923,7 +5018,7 @@ var ChatService = class {
 ${r.content.slice(0, 500)}`).join("\n\n");
           }
         } catch (err) {
-          logger23.debug("Vector search failed, continuing without", { error: err.message });
+          logger24.debug("Vector search failed, continuing without", { error: err.message });
         }
       }
       const prompt = isFirstMessage ? `${buildChatSystemPrompt(getProjectKnowledge(), knowledgeEntries)}${vectorContext}
@@ -5004,14 +5099,108 @@ ${r.content.slice(0, 500)}`).join("\n\n");
   }
 };
 
+// src/terminal/TerminalWebSocket.ts
+import { WebSocketServer, WebSocket } from "ws";
+var logger25 = logger.child("TerminalWebSocket");
+function setupTerminalWebSocket(opts) {
+  const { httpServer, terminalManager, isEnabled } = opts;
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+    if (!url.pathname.startsWith("/ws/terminal")) return;
+    if (!isEnabled()) {
+      socket.write("HTTP/1.1 503 Service Unavailable\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit("connection", ws, request);
+    });
+  });
+  wss.on("connection", (ws, request) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+    let sessionId = null;
+    try {
+      if (url.pathname === "/ws/terminal/new") {
+        const workDir = url.searchParams.get("workDir") ?? "";
+        const issueIidStr = url.searchParams.get("issueIid");
+        const issueIid = issueIidStr ? parseInt(issueIidStr, 10) : void 0;
+        if (!workDir) {
+          ws.close(1008, "workDir is required");
+          return;
+        }
+        const info = terminalManager.create({
+          workDir,
+          issueIid: issueIid && !isNaN(issueIid) ? issueIid : void 0
+        });
+        sessionId = info.id;
+        ws.send(JSON.stringify({ type: "session", sessionId: info.id }));
+      } else {
+        sessionId = url.searchParams.get("sessionId");
+        if (!sessionId || !terminalManager.get(sessionId)) {
+          ws.close(1008, "Invalid or missing sessionId");
+          return;
+        }
+      }
+      terminalManager.onData(sessionId, (data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+          try {
+            ws.send(data);
+          } catch {
+          }
+        }
+      });
+      terminalManager.onExit(sessionId, () => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.close(1e3, "PTY process exited");
+        }
+      });
+      ws.on("message", (msg) => {
+        if (!sessionId) return;
+        const str = msg.toString();
+        try {
+          const parsed = JSON.parse(str);
+          if (parsed.type === "resize" && parsed.cols && parsed.rows) {
+            terminalManager.resize(sessionId, parsed.cols, parsed.rows);
+            return;
+          }
+        } catch {
+        }
+        terminalManager.write(sessionId, str);
+      });
+      ws.on("close", () => {
+        if (sessionId) {
+          const session = terminalManager.get(sessionId);
+          if (session?.managed) {
+            logger25.info("WebSocket detached from managed session (kept alive)", { sessionId });
+          } else {
+            logger25.info("WebSocket closed, destroying terminal session", { sessionId });
+            terminalManager.destroy(sessionId);
+          }
+        }
+      });
+      ws.on("error", (err) => {
+        logger25.warn("Terminal WebSocket error", { sessionId, error: err.message });
+      });
+      logger25.info("Terminal WebSocket connected", { sessionId });
+    } catch (err) {
+      logger25.error("Failed to handle terminal WebSocket connection", { error: err.message });
+      ws.close(1011, err.message);
+    }
+  });
+  logger25.info("Terminal WebSocket handler registered");
+}
+
 // src/web/WebServer.ts
 var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
-var logger24 = logger.child("WebServer");
+var logger26 = logger.child("WebServer");
 var WebServer = class _WebServer {
   app;
   server = null;
   host;
   port;
+  terminalManager;
+  config;
   constructor(trackerOrDeps, config, agentLogStore, orchestrator, mainGit) {
     let apiDeps;
     if (trackerOrDeps instanceof IssueTracker) {
@@ -5049,8 +5238,18 @@ var WebServer = class _WebServer {
         previewReaper: deps.previewReaper
       };
     }
-    this.app = express12();
-    this.app.use(express12.json());
+    this.app = express13();
+    this.app.use(express13.json());
+    const resolvedConfig = trackerOrDeps instanceof IssueTracker ? config : trackerOrDeps.config;
+    this.config = resolvedConfig;
+    this.terminalManager = (trackerOrDeps instanceof IssueTracker ? void 0 : trackerOrDeps.terminalManager) ?? new TerminalManager({
+      idleTimeoutMs: resolvedConfig.terminal.idleTimeoutMs,
+      maxSessions: resolvedConfig.terminal.maxSessions,
+      allowedBaseDirs: [
+        resolvedConfig.project.worktreeBaseDir ?? resolvedConfig.project.workDir,
+        resolvedConfig.project.workDir
+      ].filter(Boolean)
+    });
     this.app.get("/metrics", (_req, res) => {
       res.set("Content-Type", "text/plain; version=0.0.4; charset=utf-8");
       res.send(metrics.serialize());
@@ -5074,12 +5273,12 @@ var WebServer = class _WebServer {
     if (fs6.existsSync(projectKnowledgeIndex) && !fs6.existsSync(globalKnowledgeIndex)) {
       try {
         _WebServer.migrateKnowledgeDir(projectKnowledgeDir, globalKnowledgeDataDir);
-        logger24.info("Migrated knowledge entries from project to global DATA_DIR", {
+        logger26.info("Migrated knowledge entries from project to global DATA_DIR", {
           src: projectKnowledgeDir,
           dest: globalKnowledgeDataDir
         });
       } catch (err) {
-        logger24.warn("Failed to migrate knowledge entries to global DATA_DIR", {
+        logger26.warn("Failed to migrate knowledge entries to global DATA_DIR", {
           error: err.message
         });
       }
@@ -5097,12 +5296,12 @@ var WebServer = class _WebServer {
     if (fs6.existsSync(legacyKnowledgePath) && !fs6.existsSync(dataDirKnowledgePath)) {
       try {
         fs6.copyFileSync(legacyKnowledgePath, dataDirKnowledgePath);
-        logger24.info("Migrated knowledge.json from project to DATA_DIR", {
+        logger26.info("Migrated knowledge.json from project to DATA_DIR", {
           src: legacyKnowledgePath,
           dest: dataDirKnowledgePath
         });
       } catch (err) {
-        logger24.warn("Failed to migrate knowledge.json to DATA_DIR", {
+        logger26.warn("Failed to migrate knowledge.json to DATA_DIR", {
           error: err.message
         });
       }
@@ -5159,8 +5358,13 @@ var WebServer = class _WebServer {
       });
       this.app.use(analyticsRouter);
     }
+    const terminalRouter = createTerminalRouter({
+      terminalManager: this.terminalManager,
+      config: apiDeps.config
+    });
+    this.app.use(terminalRouter);
     const publicDir = apiDeps.config.web.frontendDistDir;
-    this.app.use(express12.static(publicDir));
+    this.app.use(express13.static(publicDir));
     this.app.get("/{*splat}", (_req, res) => {
       res.sendFile("index.html", { root: publicDir });
     });
@@ -5168,16 +5372,22 @@ var WebServer = class _WebServer {
   start() {
     return new Promise((resolve) => {
       this.server = this.app.listen(this.port, this.host, () => {
-        logger24.info(`Web UI available at http://${resolveDisplayHost(this.host)}:${this.port}`);
+        setupTerminalWebSocket({
+          httpServer: this.server,
+          terminalManager: this.terminalManager,
+          isEnabled: () => getFeatureEnabled("terminal", this.config)
+        });
+        logger26.info(`Web UI available at http://${resolveDisplayHost(this.host)}:${this.port}`);
         resolve();
       });
     });
   }
   stop() {
+    this.terminalManager.destroyAll();
     if (this.server) {
       this.server.close();
       this.server = null;
-      logger24.info("Web server stopped");
+      logger26.info("Web server stopped");
     }
   }
   /**
@@ -5213,10 +5423,10 @@ var WebServer = class _WebServer {
 };
 
 // src/webhook/WebhookServer.ts
-import express14 from "express";
+import express15 from "express";
 
 // src/webhook/WebhookHandler.ts
-import express13 from "express";
+import express14 from "express";
 
 // src/webhook/CommandParser.ts
 var TRIGGERS = ["@issue-auto", "@iaf"];
@@ -5419,7 +5629,7 @@ function parseExact(commandText) {
 // src/webhook/CommandExecutor.ts
 import path9 from "path";
 import fs7 from "fs";
-var logger25 = logger.child("CommandExecutor");
+var logger27 = logger.child("CommandExecutor");
 var CommandExecutor = class {
   tracker;
   orchestrator;
@@ -5438,13 +5648,13 @@ var CommandExecutor = class {
     this.claimer = deps.claimer;
   }
   async execute(issueIid, issueId, command) {
-    logger25.info("Executing webhook command", { issueIid, command });
+    logger27.info("Executing webhook command", { issueIid, command });
     let result;
     try {
       result = await this.dispatch(issueIid, command);
     } catch (err) {
       const msg = err.message;
-      logger25.error("Webhook command failed", { issueIid, error: msg });
+      logger27.error("Webhook command failed", { issueIid, error: msg });
       result = { success: false, message: msg };
     }
     await this.replyToIssue(issueId, result);
@@ -5502,6 +5712,7 @@ var CommandExecutor = class {
     if (!phase) return this.fail("Phase is required for retry-from (e.g. design, implement)");
     if (ctx) this.saveSupplement(iid, ctx);
     try {
+      this.poller?.forceReleaseIssue(iid);
       this.orchestrator.retryFromPhase(iid, phase);
     } catch (err) {
       return this.fail(err.message);
@@ -5575,7 +5786,6 @@ var CommandExecutor = class {
   }
   async handleRestart(iid) {
     try {
-      this.poller?.forceReleaseIssue(iid);
       if (this.claimer) {
         const record = this.tracker.get(iid);
         if (record) {
@@ -5584,6 +5794,7 @@ var CommandExecutor = class {
         }
       }
       await this.orchestrator.restartIssue(iid);
+      this.poller?.forceReleaseIssue(iid);
     } catch (err) {
       return this.fail(err.message);
     }
@@ -5599,7 +5810,7 @@ var CommandExecutor = class {
           const externalId = getExternalId(record);
           await this.claimer.releaseClaim(externalId, iid, "cancelled");
         } catch (err) {
-          logger25.warn("Failed to release lock on cancel", { iid, error: err.message });
+          logger27.warn("Failed to release lock on cancel", { iid, error: err.message });
         }
       }
       await this.orchestrator.cancelIssue(iid);
@@ -5699,7 +5910,7 @@ var CommandExecutor = class {
       return this.fail(t("conflict.noMr", { iid }));
     }
     this.orchestrator.resolveConflict(iid).catch((err) => {
-      logger25.error("Async conflict resolution failed", { iid, error: err.message });
+      logger27.error("Async conflict resolution failed", { iid, error: err.message });
     });
     return this.ok(t("conflict.startedMsg"));
   }
@@ -5741,7 +5952,7 @@ ${context}` : context;
       const prefix = result.success ? "" : "> **Failed**\n>\n> ";
       await this.gongfeng.createIssueNote(issueId, `${prefix}${result.message}`);
     } catch (err) {
-      logger25.warn("Failed to reply", { issueId, error: err.message });
+      logger27.warn("Failed to reply", { issueId, error: err.message });
     }
   }
   ok(message) {
@@ -5796,10 +6007,10 @@ var NoteDeduplicator = class {
 };
 
 // src/webhook/WebhookHandler.ts
-var { Router: Router12 } = express13;
-var logger26 = logger.child("WebhookHandler");
+var { Router: Router13 } = express14;
+var logger28 = logger.child("WebhookHandler");
 function createWebhookRouter(deps) {
-  const router = Router12();
+  const router = Router13();
   const executor = new CommandExecutor(deps);
   const dedup = new NoteDeduplicator();
   const { config, intentRecognizer } = deps;
@@ -5812,7 +6023,7 @@ function createWebhookRouter(deps) {
     if (config.webhook.secret) {
       const token = req.headers["x-gitlab-token"];
       if (token !== config.webhook.secret) {
-        logger26.warn("Webhook token mismatch");
+        logger28.warn("Webhook token mismatch");
         res.status(401).json({ error: "Invalid token" });
         return;
       }
@@ -5829,7 +6040,7 @@ function createWebhookRouter(deps) {
     }
     const noteId = event.object_attributes.id;
     if (dedup.isDuplicate(noteId)) {
-      logger26.debug("Duplicate note, skipping", { noteId });
+      logger28.debug("Duplicate note, skipping", { noteId });
       res.json({ ignored: true, reason: "duplicate" });
       return;
     }
@@ -5841,7 +6052,7 @@ function createWebhookRouter(deps) {
         return;
       }
       if (!issueId) {
-        logger26.info("Webhook received with null issue id (likely a test ping)", { issueIid });
+        logger28.info("Webhook received with null issue id (likely a test ping)", { issueIid });
         res.json({ accepted: true, noteId, issueIid, test: true });
         return;
       }
@@ -5881,19 +6092,19 @@ async function processCommandAsync(noteBody, issueIid, issueId, executor, intent
     if (!command && intentRecognizer && config.webhook.llmFallback) {
       const record = tracker.get(issueIid);
       const state = record?.state;
-      logger26.info("Falling back to LLM intent recognition", { issueIid });
+      logger28.info("Falling back to LLM intent recognition", { issueIid });
       command = await intentRecognizer.recognize(cmdText, state);
     }
     if (!command) {
-      logger26.info("Could not parse command from note", { issueIid, text: cmdText.slice(0, 100) });
+      logger28.info("Could not parse command from note", { issueIid, text: cmdText.slice(0, 100) });
       await gongfeng.createIssueNote(issueId, HELP_TEXT_FUNC()).catch(
-        (e) => logger26.warn("Failed to reply help text", { error: e.message })
+        (e) => logger28.warn("Failed to reply help text", { error: e.message })
       );
       return;
     }
     await executor.execute(issueIid, issueId, command);
   } catch (err) {
-    logger26.error("Failed to process webhook command", {
+    logger28.error("Failed to process webhook command", {
       issueIid,
       error: err.message
     });
@@ -5913,7 +6124,7 @@ async function processMRCommandAsync(noteBody, mr, executor, tracker, gongfeng)
     const command = parseExact(cmdText);
     if (!command) {
       await gongfeng.createMergeRequestNote(mr.iid, HELP_TEXT_FUNC()).catch(
-        (e) => logger26.warn("Failed to reply help text on MR", { error: e.message })
+        (e) => logger28.warn("Failed to reply help text on MR", { error: e.message })
       );
       return;
     }
@@ -5922,7 +6133,7 @@ async function processMRCommandAsync(noteBody, mr, executor, tracker, gongfeng)
         mr.iid,
         `\`${command.intent}\` command is not supported on MR comments. Please use Issue comments instead.`
       ).catch(
-        (e) => logger26.warn("Failed to reply on MR", { error: e.message })
+        (e) => logger28.warn("Failed to reply on MR", { error: e.message })
       );
       return;
     }
@@ -5933,7 +6144,7 @@ async function processMRCommandAsync(noteBody, mr, executor, tracker, gongfeng)
         mr.iid,
         `Could not find a tracked issue for branch \`${mr.source_branch}\`.`
       ).catch(
-        (e) => logger26.warn("Failed to reply on MR", { error: e.message })
+        (e) => logger28.warn("Failed to reply on MR", { error: e.message })
       );
       return;
     }
@@ -5942,10 +6153,10 @@ async function processMRCommandAsync(noteBody, mr, executor, tracker, gongfeng)
       const prefix = result.success ? "" : "> **Failed**\n>\n> ";
       await gongfeng.createMergeRequestNote(mr.iid, `${prefix}${result.message}`);
     } catch (err) {
-      logger26.warn("Failed to reply on MR", { mrIid: mr.iid, error: err.message });
+      logger28.warn("Failed to reply on MR", { mrIid: mr.iid, error: err.message });
     }
   } catch (err) {
-    logger26.error("Failed to process MR webhook command", {
+    logger28.error("Failed to process MR webhook command", {
       mrIid: mr.iid,
       error: err.message
     });
@@ -5957,7 +6168,7 @@ function isSelfNote(_event, _selfToken) {
 
 // src/webhook/IntentRecognizer.ts
 import { spawn } from "child_process";
-var logger27 = logger.child("IntentRecognizer");
+var logger29 = logger.child("IntentRecognizer");
 var VALID_INTENTS = [
   "retry",
   "retry-from",
@@ -5999,7 +6210,7 @@ ${userComment}`;
       const rawOutput = await this.runLLM(userPrompt);
       return this.parseResponse(rawOutput);
     } catch (err) {
-      logger27.error("Intent recognition failed", { error: err.message });
+      logger29.error("Intent recognition failed", { error: err.message });
       return null;
     }
   }
@@ -6007,20 +6218,20 @@ ${userComment}`;
   parseResponse(raw) {
     const jsonMatch = raw.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
-      logger27.warn("No JSON found in LLM response", { raw: raw.slice(0, 200) });
+      logger29.warn("No JSON found in LLM response", { raw: raw.slice(0, 200) });
       return null;
     }
     let parsed;
     try {
       parsed = JSON.parse(jsonMatch[0]);
     } catch {
-      logger27.warn("Failed to parse JSON from LLM", { raw: jsonMatch[0].slice(0, 200) });
+      logger29.warn("Failed to parse JSON from LLM", { raw: jsonMatch[0].slice(0, 200) });
       return null;
     }
     if (parsed.intent === null || parsed.intent === "null") return null;
     const intent = String(parsed.intent);
     if (!VALID_INTENTS.includes(intent)) {
-      logger27.warn("Invalid intent from LLM", { intent });
+      logger29.warn("Invalid intent from LLM", { intent });
       return null;
     }
     const result = { intent };
@@ -6062,7 +6273,7 @@ ${userComment}`;
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code !== 0) {
-          logger27.warn("LLM process exited with non-zero code", { code, stderr: stderr.slice(0, 300) });
+          logger29.warn("LLM process exited with non-zero code", { code, stderr: stderr.slice(0, 300) });
         }
         resolve(stdout);
       });
@@ -6077,7 +6288,7 @@ ${userComment}`;
 };
 
 // src/webhook/WebhookServer.ts
-var logger28 = logger.child("WebhookServer");
+var logger30 = logger.child("WebhookServer");
 var WebhookServer = class {
   app;
   server = null;
@@ -6101,8 +6312,8 @@ var WebhookServer = class {
       poller: deps.poller,
       claimer: deps.claimer
     };
-    this.app = express14();
-    this.app.use(express14.json());
+    this.app = express15();
+    this.app.use(express15.json());
     this.app.use(createWebhookRouter(handlerDeps));
     this.app.get("/health", (_req, res) => {
       res.json({ status: "ok", service: "webhook" });
@@ -6111,7 +6322,7 @@ var WebhookServer = class {
   start() {
     return new Promise((resolve) => {
       this.server = this.app.listen(this.port, this.host, () => {
-        logger28.info(`Webhook server listening on http://${resolveDisplayHost(this.host)}:${this.port}`);
+        logger30.info(`Webhook server listening on http://${resolveDisplayHost(this.host)}:${this.port}`);
         resolve();
       });
     });
@@ -6120,7 +6331,7 @@ var WebhookServer = class {
     if (this.server) {
       this.server.close();
       this.server = null;
-      logger28.info("Webhook server stopped");
+      logger30.info("Webhook server stopped");
     }
   }
 };
@@ -6128,7 +6339,7 @@ var WebhookServer = class {
 // src/web/AgentLogStore.ts
 import fs8 from "fs";
 import path10 from "path";
-var logger29 = logger.child("AgentLogStore");
+var logger31 = logger.child("AgentLogStore");
 var MAX_LOGS_PER_ISSUE = 2e4;
 var DEBUG_EVENT_TYPES = /* @__PURE__ */ new Set([
   "thinking",
@@ -6157,7 +6368,7 @@ var AgentLogStore = class {
     eventBus.on("pipeline:progress", (payload) => {
       this.handlePipelineProgress(payload);
     });
-    logger29.info("AgentLogStore listening for events");
+    logger31.info("AgentLogStore listening for events");
   }
   getLogs(issueIid) {
     const filePath = this.logFilePath(issueIid);
@@ -6167,7 +6378,7 @@ var AgentLogStore = class {
       if (!raw) return [];
       return raw.split("\n").map((line) => JSON.parse(line));
     } catch (err) {
-      logger29.warn("Failed to read agent logs", { issueIid, error: err.message });
+      logger31.warn("Failed to read agent logs", { issueIid, error: err.message });
       return [];
     }
   }
@@ -6187,7 +6398,7 @@ var AgentLogStore = class {
 `, "utf-8");
       this.trimIfNeeded(issueIid, filePath);
     } catch (err) {
-      logger29.warn("Failed to write agent log", { issueIid, error: err.message });
+      logger31.warn("Failed to write agent log", { issueIid, error: err.message });
     }
   }
   trimIfNeeded(issueIid, filePath) {
@@ -6199,7 +6410,7 @@ var AgentLogStore = class {
         const trimmed = lines.slice(-MAX_LOGS_PER_ISSUE);
         fs8.writeFileSync(filePath, `${trimmed.join("\n")}
 `, "utf-8");
-        logger29.info("Agent logs trimmed", { issueIid, from: lines.length, to: trimmed.length });
+        logger31.info("Agent logs trimmed", { issueIid, from: lines.length, to: trimmed.length });
       }
     } catch {
     }
@@ -6274,7 +6485,7 @@ import { readFileSync, existsSync } from "fs";
 import path11 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = path11.dirname(fileURLToPath3(import.meta.url));
-var logger30 = logger.child("VersionChecker");
+var logger32 = logger.child("VersionChecker");
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
@@ -6305,7 +6516,7 @@ var VersionChecker = class {
   async check() {
     const latestVersion = await this.fetchLatestVersion();
     const hasUpdate = compareSemver(latestVersion, this.currentVersion) > 0;
-    logger30.info("Version check completed", {
+    logger32.info("Version check completed", {
       current: this.currentVersion,
       latest: latestVersion,
       hasUpdate
@@ -6353,7 +6564,7 @@ import { cpSync, existsSync as existsSync2, rmSync } from "fs";
 import path12 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = path12.dirname(fileURLToPath4(import.meta.url));
-var logger31 = logger.child("UpdateExecutor");
+var logger33 = logger.child("UpdateExecutor");
 function findProjectRoot() {
   for (let dir = __dirname4; dir !== path12.dirname(dir); dir = path12.dirname(dir)) {
     if (existsSync2(path12.join(dir, "package.json"))) {
@@ -6383,7 +6594,7 @@ var UpdateExecutor = class {
   async execute(targetVersion) {
     const distDir = path12.join(this.projectRoot, "dist");
     const backupDir = path12.join(this.projectRoot, "dist.backup");
-    logger31.info("Backing up dist directory...");
+    logger33.info("Backing up dist directory...");
     if (existsSync2(backupDir)) {
       rmSync(backupDir, { recursive: true, force: true });
     }
@@ -6391,12 +6602,12 @@ var UpdateExecutor = class {
       cpSync(distDir, backupDir, { recursive: true });
     }
     try {
-      logger31.info("Running package update...", { package: this.packageName, targetVersion, bin: "npm" });
+      logger33.info("Running package update...", { package: this.packageName, targetVersion, bin: "npm" });
       await run("npm", ["update", this.packageName], this.projectRoot, 12e4);
-      logger31.info("Running build...", { bin: "npm" });
+      logger33.info("Running build...", { bin: "npm" });
       await run("npm", ["run", "build"], this.projectRoot, 12e4);
     } catch (err) {
-      logger31.error("Update failed, rolling back dist...", { error: err.message });
+      logger33.error("Update failed, rolling back dist...", { error: err.message });
       if (existsSync2(backupDir)) {
         if (existsSync2(distDir)) {
           rmSync(distDir, { recursive: true, force: true });
@@ -6409,21 +6620,21 @@ var UpdateExecutor = class {
         rmSync(backupDir, { recursive: true, force: true });
       }
     }
-    logger31.info("Reloading via PM2...");
+    logger33.info("Reloading via PM2...");
     try {
       await run("pm2", ["reload", "issue-auto-finish"], this.projectRoot, 3e4);
     } catch (err) {
-      logger31.warn("PM2 reload failed, the process may need manual restart", {
+      logger33.warn("PM2 reload failed, the process may need manual restart", {
         error: err.message
       });
       throw err;
     }
-    logger31.info("Update completed successfully", { version: targetVersion });
+    logger33.info("Update completed successfully", { version: targetVersion });
   }
 };
 
 // src/updater/AutoUpdater.ts
-var logger32 = logger.child("AutoUpdater");
+var logger34 = logger.child("AutoUpdater");
 var INITIAL_DELAY_MS = 3e4;
 var AutoUpdater = class {
   config;
@@ -6445,10 +6656,10 @@ var AutoUpdater = class {
   }
   start() {
     if (!this.config.autoUpdate.enabled) {
-      logger32.info("Auto-update is disabled");
+      logger34.info("Auto-update is disabled");
       return;
     }
-    logger32.info("Auto-updater starting", {
+    logger34.info("Auto-updater starting", {
       intervalMs: this.config.autoUpdate.intervalMs,
       registry: this.config.autoUpdate.registry
     });
@@ -6467,7 +6678,7 @@ var AutoUpdater = class {
       clearInterval(this.checkTimer);
       this.checkTimer = null;
     }
-    logger32.info("Auto-updater stopped");
+    logger34.info("Auto-updater stopped");
   }
   getStatus() {
     return {
@@ -6507,7 +6718,7 @@ var AutoUpdater = class {
   }
   async triggerUpdate() {
     if (this.updateInProgress) {
-      logger32.warn("Update already in progress, skipping");
+      logger34.warn("Update already in progress, skipping");
       return;
     }
     this.updateInProgress = true;
@@ -6515,40 +6726,40 @@ var AutoUpdater = class {
       if (!this.latestVersion) {
         const result = await this.checkForUpdate();
         if (!result.hasUpdate) {
-          logger32.info("No update available");
+          logger34.info("No update available");
           return;
         }
       }
       const targetVersion = this.latestVersion;
       this.state = "draining";
-      logger32.info("Draining active issues before update...");
+      logger34.info("Draining active issues before update...");
       this.poller.pauseDiscovery();
       const drainStart = Date.now();
       const drainTimeout = this.config.autoUpdate.drainTimeoutMs;
       while (this.poller.getActiveCount() > 0 && Date.now() - drainStart < drainTimeout) {
-        logger32.info("Waiting for active issues to complete...", {
+        logger34.info("Waiting for active issues to complete...", {
           active: this.poller.getActiveCount()
         });
         await new Promise((resolve) => setTimeout(resolve, 5e3));
       }
       if (this.poller.getActiveCount() > 0) {
-        logger32.warn("Drain timeout reached, proceeding with update", {
+        logger34.warn("Drain timeout reached, proceeding with update", {
           active: this.poller.getActiveCount()
         });
       }
       this.state = "updating";
       eventBus.emitTyped("update:downloading", { version: targetVersion });
-      logger32.info("Executing update...", { targetVersion });
+      logger34.info("Executing update...", { targetVersion });
       await this.updateExecutor.execute(targetVersion);
       this.state = "completed";
       eventBus.emitTyped("update:completed", { version: targetVersion });
-      logger32.info("Update completed", { version: targetVersion });
+      logger34.info("Update completed", { version: targetVersion });
     } catch (err) {
       const message = err.message;
       this.lastError = message;
       this.state = "failed";
       eventBus.emitTyped("update:failed", { error: message });
-      logger32.error("Update failed", { error: message });
+      logger34.error("Update failed", { error: message });
       this.poller.resumeDiscovery();
     } finally {
       this.updateInProgress = false;
@@ -6559,20 +6770,20 @@ var AutoUpdater = class {
     try {
       const result = await this.checkForUpdate();
       if (result.hasUpdate) {
-        logger32.info("New version available, starting update", {
+        logger34.info("New version available, starting update", {
           current: result.currentVersion,
           latest: result.latestVersion
         });
         await this.triggerUpdate();
       }
     } catch (err) {
-      logger32.warn("Periodic version check failed", { error: err.message });
+      logger34.warn("Periodic version check failed", { error: err.message });
     }
   }
 };
 
 // src/config/ConfigReloader.ts
-var logger33 = logger.child("ConfigReloader");
+var logger35 = logger.child("ConfigReloader");
 var ConfigReloader = class {
   config;
   poller;
@@ -6588,11 +6799,11 @@ var ConfigReloader = class {
   }
   async reload(opts) {
     const timeoutMs = opts?.waitTimeoutMs ?? 6e4;
-    logger33.info("Config reload requested", { timeoutMs });
+    logger35.info("Config reload requested", { timeoutMs });
     this.poller.pauseDiscovery();
     const drained = await this.waitForDrain(timeoutMs);
     if (!drained) {
-      logger33.warn("Active issues did not drain within timeout, aborting reload", {
+      logger35.warn("Active issues did not drain within timeout, aborting reload", {
         active: this.poller.getActiveCount(),
         timeoutMs
       });
@@ -6607,7 +6818,7 @@ var ConfigReloader = class {
       this.orchestrator.setAIRunner(newRunner);
       this.options.onAIRunnerChanged?.(newRunner);
       this.gongfeng.updateConfig(this.config.gongfeng);
-      logger33.info("Config reloaded successfully", {
+      logger35.info("Config reloaded successfully", {
         aiMode: this.config.ai.mode,
         aiModel: this.config.ai.model,
         discoveryIntervalMs: this.config.poll.discoveryIntervalMs
@@ -6628,7 +6839,7 @@ var ConfigReloader = class {
 
 // src/distill/DiaryCollector.ts
 import { randomUUID as randomUUID2 } from "crypto";
-var logger34 = logger.child("DiaryCollector");
+var logger36 = logger.child("DiaryCollector");
 var DiaryCollector = class {
   tracker;
   diaryStore;
@@ -6646,21 +6857,21 @@ var DiaryCollector = class {
     if (this.stateChangedHandler) return;
     this.stateChangedHandler = (payload) => {
       this.handleStateChanged(payload).catch((err) => {
-        logger34.warn("DiaryCollector failed to handle stateChanged event", {
+        logger36.warn("DiaryCollector failed to handle stateChanged event", {
           error: err.message
         });
       });
     };
     this.failedHandler = (payload) => {
       this.handleFailed(payload).catch((err) => {
-        logger34.warn("DiaryCollector failed to handle failed event", {
+        logger36.warn("DiaryCollector failed to handle failed event", {
           error: err.message
         });
       });
     };
     eventBus.on("issue:stateChanged", this.stateChangedHandler);
     eventBus.on("issue:failed", this.failedHandler);
-    logger34.info("DiaryCollector started");
+    logger36.info("DiaryCollector started");
   }
   /** 停止监听事件 */
   stop() {
@@ -6672,7 +6883,7 @@ var DiaryCollector = class {
       eventBus.off("issue:failed", this.failedHandler);
       this.failedHandler = null;
     }
-    logger34.info("DiaryCollector stopped");
+    logger36.info("DiaryCollector stopped");
   }
   /** 处理 issue:stateChanged 事件 */
   async handleStateChanged(payload) {
@@ -6683,7 +6894,7 @@ var DiaryCollector = class {
     if (!issueIid) return;
     const existing = this.diaryStore.getByIssueIid(issueIid);
     if (existing.some((d) => d.outcome === "completed")) {
-      logger34.debug("Diary already exists for completed issue", { issueIid });
+      logger36.debug("Diary already exists for completed issue", { issueIid });
       return;
     }
     await this.collectDiary(issueIid, "completed");
@@ -6700,7 +6911,7 @@ var DiaryCollector = class {
     try {
       const record = this.tracker.get(issueIid);
       if (!record) {
-        logger34.warn("Cannot collect diary: issue record not found", { issueIid });
+        logger36.warn("Cannot collect diary: issue record not found", { issueIid });
         return null;
       }
       const plan = this.createPlanPersistence?.(issueIid);
@@ -6724,10 +6935,10 @@ var DiaryCollector = class {
       };
       this.diaryStore.create(diary);
       eventBus.emitTyped("distill:diary:created", { issueIid, diaryId: diary.id, outcome });
-      logger34.info("Diary collected", { issueIid, diaryId: diary.id, outcome });
+      logger36.info("Diary collected", { issueIid, diaryId: diary.id, outcome });
       return diary;
     } catch (err) {
-      logger34.warn("Failed to collect diary", {
+      logger36.warn("Failed to collect diary", {
         issueIid,
         outcome,
         error: err.message
@@ -6950,7 +7161,7 @@ ${memorySection}
 }
 
 // src/distill/MemoryDistiller.ts
-var logger35 = logger.child("MemoryDistiller");
+var logger37 = logger.child("MemoryDistiller");
 var MemoryDistiller = class {
   aiRunner;
   diaryStore;
@@ -6975,17 +7186,17 @@ var MemoryDistiller = class {
   async distill(options) {
     const undistilled = this.diaryStore.getUndistilled();
     if (!options?.force && undistilled.length < this.minDiariesForDistill) {
-      logger35.info("Not enough undistilled diaries, skipping memory distillation", {
+      logger37.info("Not enough undistilled diaries, skipping memory distillation", {
         count: undistilled.length,
         threshold: this.minDiariesForDistill
       });
       return { processedDiaries: 0, actions: 0 };
     }
     if (undistilled.length === 0) {
-      logger35.info("No undistilled diaries available");
+      logger37.info("No undistilled diaries available");
       return { processedDiaries: 0, actions: 0 };
     }
-    logger35.info("Starting memory distillation", { diaryCount: undistilled.length });
+    logger37.info("Starting memory distillation", { diaryCount: undistilled.length });
     const existingMemories = this.loadExistingMemories();
     const prompt = buildMemoryDistillPrompt(undistilled, existingMemories);
     const result = await this.aiRunner.run({
@@ -6994,12 +7205,12 @@ var MemoryDistiller = class {
       timeoutMs: this.timeoutMs
     });
     if (!result.success) {
-      logger35.error("AI distillation failed", { output: result.output.slice(0, 500) });
+      logger37.error("AI distillation failed", { output: result.output.slice(0, 500) });
       throw new Error(`Memory distillation AI call failed: ${result.output.slice(0, 200)}`);
     }
     const actions = this.parseActions(result.output);
     if (actions.length === 0) {
-      logger35.info("No distillation actions returned by AI");
+      logger37.info("No distillation actions returned by AI");
       this.diaryStore.markDistilled(undistilled.map((d) => d.id));
       return { processedDiaries: undistilled.length, actions: 0 };
     }
@@ -7009,14 +7220,14 @@ var MemoryDistiller = class {
         this.executeAction(action, existingMemories);
         actionCount++;
       } catch (err) {
-        logger35.warn("Failed to execute distill action", {
+        logger37.warn("Failed to execute distill action", {
           action: action.type,
           error: err.message
         });
       }
     }
     this.diaryStore.markDistilled(undistilled.map((d) => d.id));
-    logger35.info("Memory distillation complete", {
+    logger37.info("Memory distillation complete", {
       processedDiaries: undistilled.length,
       actions: actionCount
     });
@@ -7040,18 +7251,18 @@ var MemoryDistiller = class {
     try {
       const jsonMatch = output.match(/```json\s*([\s\S]*?)```/) ?? output.match(/\{[\s\S]*"actions"[\s\S]*\}/);
       if (!jsonMatch) {
-        logger35.warn("No JSON found in AI output");
+        logger37.warn("No JSON found in AI output");
         return [];
       }
       const jsonStr = jsonMatch[1] ?? jsonMatch[0];
       const parsed = JSON.parse(jsonStr);
       if (!Array.isArray(parsed.actions)) {
-        logger35.warn("Invalid actions format in AI output");
+        logger37.warn("Invalid actions format in AI output");
         return [];
       }
       return parsed.actions;
     } catch (err) {
-      logger35.warn("Failed to parse AI distillation output", {
+      logger37.warn("Failed to parse AI distillation output", {
         error: err.message,
         output: output.slice(0, 300)
       });
@@ -7071,7 +7282,7 @@ var MemoryDistiller = class {
         this.supersedeMemory(action, existingMemories);
         break;
       default:
-        logger35.warn("Unknown distill action type", { type: action.type });
+        logger37.warn("Unknown distill action type", { type: action.type });
     }
   }
   /** 创建新 memory */
@@ -7101,13 +7312,13 @@ var MemoryDistiller = class {
       action: "created",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger35.info("Created new memory", { id: memoryEntry.id, theme: action.theme, title: action.title });
+    logger37.info("Created new memory", { id: memoryEntry.id, theme: action.theme, title: action.title });
   }
   /** 合并新证据到已有 memory */
   mergeMemory(action, existingMemories) {
     const existing = existingMemories.find((m) => m.id === action.memoryId);
     if (!existing) {
-      logger35.warn("Cannot merge: memory not found", { memoryId: action.memoryId });
+      logger37.warn("Cannot merge: memory not found", { memoryId: action.memoryId });
       return;
     }
     existing.evidence = [.../* @__PURE__ */ new Set([...existing.evidence, ...action.newEvidence])];
@@ -7140,7 +7351,7 @@ var MemoryDistiller = class {
       reason: `Merged ${action.newEvidence.length} new evidence(s)`,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger35.info("Merged memory", { id: existing.id, newEvidence: action.newEvidence.length });
+    logger37.info("Merged memory", { id: existing.id, newEvidence: action.newEvidence.length });
   }
   /** 用新 memory 替代旧 memory */
   supersedeMemory(action, existingMemories) {
@@ -7182,7 +7393,7 @@ var MemoryDistiller = class {
       reason: `Supersedes ${action.oldMemoryId}`,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger35.info("Superseded memory", {
+    logger37.info("Superseded memory", {
       oldId: action.oldMemoryId,
       newId: newMemory.id,
       theme: action.theme
@@ -7284,7 +7495,7 @@ ${ruleSection}
 }
 
 // src/distill/AgentRuleDistiller.ts
-var logger36 = logger.child("AgentRuleDistiller");
+var logger38 = logger.child("AgentRuleDistiller");
 var AgentRuleDistiller = class {
   aiRunner;
   knowledgeStore;
@@ -7313,11 +7524,11 @@ var AgentRuleDistiller = class {
   async distill() {
     const matureMemories = this.getMatureMemories();
     if (matureMemories.length === 0) {
-      logger36.info("No mature memories ready for rule distillation");
+      logger38.info("No mature memories ready for rule distillation");
       return { processedMemories: 0, actions: 0 };
     }
     const existingRules = this.loadExistingRules();
-    logger36.info("Starting rule distillation", {
+    logger38.info("Starting rule distillation", {
       matureMemories: matureMemories.length,
       existingRules: existingRules.length
     });
@@ -7328,12 +7539,12 @@ var AgentRuleDistiller = class {
       timeoutMs: this.timeoutMs
     });
     if (!result.success) {
-      logger36.error("AI rule distillation failed", { output: result.output.slice(0, 500) });
+      logger38.error("AI rule distillation failed", { output: result.output.slice(0, 500) });
       throw new Error(`Rule distillation AI call failed: ${result.output.slice(0, 200)}`);
     }
     const actions = this.parseActions(result.output);
     if (actions.length === 0) {
-      logger36.info("No rule distillation actions returned by AI");
+      logger38.info("No rule distillation actions returned by AI");
       return { processedMemories: matureMemories.length, actions: 0 };
     }
     let actionCount = 0;
@@ -7342,13 +7553,13 @@ var AgentRuleDistiller = class {
         this.executeAction(action, existingRules);
         actionCount++;
       } catch (err) {
-        logger36.warn("Failed to execute rule distill action", {
+        logger38.warn("Failed to execute rule distill action", {
           action: action.type,
           error: err.message
         });
       }
     }
-    logger36.info("Rule distillation complete", {
+    logger38.info("Rule distillation complete", {
       processedMemories: matureMemories.length,
       actions: actionCount
     });
@@ -7402,7 +7613,7 @@ var AgentRuleDistiller = class {
     try {
       const jsonMatch = output.match(/```json\s*([\s\S]*?)```/) ?? output.match(/\{[\s\S]*"actions"[\s\S]*\}/);
       if (!jsonMatch) {
-        logger36.warn("No JSON found in AI rule distill output");
+        logger38.warn("No JSON found in AI rule distill output");
         return [];
       }
       const jsonStr = jsonMatch[1] ?? jsonMatch[0];
@@ -7410,7 +7621,7 @@ var AgentRuleDistiller = class {
       if (!Array.isArray(parsed.actions)) return [];
       return parsed.actions;
     } catch (err) {
-      logger36.warn("Failed to parse AI rule distill output", {
+      logger38.warn("Failed to parse AI rule distill output", {
         error: err.message
       });
       return [];
@@ -7429,7 +7640,7 @@ var AgentRuleDistiller = class {
         this.deprecateRule(action, existingRules);
         break;
       default:
-        logger36.warn("Unknown rule distill action type", { type: action.type });
+        logger38.warn("Unknown rule distill action type", { type: action.type });
     }
   }
   /** 创建新规则 */
@@ -7462,13 +7673,13 @@ var AgentRuleDistiller = class {
       action: "created",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger36.info("Created agent rule", { id: ruleEntry.id, ruleName: action.ruleName });
+    logger38.info("Created agent rule", { id: ruleEntry.id, ruleName: action.ruleName });
   }
   /** 更新已有规则 */
   updateRule(action, existingRules) {
     const existing = existingRules.find((r) => r.id === action.ruleId);
     if (!existing) {
-      logger36.warn("Cannot update: rule not found", { ruleId: action.ruleId });
+      logger38.warn("Cannot update: rule not found", { ruleId: action.ruleId });
       return;
     }
     existing.content = action.content;
@@ -7498,13 +7709,13 @@ var AgentRuleDistiller = class {
       action: "merged",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger36.info("Updated agent rule", { id: existing.id, ruleName: existing.ruleName });
+    logger38.info("Updated agent rule", { id: existing.id, ruleName: existing.ruleName });
   }
   /** 废弃规则 */
   deprecateRule(action, existingRules) {
     const existing = existingRules.find((r) => r.id === action.ruleId);
     if (!existing) {
-      logger36.warn("Cannot deprecate: rule not found", { ruleId: action.ruleId });
+      logger38.warn("Cannot deprecate: rule not found", { ruleId: action.ruleId });
       return;
     }
     existing.deprecated = true;
@@ -7533,7 +7744,7 @@ var AgentRuleDistiller = class {
       reason: action.reason,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger36.info("Deprecated agent rule", { id: existing.id, reason: action.reason });
+    logger38.info("Deprecated agent rule", { id: existing.id, reason: action.reason });
   }
   /** 同步规则到 DATA_DIR/rules/ MDC 文件，可选同步到项目 */
   syncMdcFile(rule) {
@@ -7549,9 +7760,9 @@ var AgentRuleDistiller = class {
       ensureDir(this.rulesDir);
       const filePath = path13.join(this.rulesDir, `distilled-${rule.ruleName}.mdc`);
       fs9.writeFileSync(filePath, mdcContent, "utf-8");
-      logger36.debug("Synced MDC file", { path: filePath });
+      logger38.debug("Synced MDC file", { path: filePath });
     } catch (err) {
-      logger36.warn("Failed to sync MDC file", {
+      logger38.warn("Failed to sync MDC file", {
         ruleName: rule.ruleName,
         error: err.message
       });
@@ -7561,9 +7772,9 @@ var AgentRuleDistiller = class {
         ensureDir(this.projectRulesDir);
         const projectFilePath = path13.join(this.projectRulesDir, `distilled-${rule.ruleName}.mdc`);
         fs9.writeFileSync(projectFilePath, mdcContent, "utf-8");
-        logger36.debug("Synced MDC file to project", { path: projectFilePath });
+        logger38.debug("Synced MDC file to project", { path: projectFilePath });
       } catch (err) {
-        logger36.warn("Failed to sync MDC file to project", {
+        logger38.warn("Failed to sync MDC file to project", {
           ruleName: rule.ruleName,
           error: err.message
         });
@@ -7577,10 +7788,10 @@ var AgentRuleDistiller = class {
       const filePath = path13.join(this.rulesDir, fileName);
       if (fs9.existsSync(filePath)) {
         fs9.unlinkSync(filePath);
-        logger36.debug("Removed MDC file", { path: filePath });
+        logger38.debug("Removed MDC file", { path: filePath });
       }
     } catch (err) {
-      logger36.warn("Failed to remove MDC file", {
+      logger38.warn("Failed to remove MDC file", {
         ruleName,
         error: err.message
       });
@@ -7590,10 +7801,10 @@ var AgentRuleDistiller = class {
         const projectFilePath = path13.join(this.projectRulesDir, fileName);
         if (fs9.existsSync(projectFilePath)) {
           fs9.unlinkSync(projectFilePath);
-          logger36.debug("Removed MDC file from project", { path: projectFilePath });
+          logger38.debug("Removed MDC file from project", { path: projectFilePath });
         }
       } catch (err) {
-        logger36.warn("Failed to remove MDC file from project", {
+        logger38.warn("Failed to remove MDC file from project", {
           ruleName,
           error: err.message
         });
@@ -7624,7 +7835,7 @@ var AgentRuleDistiller = class {
 // src/distill/VectorStore.ts
 import fs10 from "fs";
 import path14 from "path";
-var logger37 = logger.child("VectorStore");
+var logger39 = logger.child("VectorStore");
 var STOP_WORDS = /* @__PURE__ */ new Set([
   // 英文
   "the",
@@ -7811,7 +8022,7 @@ var VectorStore = class {
   async reindex() {
     this.rebuildDocumentFreqs();
     this.save();
-    logger37.info("Vector index rebuilt", { count: this.data.vectors.length });
+    logger39.info("Vector index rebuilt", { count: this.data.vectors.length });
   }
   /** 获取索引条目数 */
   count() {
@@ -7888,7 +8099,7 @@ var VectorStore = class {
         return JSON.parse(raw);
       }
     } catch (err) {
-      logger37.warn("Failed to load vector store", { error: err.message });
+      logger39.warn("Failed to load vector store", { error: err.message });
     }
     return { documentFreqs: {}, vectors: [], totalDocs: 0 };
   }
@@ -7906,7 +8117,7 @@ var VectorStore = class {
 // src/distill/VersionStore.ts
 import fs11 from "fs";
 import path15 from "path";
-var logger38 = logger.child("VersionStore");
+var logger40 = logger.child("VersionStore");
 var VersionStore = class {
   filePath;
   data;
@@ -7938,7 +8149,7 @@ var VersionStore = class {
         return JSON.parse(raw);
       }
     } catch (err) {
-      logger38.warn("Failed to load version store", { error: err.message });
+      logger40.warn("Failed to load version store", { error: err.message });
     }
     return { records: [] };
   }
@@ -7954,7 +8165,7 @@ var VersionStore = class {
 };
 
 // src/distill/DistillScheduler.ts
-var logger39 = logger.child("DistillScheduler");
+var logger41 = logger.child("DistillScheduler");
 var DistillScheduler = class {
   diaryStore;
   memoryDistiller;
@@ -7980,29 +8191,29 @@ var DistillScheduler = class {
     if (this.timer) return;
     this.timer = setInterval(() => {
       this.runDistill().catch((err) => {
-        logger39.error("Scheduled distillation failed", { error: err.message });
+        logger41.error("Scheduled distillation failed", { error: err.message });
       });
     }, this.intervalMs);
-    logger39.info("DistillScheduler started", { intervalMs: this.intervalMs });
+    logger41.info("DistillScheduler started", { intervalMs: this.intervalMs });
   }
   /** 停止定时调度 */
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
-      logger39.info("DistillScheduler stopped");
+      logger41.info("DistillScheduler stopped");
     }
   }
   /** 手动触发蒸馏 */
   async runDistill(options) {
     if (this.running) {
-      logger39.info("Distillation already in progress, skipping");
+      logger41.info("Distillation already in progress, skipping");
       return { memory: { processedDiaries: 0, actions: 0 }, rule: { processedMemories: 0, actions: 0 }, vectorIndexed: 0 };
     }
     this.running = true;
     eventBus.emitTyped("distill:started", {});
     try {
-      logger39.info("Starting distillation pipeline");
+      logger41.info("Starting distillation pipeline");
       const memoryResult = await this.memoryDistiller.distill({ force: options?.force });
       if (memoryResult.actions > 0) {
         eventBus.emitTyped("distill:memory:updated", {
@@ -8027,7 +8238,7 @@ var DistillScheduler = class {
         rule: ruleResult,
         vectorIndexed
       });
-      logger39.info("Distillation pipeline complete", {
+      logger41.info("Distillation pipeline complete", {
         memoryActions: memoryResult.actions,
         ruleActions: ruleResult.actions,
         vectorIndexed
@@ -8095,13 +8306,13 @@ ${content}`
       });
       indexed++;
     }
-    logger39.info("Vector indexing complete", { indexed });
+    logger41.info("Vector indexing complete", { indexed });
     return indexed;
   }
 };
 
 // src/deploy/PreviewReaper.ts
-var logger40 = logger.child("PreviewReaper");
+var logger42 = logger.child("PreviewReaper");
 var TERMINAL_STATES = /* @__PURE__ */ new Set(["completed" /* Completed */, "failed" /* Failed */, "deployed" /* Deployed */]);
 var PreviewReaper = class {
   tracker;
@@ -8124,16 +8335,16 @@ var PreviewReaper = class {
     if (this.timer) return;
     this.timer = setInterval(() => {
       this.reap().catch((err) => {
-        logger40.error("Scheduled preview reap failed", { error: err.message });
+        logger42.error("Scheduled preview reap failed", { error: err.message });
       });
     }, this.intervalMs);
-    logger40.info("PreviewReaper started", { intervalMs: this.intervalMs, ttlMs: this.ttlMs });
+    logger42.info("PreviewReaper started", { intervalMs: this.intervalMs, ttlMs: this.ttlMs });
   }
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
-      logger40.info("PreviewReaper stopped");
+      logger42.info("PreviewReaper stopped");
     }
   }
   async reap() {
@@ -8155,13 +8366,13 @@ var PreviewReaper = class {
         try {
           this.orchestrator.stopPreviewServers(iid);
           reaped.push(iid);
-          logger40.info(t("reaper.reaped", { iid, hours }));
+          logger42.info(t("reaper.reaped", { iid, hours }));
         } catch (err) {
-          logger40.warn("Failed to reap preview", { iid, error: err.message });
+          logger42.warn("Failed to reap preview", { iid, error: err.message });
         }
       }
       if (reaped.length > 0) {
-        logger40.info(t("reaper.summary", { count: reaped.length }));
+        logger42.info(t("reaper.summary", { count: reaped.length }));
         this.bus.emitTyped("preview:reaped", { iids: reaped, count: reaped.length });
       }
       this.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -8190,7 +8401,7 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
-var logger41 = logger.child("OrphanBranchManager");
+var logger43 = logger.child("OrphanBranchManager");
 var SYNC_MANIFEST = [
   "knowledge/index.json",
   "knowledge/knowledge.json",
@@ -8261,7 +8472,7 @@ var OrphanBranchManager = class {
         await this.gitIn(tmpDir, ["add", "-A"]);
         const status = await this.gitIn(tmpDir, ["status", "--porcelain"]);
         if (!status.trim()) {
-          logger41.info("No changes to publish");
+          logger43.info("No changes to publish");
           return { commitSha: await this.gitIn(tmpDir, ["rev-parse", "HEAD"]) };
         }
         await this.gitIn(tmpDir, [
@@ -8272,7 +8483,7 @@ var OrphanBranchManager = class {
         ]);
         const commitSha = await this.gitIn(tmpDir, ["rev-parse", "HEAD"]);
         await this.pushWithRetry(tmpDir);
-        logger41.info("Knowledge published to orphan branch", {
+        logger43.info("Knowledge published to orphan branch", {
           branch: this.branch,
           commitSha: commitSha.slice(0, 8),
           entriesCount: copied
@@ -8339,7 +8550,7 @@ var OrphanBranchManager = class {
         } catch {
         }
       }
-      logger41.info("Knowledge restored from orphan branch", {
+      logger43.info("Knowledge restored from orphan branch", {
         branch: this.branch,
         entriesCount
       });
@@ -8376,7 +8587,7 @@ var OrphanBranchManager = class {
   // Private helpers
   // -----------------------------------------------------------------------
   async git(args) {
-    logger41.debug("git exec (main)", { args });
+    logger43.debug("git exec (main)", { args });
     const { stdout } = await execFileAsync("git", args, {
       cwd: this.gitRootDir,
       maxBuffer: 10 * 1024 * 1024,
@@ -8385,7 +8596,7 @@ var OrphanBranchManager = class {
     return stdout.trim();
   }
   async gitIn(cwd, args) {
-    logger41.debug("git exec (worktree)", { cwd: path16.basename(cwd), args });
+    logger43.debug("git exec (worktree)", { cwd: path16.basename(cwd), args });
     const { stdout } = await execFileAsync("git", args, {
       cwd,
       maxBuffer: 10 * 1024 * 1024,
@@ -8485,7 +8696,7 @@ var OrphanBranchManager = class {
             `Failed to push to orphan branch after ${MAX_PUSH_RETRIES} attempts: ${err.message}`
           );
         }
-        logger41.warn("Push failed, pulling and retrying", {
+        logger43.warn("Push failed, pulling and retrying", {
           attempt,
           error: err.message
         });
@@ -8498,7 +8709,7 @@ var OrphanBranchManager = class {
     try {
       await this.git(["worktree", "remove", wtDir, "--force"]);
     } catch {
-      logger41.debug("Worktree cleanup skipped (may not exist)", { dir: wtDir });
+      logger43.debug("Worktree cleanup skipped (may not exist)", { dir: wtDir });
     }
     try {
       await this.git(["worktree", "prune"]);
@@ -8515,7 +8726,7 @@ import fs14 from "fs";
 import { z } from "zod";
 import fs13 from "fs";
 import path17 from "path";
-var logger42 = logger.child("TenantConfig");
+var logger44 = logger.child("TenantConfig");
 var tenantGongfengSchema = z.object({
   apiUrl: z.string().url("apiUrl must be a valid URL"),
   privateToken: z.string().min(1, "privateToken is required"),
@@ -8542,7 +8753,7 @@ var DEFAULT_TENANT_ID = "default";
 function loadTenantsConfig(configPath) {
   if (!configPath) return null;
   if (!fs13.existsSync(configPath)) {
-    logger42.warn("Tenants config file not found, falling back to single-tenant mode", {
+    logger44.warn("Tenants config file not found, falling back to single-tenant mode", {
       path: configPath
     });
     return null;
@@ -8553,14 +8764,14 @@ function loadTenantsConfig(configPath) {
     const result = tenantsConfigSchema.safeParse(json);
     if (!result.success) {
       const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      logger42.error(`Tenants config validation failed:
+      logger44.error(`Tenants config validation failed:
 ${issues}`);
       return null;
     }
     const ids = result.data.tenants.map((t2) => t2.id);
     const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
     if (dupes.length > 0) {
-      logger42.error("Duplicate tenant IDs found", { duplicates: [...new Set(dupes)] });
+      logger44.error("Duplicate tenant IDs found", { duplicates: [...new Set(dupes)] });
       return null;
     }
     const baseDir = path17.dirname(configPath);
@@ -8569,12 +8780,12 @@ ${issues}`);
         tenant.workspace = path17.resolve(baseDir, tenant.workspace);
       }
     }
-    logger42.info("Tenants config loaded", {
+    logger44.info("Tenants config loaded", {
       tenants: result.data.tenants.map((t2) => t2.id)
     });
     return result.data;
   } catch (err) {
-    logger42.error("Failed to parse tenants config", {
+    logger44.error("Failed to parse tenants config", {
       path: configPath,
       error: err.message
     });
@@ -8637,6 +8848,49 @@ async function main() {
   const allAiPhaseNames = [...new Set(
     [...lifecycleManagers.values()].flatMap((lm) => lm.getExecutablePhaseNames())
   )];
+  let sharedTerminalManager;
+  if (config.ai.mode === "pty") {
+    const { TerminalManager: TerminalManager2 } = await import("./TerminalManager-RT2N7N5R.js");
+    const { PtyRunner } = await import("./PtyRunner-6UGI5STW.js");
+    const { registerAIRunner: regRunner, getPtyProfile } = await import("./AIRunnerRegistry-II3WWSFN.js");
+    const allPtyAgents = /* @__PURE__ */ new Set([
+      config.pty.defaultAgent,
+      ...Object.values(config.pty.phaseAgents)
+    ]);
+    for (const agent of allPtyAgents) {
+      if (!getPtyProfile(agent)) {
+        throw new Error(
+          `PTY agent "${agent}" has no PtyProfile. Supported agents: claude-internal, codebuddy, cursor-agent`
+        );
+      }
+    }
+    sharedTerminalManager = new TerminalManager2({
+      idleTimeoutMs: config.terminal.idleTimeoutMs,
+      maxSessions: config.terminal.maxSessions,
+      allowedBaseDirs: [
+        config.project.worktreeBaseDir ?? config.project.workDir,
+        config.project.workDir
+      ].filter(Boolean)
+    });
+    const tm = sharedTerminalManager;
+    regRunner("pty", {
+      factoryFn: (_binary, nvmNodeVersion) => new PtyRunner(
+        nvmNodeVersion,
+        tm,
+        config.pty.defaultAgent,
+        config.pty.phaseAgents,
+        config.ai.model,
+        config.pty.idleDetectMs
+      ),
+      defaultBinary: "claude",
+      binaryEnvKey: "CLAUDE_BINARY",
+      capabilities: { nativePlanMode: false }
+    });
+    logger.info("PTY runner registered (multi-agent)", {
+      defaultAgent: config.pty.defaultAgent,
+      phaseAgents: config.pty.phaseAgents
+    });
+  }
   validatePhaseRegistry(allAiPhaseNames);
   validateRunnerRegistry([config.ai.mode]);
   const aiRunner = createAIRunner(config.ai);
@@ -8894,7 +9148,8 @@ async function main() {
       configReloader,
       orphanManager,
       wsConfig: primaryTenant.wsConfig,
-      previewReaper
+      previewReaper,
+      terminalManager: sharedTerminalManager
     });
     await webServer.start();
   }
@@ -9005,4 +9260,4 @@ function migrateKnowledgeDir(srcDir, destDir) {
 export {
   main
 };
-//# sourceMappingURL=chunk-K2OTLYJI.js.map
+//# sourceMappingURL=chunk-QZZGIZWC.js.map