copilotoffice 2.0.0 → 2.1.0

package/dist/electron/main.js

@@ -23,18 +23,138 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // electron/main.ts
-var import_electron3 = require("electron");
-var path3 = __toESM(require("path"));
-var fs2 = __toESM(require("fs"));
-var import_child_process2 = require("child_process");
+var import_electron4 = require("electron");
+var path8 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var import_child_process4 = require("child_process");
 
 // electron/terminal/ipc-relay.ts
 var import_electron = require("electron");
+var import_child_process2 = require("child_process");
+var import_events = require("events");
+var crypto2 = __toESM(require("crypto"));
+var path2 = __toESM(require("path"));
+
+// electron/terminal/pty-registry.ts
 var import_child_process = require("child_process");
 var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
 var path = __toESM(require("path"));
+var START_TIME_GRACE_MS = 2e3;
+var DEFAULT_REGISTRY_FILE = path.join(process.cwd(), ".data", "pty-pids.json");
+function readPtyRegistry(file = DEFAULT_REGISTRY_FILE) {
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (r) => !!r && typeof r.pid === "number" && Number.isFinite(r.pid)
+    );
+  } catch {
+    return [];
+  }
+}
+function writePtyRegistry(records, file = DEFAULT_REGISTRY_FILE) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(records, null, 2));
+    fs.renameSync(tmp, file);
+  } catch {
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function processStartTimeMs(pid) {
+  try {
+    if (os.platform() === "win32") {
+      const cmd = `powershell -NoProfile -NonInteractive -Command "$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($p) { [DateTimeOffset]::new($p.CreationDate).ToUnixTimeMilliseconds() }"`;
+      const out2 = (0, import_child_process.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      const ms2 = parseInt(out2, 10);
+      return Number.isFinite(ms2) ? ms2 : null;
+    }
+    const out = (0, import_child_process.execSync)(`ps -o lstart= -p ${pid}`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out) return null;
+    const ms = Date.parse(out);
+    return Number.isNaN(ms) ? null : ms;
+  } catch {
+    return null;
+  }
+}
+function processIdentityMatches(record, startTimeOf) {
+  const startMs = startTimeOf(record.pid);
+  if (startMs == null) return false;
+  return startMs <= record.startedAt + START_TIME_GRACE_MS;
+}
+function killTree(pid) {
+  try {
+    if (os.platform() === "win32") {
+      (0, import_child_process.execSync)(`taskkill /T /F /PID ${pid}`, { stdio: "ignore" });
+    } else {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+        process.kill(pid, "SIGKILL");
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reapRegisteredPtys(options = {}) {
+  const file = options.file ?? DEFAULT_REGISTRY_FILE;
+  const isAlive = options.isAlive ?? isPidAlive;
+  const kill = options.kill ?? killTree;
+  const startTimeOf = options.startTimeOf ?? processStartTimeMs;
+  const protectedPids = /* @__PURE__ */ new Set([process.pid, ...options.protectedPids ?? []]);
+  const records = readPtyRegistry(file);
+  const reaped = [];
+  const skipped = [];
+  const failed = [];
+  const survivors = [];
+  for (const record of records) {
+    const { pid } = record;
+    if (protectedPids.has(pid) || !isAlive(pid)) {
+      skipped.push(pid);
+      continue;
+    }
+    if (!processIdentityMatches(record, startTimeOf)) {
+      skipped.push(pid);
+      continue;
+    }
+    if (kill(pid)) {
+      reaped.push(pid);
+    } else {
+      failed.push(pid);
+      survivors.push(record);
+    }
+  }
+  writePtyRegistry(survivors, file);
+  return { reaped, skipped, failed };
+}
+
+// electron/terminal/ipc-relay.ts
 var TerminalRelay = class _TerminalRelay {
   constructor(getWindow) {
+    /**
+     * Event bus for main-process consumers (e.g. the Teams service) that need
+     * server→main copilot/terminal events without going through the renderer.
+     * Emits: 'copilot-event' (agentId, event), 'copilot-turn-start' (agentId),
+     * 'copilot-turn-end' (agentId), 'copilot-tool-start' (agentId, toolName, toolId, status),
+     * 'session-meta-updated' (agentId, meta), 'terminal-exit' (agentId, exitCode).
+     */
+    this.mainEvents = new import_events.EventEmitter();
     this.server = null;
     this.pendingRequests = /* @__PURE__ */ new Map();
     /** True while a deliberate shutdown→respawn is in progress (prevents double-spawn). */
@@ -49,10 +169,10 @@ var TerminalRelay = class _TerminalRelay {
   }
   // ── Server Lifecycle ──────────────────────────────────────────
   spawnServer(distDir) {
-    return new Promise((resolve, reject) => {
-      const serverPath = path.join(distDir, "terminal", "server.js");
+    return new Promise((resolve2, reject) => {
+      const serverPath = path2.join(distDir, "terminal", "server.js");
       console.log("[Relay] Forking terminal server:", serverPath);
-      this.server = (0, import_child_process.fork)(serverPath, [], {
+      this.server = (0, import_child_process2.fork)(serverPath, [], {
         cwd: process.cwd(),
         stdio: ["pipe", "inherit", "inherit", "ipc"]
       });
@@ -60,7 +180,7 @@ var TerminalRelay = class _TerminalRelay {
         reject(new Error("Terminal server did not send ready in time"));
       }, 15e3);
       this.server.on("message", (msg) => {
-        this.handleServerMessage(msg, readyTimeout, resolve);
+        this.handleServerMessage(msg, readyTimeout, resolve2);
       });
       this.server.on("exit", (code, signal) => {
         console.error(`[Relay] Terminal server exited (code=${code}, signal=${signal})`);
@@ -76,6 +196,14 @@ var TerminalRelay = class _TerminalRelay {
         }
         const win = this.getWindow();
         if (win && !win.isDestroyed()) {
+          try {
+            const { reaped } = reapRegisteredPtys();
+            if (reaped.length > 0) {
+              console.log(`[Relay] Reaped ${reaped.length} orphaned PTY tree(s) from crashed server:`, reaped);
+            }
+          } catch (e) {
+            console.error("[Relay] Failed to reap orphaned PTYs after crash:", e);
+          }
           console.log("[Relay] Respawning terminal server...");
           this.spawnServer(distDir).catch(
             (e) => console.error("[Relay] Failed to respawn:", e)
@@ -107,10 +235,10 @@ var TerminalRelay = class _TerminalRelay {
     this.pendingRequests.clear();
     this.queuedRequests = [];
     const oldPid = oldServer.pid;
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const onExit = () => {
         clearTimeout(timeout);
-        resolve();
+        resolve2();
       };
       oldServer.once("exit", onExit);
       const timeout = setTimeout(() => {
@@ -120,14 +248,14 @@ var TerminalRelay = class _TerminalRelay {
             process.kill(oldPid, 0);
             console.log(`[Relay] Server PID ${oldPid} still alive after timeout \u2014 force killing`);
             if (process.platform === "win32") {
-              (0, import_child_process.execSync)(`taskkill /T /F /PID ${oldPid}`, { stdio: "ignore" });
+              (0, import_child_process2.execSync)(`taskkill /T /F /PID ${oldPid}`, { stdio: "ignore" });
             } else {
               process.kill(oldPid, "SIGKILL");
             }
           } catch {
           }
         }
-        resolve();
+        resolve2();
       }, 3e3);
     });
   }
@@ -140,26 +268,52 @@ var TerminalRelay = class _TerminalRelay {
   request(msg) {
     if (!this.server?.connected) {
       console.log(`[Relay] Server not connected \u2014 queuing request ${msg.type} (${msg.requestId})`);
-      return new Promise((resolve) => {
-        this.queuedRequests.push({ msg, resolve });
+      return new Promise((resolve2) => {
+        this.queuedRequests.push({ msg, resolve: resolve2 });
       });
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         if (this.pendingRequests.delete(msg.requestId)) {
           console.warn(`[Relay] Request ${msg.type} (${msg.requestId}) timed out after ${_TerminalRelay.REQUEST_TIMEOUT_MS}ms`);
-          resolve({ success: false, error: "Request timed out" });
+          resolve2({ success: false, error: "Request timed out" });
         }
       }, _TerminalRelay.REQUEST_TIMEOUT_MS);
       this.pendingRequests.set(msg.requestId, (result) => {
         clearTimeout(timeout);
-        resolve(result);
+        resolve2(result);
       });
       this.send(msg);
     });
   }
   id() {
-    return crypto.randomUUID();
+    return crypto2.randomUUID();
+  }
+  // ── Main-process gateway (for the Teams service) ──────────────
+  // These let a main-process consumer talk to the terminal server directly,
+  // reusing the same request/response plumbing as the renderer IPC handlers.
+  mainGetSessionId(officeId, agentId) {
+    return this.request({ type: "get-session-id", requestId: this.id(), officeId, agentId });
+  }
+  /** True only when the agent's PTY is alive AND the CLI has signalled ready. */
+  mainIsAgentReady(officeId, agentId) {
+    return this.request({ type: "query-agent-statuses", requestId: this.id(), officeId }).then((statuses) => {
+      const s = statuses?.[agentId];
+      return !!(s && s.alive && s.ready);
+    });
+  }
+  mainGetSessionMeta(officeId, agentId) {
+    return this.request({ type: "get-session-meta", requestId: this.id(), officeId, agentId });
+  }
+  mainWrite(officeId, agentId, data) {
+    return this.request({ type: "write", requestId: this.id(), officeId, agentId, data });
+  }
+  mainSubmitPrompt(officeId, agentId, prompt, label) {
+    return this.request({ type: "submit-prompt", requestId: this.id(), officeId, agentId, prompt, label });
+  }
+  /** Fire-and-forget: control whether copilot-events are mirrored to main for an agent without a viewer. */
+  mainSetAgentForwarding(officeId, agentId, enabled) {
+    this.send({ type: "set-agent-forwarding", officeId, agentId, enabled });
   }
   handleServerMessage(msg, readyTimeout, onReady) {
     if (msg.type === "ready") {
@@ -185,6 +339,29 @@ var TerminalRelay = class _TerminalRelay {
       }
       return;
     }
+    switch (msg.type) {
+      case "copilot-event":
+        this.mainEvents.emit("copilot-event", msg.agentId, msg.event);
+        break;
+      case "copilot-turn-start":
+        this.mainEvents.emit("copilot-turn-start", msg.agentId);
+        break;
+      case "copilot-turn-end":
+        this.mainEvents.emit("copilot-turn-end", msg.agentId);
+        break;
+      case "copilot-user-message":
+        this.mainEvents.emit("copilot-user-message", msg.agentId, msg.text);
+        break;
+      case "copilot-tool-start":
+        this.mainEvents.emit("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
+        break;
+      case "session-meta-updated":
+        this.mainEvents.emit("session-meta-updated", msg.agentId, msg.meta);
+        break;
+      case "terminal-exit":
+        this.mainEvents.emit("terminal-exit", msg.agentId, msg.exitCode);
+        break;
+    }
     const win = this.getWindow();
     if (!win || win.isDestroyed()) return;
     switch (msg.type) {
@@ -195,7 +372,7 @@ var TerminalRelay = class _TerminalRelay {
         win.webContents.send("terminal-exit", msg.agentId, msg.exitCode);
         break;
       case "copilot-event":
-        win.webContents.send("copilot-event", msg.agentId, msg.event);
+        if (!msg.mainOnly) win.webContents.send("copilot-event", msg.agentId, msg.event);
         break;
       case "copilot-tool-start":
         win.webContents.send("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
@@ -210,7 +387,7 @@ var TerminalRelay = class _TerminalRelay {
         win.webContents.send("copilot-turn-start", msg.agentId);
         break;
       case "copilot-user-message":
-        win.webContents.send("copilot-user-message", msg.agentId);
+        win.webContents.send("copilot-user-message", msg.agentId, msg.text);
         break;
       case "session-meta-updated":
         win.webContents.send("session-meta-updated", msg.agentId, msg.meta);
@@ -242,6 +419,14 @@ var TerminalRelay = class _TerminalRelay {
       this.send({ type: "resize", officeId, agentId, cols, rows });
       return { success: true };
     });
+    import_electron.ipcMain.handle("set-yolo", (_event, enabled) => {
+      this.send({ type: "set-yolo", enabled: !!enabled });
+      return { success: true };
+    });
+    import_electron.ipcMain.handle("set-additional-params", (_event, params) => {
+      this.send({ type: "set-additional-params", params: String(params ?? "") });
+      return { success: true };
+    });
     import_electron.ipcMain.handle(
       "terminal-kill",
       (_event, officeId, agentId) => this.request({ type: "kill", requestId: this.id(), officeId, agentId })
@@ -314,22 +499,22 @@ var TerminalRelay = class _TerminalRelay {
 };
 
 // electron/officeFileStore.ts
-var fs = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var DEFAULT_DATA_SUBDIR = ".data";
 var DEFAULT_FILE_NAME = "copilot-offices.json";
 function createOfficeFileStore(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const dataSubdir = options.dataSubdir ?? DEFAULT_DATA_SUBDIR;
   const fileName = options.fileName ?? DEFAULT_FILE_NAME;
-  const dataDir = path2.join(cwd, dataSubdir);
-  const filePath = path2.join(dataDir, fileName);
+  const dataDir = path3.join(cwd, dataSubdir);
+  const filePath = path3.join(dataDir, fileName);
   return {
     filePath,
     load() {
       try {
-        if (!fs.existsSync(filePath)) return { success: true, data: null };
-        const data = fs.readFileSync(filePath, "utf8");
+        if (!fs2.existsSync(filePath)) return { success: true, data: null };
+        const data = fs2.readFileSync(filePath, "utf8");
         return { success: true, data };
       } catch (e) {
         return { success: false, data: null, error: String(e) };
@@ -337,8 +522,8 @@ function createOfficeFileStore(options = {}) {
     },
     save(data) {
       try {
-        fs.mkdirSync(dataDir, { recursive: true });
-        fs.writeFileSync(filePath, data, "utf8");
+        fs2.mkdirSync(dataDir, { recursive: true });
+        fs2.writeFileSync(filePath, data, "utf8");
         return { success: true };
       } catch (e) {
         return { success: false, error: String(e) };
@@ -403,155 +588,2121 @@ function registerNonTerminalIpc(hooks) {
   });
 }
 
-// electron/main.ts
-var OPEN_DEVTOOLS_ON_START = process.env.COPILOT_OFFICE_OPEN_DEVTOOLS !== "0";
-var ENABLE_FILE_WATCHER = process.env.COPILOT_OFFICE_ENABLE_WATCHER !== "0";
-function killOrphanedProcesses() {
-  try {
-    if (process.platform === "win32") {
-      const out = (0, import_child_process2.execSync)(
-        `wmic process where "CommandLine like '%COPILOT_OFFICE_PROCESS%'" get ProcessId`,
-        { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }
-      );
-      const pids = out.split(/\r?\n/).map((l) => parseInt(l.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
-      if (pids.length > 0) {
-        console.log(`[Main] Killing ${pids.length} orphaned COPILOT_OFFICE processes:`, pids);
-        for (const pid of pids) {
-          try {
-            (0, import_child_process2.execSync)(`taskkill /T /F /PID ${pid}`, { stdio: "ignore" });
-          } catch {
-          }
-        }
-      }
-    } else {
-      const out = (0, import_child_process2.execSync)("pgrep -f COPILOT_OFFICE_PROCESS || true", {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "ignore"]
-      });
-      const pids = out.split(/\r?\n/).map((l) => parseInt(l.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
-      if (pids.length > 0) {
-        console.log(`[Main] Killing ${pids.length} orphaned COPILOT_OFFICE processes:`, pids);
-        for (const pid of pids) {
-          try {
-            process.kill(pid, "SIGKILL");
-          } catch {
-          }
+// electron/teams/onlineAgentsStore.ts
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// electron/teams/log.ts
+var PREFIX = "[TeamsRemote]";
+function tlog(...args) {
+  console.log(PREFIX, ...args);
+}
+function twarn(...args) {
+  console.warn(PREFIX, ...args);
+}
+function terror(...args) {
+  console.error(PREFIX, ...args);
+}
+
+// electron/teams/onlineAgentsStore.ts
+var STORE_VERSION = 1;
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+function emptyState() {
+  return { bindings: [], knownThreads: [] };
+}
+function gcStale(bindings, nowMs, maxAgeMs = THIRTY_DAYS_MS) {
+  const kept = [];
+  const removed = [];
+  for (const b of bindings) {
+    if (nowMs - (b.lastConnected || 0) > maxAgeMs) removed.push(b);
+    else kept.push(b);
+  }
+  return { kept, removed };
+}
+var FileTeamsOnlineStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  static defaultPath(dataDir) {
+    return path4.join(dataDir, "teams-online-agents.json");
+  }
+  async load() {
+    try {
+      const raw = await fs3.promises.readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        bindings: Array.isArray(parsed.bindings) ? parsed.bindings : [],
+        knownThreads: Array.isArray(parsed.knownThreads) ? parsed.knownThreads : []
+      };
+    } catch (e) {
+      if (e?.code === "ENOENT") return emptyState();
+      terror("Failed to load online store \u2014 starting empty:", e);
+      return emptyState();
+    }
+  }
+  async save(state) {
+    const dir = path4.dirname(this.filePath);
+    await fs3.promises.mkdir(dir, { recursive: true });
+    const payload = JSON.stringify(
+      { version: STORE_VERSION, bindings: state.bindings, knownThreads: state.knownThreads },
+      null,
+      2
+    );
+    await fs3.promises.writeFile(this.filePath, payload, "utf-8");
+  }
+};
+
+// electron/teams/dispatchQueue.ts
+var DispatchQueue = class {
+  constructor(process2) {
+    this.process = process2;
+    this.queues = /* @__PURE__ */ new Map();
+    this.processing = /* @__PURE__ */ new Set();
+  }
+  key(officeId, agentId) {
+    return `${officeId}:${agentId}`;
+  }
+  enqueue(item) {
+    const k = this.key(item.officeId, item.agentId);
+    const q = this.queues.get(k) ?? [];
+    q.push(item);
+    this.queues.set(k, q);
+    void this.drain(k);
+  }
+  /** Number of pending items for an agent (excludes the in-flight one). */
+  pending(officeId, agentId) {
+    return this.queues.get(this.key(officeId, agentId))?.length ?? 0;
+  }
+  /** Drop all queued work for an agent (e.g. on going offline). */
+  clear(officeId, agentId) {
+    this.queues.delete(this.key(officeId, agentId));
+  }
+  async drain(k) {
+    if (this.processing.has(k)) return;
+    this.processing.add(k);
+    try {
+      for (; ; ) {
+        const q = this.queues.get(k);
+        const item = q?.shift();
+        if (!item) break;
+        try {
+          await this.process(item);
+        } catch (e) {
+          twarn("dispatch item failed:", e.message);
         }
       }
+    } finally {
+      this.processing.delete(k);
     }
-  } catch {
   }
+};
+
+// electron/teams/channelResolver.ts
+function resolveChannel(office, settings) {
+  const override = office?.teamsChannelUrl?.trim();
+  if (override) return override;
+  return settings?.defaultChannelUrl?.trim() || "";
 }
-var mainWindow = null;
-var watcherProcess = null;
-var relay = new TerminalRelay(() => mainWindow);
-var pendingHardReload = false;
-function startFileWatcher() {
-  const copilotOfficePath = path3.join(process.cwd(), "CopilotOffice");
-  if (!fs2.existsSync(path3.join(copilotOfficePath, "package.json"))) {
-    if (fs2.existsSync(path3.join(process.cwd(), "src", "main.ts"))) {
-      watcherProcess = (0, import_child_process2.spawn)("npx", ["esbuild", "src/main.ts", "--bundle", "--outfile=dist/game.bundle.js", "--platform=browser", "--format=iife", "--global-name=CopilotOffice", "--watch"], {
-        cwd: process.cwd(),
-        shell: true,
-        stdio: "pipe"
-      });
+function activeChannelSet(bindings) {
+  const set = /* @__PURE__ */ new Set();
+  for (const b of bindings) {
+    if (b.online && b.channelId) set.add(b.channelId);
+  }
+  return set;
+}
+function findBinding(channelId, threadRootId, bindings) {
+  return bindings.find(
+    (b) => b.online && b.channelId === channelId && b.threadRootId === threadRootId
+  );
+}
+function classifyThread(channelId, threadRootId, bindings, knownThreads) {
+  if (findBinding(channelId, threadRootId, bindings)) return "bound";
+  if (threadRootId && knownThreads.some((t) => t.threadRootId === threadRootId)) {
+    return "orphaned";
+  }
+  return "foreign";
+}
+
+// electron/teams/messageFilter.ts
+var STALE_MS = 5 * 60 * 1e3;
+var INJECTION_PATTERNS = [
+  /ignore (all |your )?(previous|prior|above) instructions/i,
+  /disregard (the |your )?(system|previous) prompt/i,
+  /reveal (your )?(system )?prompt/i
+];
+function scanInjection(content) {
+  return INJECTION_PATTERNS.some((re) => re.test(content));
+}
+var BOT_DISPLAY_NAMES = /^(flow bot|power automate|microsoft power automate)$/i;
+function isBotSender(msg) {
+  const id = (msg.senderId || "").trim();
+  if (id) return id.includes("28:");
+  return BOT_DISPLAY_NAMES.test((msg.senderName || "").trim());
+}
+var MessageFilter = class _MessageFilter {
+  constructor(nowFn = Date.now) {
+    this.nowFn = nowFn;
+    this.seen = /* @__PURE__ */ new Set();
+    this.seenOrder = [];
+  }
+  static {
+    this.MAX_SEEN = 5e3;
+  }
+  /** Reset dedup memory (e.g. on service restart). */
+  reset() {
+    this.seen.clear();
+    this.seenOrder = [];
+  }
+  remember(id) {
+    this.seen.add(id);
+    this.seenOrder.push(id);
+    if (this.seenOrder.length > _MessageFilter.MAX_SEEN) {
+      const old = this.seenOrder.shift();
+      if (old) this.seen.delete(old);
     }
-  } else {
-    watcherProcess = (0, import_child_process2.spawn)("npx", ["esbuild", "src/main.ts", "--bundle", "--outfile=dist/game.bundle.js", "--platform=browser", "--format=iife", "--global-name=CopilotOffice", "--watch"], {
-      cwd: copilotOfficePath,
-      shell: true,
-      stdio: "pipe"
-    });
   }
-  if (watcherProcess) {
-    watcherProcess.stdout?.on("data", (data) => {
-      const msg = data.toString();
-      console.log("[Watcher]", msg);
-      if (msg.includes("watching") || msg.includes("built")) {
-        if (mainWindow && !mainWindow.isDestroyed()) {
-          mainWindow.webContents.send("build-complete");
-        }
+  evaluate(msg, bindings, knownThreads) {
+    if (msg.messageId) {
+      if (this.seen.has(msg.messageId)) return { action: "ignore", reason: "duplicate" };
+      this.remember(msg.messageId);
+    }
+    if (msg.hasMarker) return { action: "ignore", reason: "self-post" };
+    if (isBotSender(msg)) return { action: "ignore", reason: "bot-sender" };
+    if (msg.composeTime) {
+      const t = Date.parse(msg.composeTime);
+      if (Number.isFinite(t) && this.nowFn() - t > STALE_MS) {
+        return { action: "ignore", reason: "stale" };
       }
-    });
-    watcherProcess.stderr?.on("data", (data) => {
-      console.error("[Watcher Error]", data.toString());
-    });
-    console.log("File watcher started");
+    }
+    const active = activeChannelSet(bindings);
+    if (!active.has(msg.channelId)) return { action: "ignore", reason: "inactive-channel" };
+    if (!msg.threadRootId) return { action: "ignore", reason: "root-message" };
+    const classification = classifyThread(msg.channelId, msg.threadRootId, bindings, knownThreads);
+    if (classification === "foreign") {
+      return { action: "ignore", classification, reason: "foreign-thread" };
+    }
+    if (classification === "orphaned") {
+      return { action: "orphaned-notice", classification, reason: "orphaned-thread" };
+    }
+    if (scanInjection(msg.content)) {
+      return { action: "ignore", classification, reason: "injection-blocked" };
+    }
+    const binding = findBinding(msg.channelId, msg.threadRootId, bindings);
+    return { action: "dispatch", classification, binding };
   }
+};
+
+// electron/teams/handleRegistry.ts
+function normalizeHandle(name) {
+  if (!name) return "";
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function createWindow() {
-  mainWindow = new import_electron3.BrowserWindow({
-    width: 2560,
-    height: 1440,
-    title: "Copilot Office",
-    webPreferences: {
-      preload: path3.join(__dirname, "terminal", "preload.js"),
-      contextIsolation: true,
-      nodeIntegration: false,
-      backgroundThrottling: false
-    }
-  });
-  mainWindow.maximize();
-  mainWindow.loadFile(path3.join(__dirname, "../../src/index.html"));
-  if (OPEN_DEVTOOLS_ON_START) {
-    mainWindow.webContents.openDevTools({ mode: "detach" });
+function assignHandle(base, takenOnline) {
+  if (!base) {
+    throw new Error("Cannot derive a Teams handle from an empty/invalid agent name");
   }
-  mainWindow.webContents.on("did-start-navigation", (_event, _url, isInPlace) => {
-    if (isInPlace && pendingHardReload) {
-      console.log("[Main] Hard reload \u2014 restarting terminal server");
-      pendingHardReload = false;
-      relay.shutdown().then(
-        () => relay.spawnServer(__dirname)
-      ).catch(
-        (e) => console.error("[Main] Failed to respawn after reload:", e)
-      );
-    } else if (isInPlace) {
-      console.log("[Main] Soft reload \u2014 keeping terminal server alive");
+  if (!takenOnline.has(base)) return base;
+  for (let i = 1; ; i++) {
+    const candidate = `${base}-${i}`;
+    if (!takenOnline.has(candidate)) return candidate;
+  }
+}
+
+// electron/teams/channelLink.ts
+function parseChannelLink(url) {
+  if (!url || typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  const teamId = (parsed.searchParams.get("groupId") || "").trim();
+  const tenantId = (parsed.searchParams.get("tenantId") || "").trim();
+  const marker = "/l/channel/";
+  const idx = parsed.pathname.indexOf(marker);
+  let channelId = "";
+  if (idx >= 0) {
+    const rest = parsed.pathname.slice(idx + marker.length);
+    const seg = rest.split("/")[0] || "";
+    try {
+      channelId = decodeURIComponent(seg).trim();
+    } catch {
+      channelId = seg.trim();
     }
+  }
+  if (!teamId || !channelId) return null;
+  if (!/^19:.+@thread\./.test(channelId)) return null;
+  return { teamId, channelId, tenantId };
+}
+
+// electron/teams/chunk.ts
+var DEFAULT_MAX = 3500;
+function chunkReply(text, max = DEFAULT_MAX) {
+  const body = text ?? "";
+  const prefixBudget = 12;
+  const limit = Math.max(1, max - prefixBudget);
+  if (body.length <= limit) {
+    return body.length === 0 ? [""] : [body];
+  }
+  const raw = [];
+  let remaining = body;
+  while (remaining.length > limit) {
+    let cut = remaining.lastIndexOf("\n", limit);
+    if (cut <= 0) cut = limit;
+    raw.push(remaining.slice(0, cut));
+    remaining = remaining.slice(cut).replace(/^\n/, "");
+  }
+  if (remaining.length > 0) raw.push(remaining);
+  const n = raw.length;
+  if (n === 1) return raw;
+  return raw.map((part, i) => `(${i + 1}/${n}) ${part}`);
+}
+
+// electron/teams/htmlText.ts
+function stripHtml(html) {
+  if (!html) return "";
+  return html.replace(/<!--[\s\S]*?-->/g, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+function escapeHtml(text) {
+  return (text ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// electron/teams/imageMarker.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var IMAGE_MARKER_SOURCE = "<!--office-image:(.*?)-->";
+var IMAGE_MARKER_RE = new RegExp(IMAGE_MARKER_SOURCE, "g");
+function extractImageMarkers(input) {
+  const src = input ?? "";
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  const matcher = new RegExp(IMAGE_MARKER_SOURCE, "g");
+  for (const m of src.matchAll(matcher)) {
+    const p = (m[1] ?? "").trim();
+    if (!p || seen.has(p)) continue;
+    seen.add(p);
+    paths.push(p);
+  }
+  const text = src.replace(new RegExp(IMAGE_MARKER_SOURCE, "g"), "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return { text, paths };
+}
+function sniffImageType(buf) {
+  if (buf.length >= 8 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10) {
+    return "image/png";
+  }
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+    return "image/jpeg";
+  }
+  if (buf.length >= 6 && buf[0] === 71 && buf[1] === 73 && buf[2] === 70 && buf[3] === 56 && (buf[4] === 55 || buf[4] === 57) && buf[5] === 97) {
+    return "image/gif";
+  }
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (buf.length >= 2 && buf[0] === 66 && buf[1] === 77) {
+    return "image/bmp";
+  }
+  return null;
+}
+function resolveWithinBase(rawPath, baseDir) {
+  if (!baseDir) return null;
+  if (path5.isAbsolute(rawPath)) return null;
+  const root = path5.resolve(baseDir);
+  const resolved = path5.resolve(root, rawPath);
+  const rel = path5.relative(root, resolved);
+  if (rel === "" || rel.startsWith("..") || path5.isAbsolute(rel)) return null;
+  return resolved;
+}
+var DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
+var DEFAULT_MAX_IMAGES = 8;
+var DEFAULT_MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+async function loadHostedImages(paths, options = {}) {
+  const baseDir = options.baseDir;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const maxImages = options.maxImages ?? DEFAULT_MAX_IMAGES;
+  const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+  const readFile = options.readFile ?? ((p) => fs4.promises.readFile(p));
+  const warn = options.warn ?? (() => {
   });
-  mainWindow.on("closed", () => {
-    if (watcherProcess) {
-      watcherProcess.kill();
-      watcherProcess = null;
+  const images = [];
+  let totalBytes = 0;
+  for (const rawPath of paths) {
+    if (images.length >= maxImages) {
+      warn(`office-image: image count cap (${maxImages}) reached \u2014 ignoring "${rawPath}"`);
+      continue;
     }
-    mainWindow = null;
-  });
+    const absPath = resolveWithinBase(rawPath, baseDir);
+    if (!absPath) {
+      warn(`office-image: rejected path outside agent sandbox: "${rawPath}"`);
+      continue;
+    }
+    try {
+      const buf = await readFile(absPath);
+      if (buf.length === 0) {
+        warn(`office-image: skipping empty file ${absPath}`);
+        continue;
+      }
+      if (buf.length > maxBytes) {
+        warn(`office-image: skipping ${absPath} \u2014 ${buf.length} bytes exceeds ${maxBytes} limit`);
+        continue;
+      }
+      const sniffed = sniffImageType(buf);
+      if (!sniffed) {
+        warn(`office-image: skipping ${absPath} \u2014 not a recognized image (magic-byte check failed)`);
+        continue;
+      }
+      if (totalBytes + buf.length > maxTotalBytes) {
+        warn(`office-image: aggregate byte cap (${maxTotalBytes}) reached \u2014 ignoring ${absPath}`);
+        continue;
+      }
+      totalBytes += buf.length;
+      images.push({
+        id: String(images.length + 1),
+        contentType: sniffed,
+        contentBytesBase64: buf.toString("base64")
+      });
+    } catch (e) {
+      warn(`office-image: could not read ${absPath}: ${e.message}`);
+    }
+  }
+  return images;
 }
-import_electron3.app.whenReady().then(async () => {
-  import_electron3.Menu.setApplicationMenu(null);
-  killOrphanedProcesses();
-  relay.registerIpc();
-  const officeStore = createOfficeFileStore();
-  registerNonTerminalIpc({
-    getMainWindow: () => mainWindow,
-    onHardReloadRequested: () => {
-      pendingHardReload = true;
-    },
-    officeStore
-  });
-  await relay.spawnServer(__dirname);
-  if (ENABLE_FILE_WATCHER) {
-    startFileWatcher();
-  } else {
-    console.log("[Main] File watcher disabled");
+function hostedImagesHtml(images) {
+  return images.map((img) => `<img src="../hostedContents/${img.id}/$value" alt="attachment" style="max-width:100%">`).join("<br>");
+}
+
+// electron/teams/ackQuips.ts
+var ACK_QUIPS = [
+  "Cracking my knuckles\u2026",
+  "Summoning the electrons\u2026",
+  "Bribing the compiler\u2026",
+  "Yelling at the terminal politely\u2026",
+  "Consulting the rubber duck\u2026",
+  "Putting down my coffee\u2026",
+  "Rolling a d20 for initiative\u2026",
+  "Waking up the hamsters\u2026",
+  "Pretending I wasn't slacking\u2026",
+  "Feeding the machine spirit\u2026"
+];
+function pickAckQuip(rng = Math.random) {
+  if (ACK_QUIPS.length === 0) return "Working on this\u2026";
+  return ACK_QUIPS[Math.floor(rng() * ACK_QUIPS.length)] ?? ACK_QUIPS[0];
+}
+
+// electron/teams/teamsService.ts
+var RECONCILE_MS = 15e3;
+var TURN_SETTLE_MS = 2500;
+var TeamsService = class _TeamsService {
+  constructor(deps) {
+    this.deps = deps;
+    this.bindings = [];
+    this.knownThreads = [];
+    this.pending = /* @__PURE__ */ new Map();
+    // key = agentId
+    /**
+     * Ambient (locally-driven) turn accumulators, keyed by agentId. Populated only
+     * when an online agent produces output that was NOT triggered by a Teams dispatch
+     * (i.e. someone drove the agent in the app's own terminal). Streams those turns
+     * into the bound thread so the channel mirrors everything the online agent does,
+     * not just replies to Teams-originated requests. Disjoint from {@link pending}:
+     * an agent with an in-flight Teams dispatch never uses this map.
+     */
+    this.ambient = /* @__PURE__ */ new Map();
+    // key = agentId
+    /**
+     * Message ids of every message the app has posted (thread roots + replies).
+     * Primary self-loop guard: an inbound message whose id is here is our own echo
+     * and is dropped before all other processing. Deterministic — does not depend on
+     * content markers surviving Teams' sanitizer. Capped FIFO to bound memory.
+     */
+    this.postedMessageIds = /* @__PURE__ */ new Set();
+    this.postedOrder = [];
+    this.unsubEvent = null;
+    this.unsubExit = null;
+    this.reconcileTimer = null;
+    this.started = false;
+    this.now = deps.now ?? Date.now;
+    this.settleMs = deps.turnSettleMs ?? TURN_SETTLE_MS;
+    this.filter = new MessageFilter(this.now);
+    this.queue = new DispatchQueue((item) => this.processDispatch(item));
+  }
+  static {
+    this.MAX_POSTED_IDS = 2e3;
+  }
+  // ── Lifecycle ────────────────────────────────────────────────
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    tlog("Service starting\u2026");
+    const state = await this.deps.store.load();
+    const { kept, removed } = gcStale(state.bindings, this.now());
+    this.bindings = kept.map((b) => ({ ...b, online: false }));
+    this.knownThreads = state.knownThreads;
+    tlog(`Loaded ${this.bindings.length} persisted binding(s), ${this.knownThreads.length} known thread(s).`);
+    if (removed.length > 0) {
+      await this.persist();
+      tlog(`GC removed ${removed.length} stale binding(s) (>30 days).`);
+      this.deps.emitToast({
+        level: "info",
+        message: `Teams: cleaned up ${removed.length} stale agent binding(s) (>30 days).`
+      });
+    }
+    this.unsubEvent = this.deps.gateway.onAgentEvent((e) => this.onAgentEvent(e));
+    this.unsubExit = this.deps.gateway.onSessionExit((agentId) => this.onSessionExit(agentId));
+    await this.deps.source.start((m) => {
+      void this.handleInbound(m);
+    });
+    tlog(`Receive transport started (health=${this.deps.source.health}).`);
+    this.reconcileTimer = setInterval(() => void this.reconcile(), RECONCILE_MS);
+    void this.reconcile();
+  }
+  async stop() {
+    this.started = false;
+    if (this.reconcileTimer) clearInterval(this.reconcileTimer);
+    this.reconcileTimer = null;
+    this.unsubEvent?.();
+    this.unsubExit?.();
+    this.unsubEvent = this.unsubExit = null;
+    for (const rec of this.ambient.values()) {
+      if (rec.settleTimer) clearTimeout(rec.settleTimer);
+    }
+    this.ambient.clear();
+    for (const b of this.bindings) {
+      if (b.online) this.deps.gateway.setForwarding(b.officeId, b.agentId, false);
+    }
+    for (const [agentId, rec] of this.pending) {
+      this.queue.clear(rec.officeId, agentId);
+      this.cancelSettle(rec);
+      rec.resolve();
+      this.pending.delete(agentId);
+    }
+    await this.deps.source.stop();
+    tlog("Service stopped.");
+  }
+  // ── Public API (invoked from IPC) ────────────────────────────
+  getStatuses() {
+    return this.bindings.map((b) => this.toStatus(b));
+  }
+  getStatus(officeId, agentId) {
+    const b = this.findBinding(officeId, agentId);
+    return b ? this.toStatus(b) : null;
+  }
+  /** Bring an agent online: resolve channel, create thread, bind, start listening. */
+  async register(ctx) {
+    const { officeId, agentId } = ctx;
+    const settings = this.deps.getSettings();
+    if (!settings.enabled) return { success: false, error: "Teams remote is disabled in settings." };
+    const channelUrl = resolveChannel({ teamsChannelUrl: ctx.officeChannelUrl }, settings);
+    const coords = parseChannelLink(channelUrl);
+    if (!coords) {
+      return { success: false, error: "no-channel" };
+    }
+    tlog(`Register requested: ${ctx.displayName} (${officeId}:${agentId}) \u2192 channel ${coords.channelId}`);
+    const sessionId = await this.deps.gateway.getSessionId(officeId, agentId);
+    if (!sessionId) {
+      return { success: false, error: "No active session for this agent. Open its terminal first." };
+    }
+    const displayName = ctx.displayName || agentId;
+    const workingDir = ctx.workingDir || "";
+    const existing = this.findBinding(officeId, agentId);
+    if (existing && existing.online) {
+      return { success: true, handle: existing.handle, threadWebUrl: existing.threadWebUrl };
+    }
+    const meta = await this.deps.gateway.getSessionMeta(officeId, agentId);
+    const sessionTitle = meta?.title?.trim() || "";
+    const base = normalizeHandle(displayName);
+    let handle;
+    try {
+      handle = assignHandle(base, this.onlineHandles());
+    } catch {
+      return { success: false, error: "Could not derive a valid handle from the agent name." };
+    }
+    const subject = sessionTitle ? `${displayName}: ${sessionTitle}` : `${displayName}: ${handle}`;
+    const introHtml = this.buildIntro({ displayName, workingDir }, handle, sessionTitle);
+    let thread;
+    try {
+      thread = await this.deps.graph.createThread({
+        teamId: coords.teamId,
+        channelId: coords.channelId,
+        subject,
+        html: introHtml
+      });
+    } catch (e) {
+      return { success: false, error: `Failed to create Teams thread: ${e.message}` };
+    }
+    tlog(`Thread created (root=${thread.threadRootId}) for @${handle}.`);
+    this.rememberPosted(thread.threadRootId);
+    const binding = {
+      agentId,
+      officeId,
+      sessionId,
+      handle,
+      displayName,
+      workingDir,
+      sessionTitle,
+      teamId: coords.teamId,
+      channelId: coords.channelId,
+      tenantId: coords.tenantId,
+      threadRootId: thread.threadRootId,
+      threadWebUrl: thread.webUrl,
+      online: true,
+      lastConnected: this.now()
+    };
+    this.bindings = this.bindings.filter((b) => !(b.officeId === officeId && b.agentId === agentId));
+    this.bindings.push(binding);
+    this.rememberThread(thread.threadRootId);
+    await this.persist();
+    this.updateSourceChannels();
+    this.deps.gateway.setForwarding(officeId, agentId, true);
+    this.deps.emitStatus(this.toStatus(binding));
+    tlog(`ONLINE: @${handle} (${officeId}:${agentId}). Active channels: ${activeChannelSet(this.bindings).size}.`);
+    return { success: true, handle, threadWebUrl: thread.webUrl };
+  }
+  /** Take an agent offline (connection only; session untouched). */
+  async goOffline(officeId, agentId, postNotice = true) {
+    const b = this.findBinding(officeId, agentId);
+    if (!b) return { success: true };
+    tlog(`OFFLINE: @${b.handle} (${officeId}:${agentId}).`);
+    if (postNotice && b.online && b.threadRootId) {
+      await this.safeReply(b, "\u{1F50C} This agent has gone offline. Replies here will not be answered.");
+    }
+    this.queue.clear(officeId, agentId);
+    this.deps.gateway.setForwarding(officeId, agentId, false);
+    const amb = this.ambient.get(agentId);
+    if (amb) {
+      if (amb.settleTimer) clearTimeout(amb.settleTimer);
+      this.ambient.delete(agentId);
+    }
+    const inFlight = this.pending.get(agentId);
+    if (inFlight) {
+      this.cancelSettle(inFlight);
+      this.pending.delete(agentId);
+      inFlight.resolve();
+    }
+    this.bindings = this.bindings.filter((x) => !(x.officeId === officeId && x.agentId === agentId));
+    await this.persist();
+    this.updateSourceChannels();
+    this.deps.emitStatus({ agentId, officeId, online: false, handle: b.handle, health: "disconnected" });
+    return { success: true };
+  }
+  // ── Inbound handling ─────────────────────────────────────────
+  async handleInbound(msg) {
+    if (msg.messageId && this.postedMessageIds.has(msg.messageId)) {
+      return;
+    }
+    const result = this.filter.evaluate(msg, this.bindings, this.knownThreads);
+    if (result.action === "ignore") {
+      if (result.reason && result.reason !== "duplicate" && result.reason !== "root-message" && result.reason !== "inactive-channel") {
+        tlog(`Ignored inbound (${result.reason}) from "${msg.senderName}".`);
+      }
+      return;
+    }
+    if (result.action === "orphaned-notice") {
+      tlog(`Orphaned thread ${msg.threadRootId} messaged by "${msg.senderName}" \u2014 posting inactive notice.`);
+      await this.postOrphanedNotice(msg);
+      return;
+    }
+    const binding = result.binding;
+    if (!binding) return;
+    const content = msg.content.trim();
+    if (content === "/stop") {
+      tlog(`/stop received in @${binding.handle}'s thread \u2014 taking offline.`);
+      await this.goOffline(binding.officeId, binding.agentId, true);
+      return;
+    }
+    tlog(`Dispatch: "${msg.senderName}" \u2192 @${binding.handle} (queued=${this.queue.pending(binding.officeId, binding.agentId)}): ${truncate(msg.content, 80)}`);
+    this.queue.enqueue({
+      officeId: binding.officeId,
+      agentId: binding.agentId,
+      sessionId: binding.sessionId,
+      threadRootId: binding.threadRootId,
+      prompt: msg.content,
+      senderName: msg.senderName
+    });
+    if (this.deps.getSettings().ackEnabled) {
+      void this.safeReply(binding, `${this.agentLabel(binding)} \u231B ${escapeHtml(pickAckQuip())} <i>(message received)</i>`);
+    }
+  }
+  async postOrphanedNotice(msg) {
+    const known = this.knownThreads.find((t) => t.threadRootId === msg.threadRootId);
+    if (!known || known.noticePosted) return;
+    known.noticePosted = true;
+    await this.persist();
+    const coords = this.coordsForChannel(msg.channelId);
+    if (!coords) return;
+    try {
+      const posted = await this.deps.graph.replyToThread({
+        teamId: coords.teamId,
+        channelId: msg.channelId,
+        threadRootId: msg.threadRootId,
+        html: "\u2139\uFE0F This thread is no longer active and will not receive responses."
+      });
+      if (posted?.messageId) this.rememberPosted(posted.messageId);
+    } catch (e) {
+      twarn("Failed to post orphaned-thread notice:", e.message);
+    }
+  }
+  // ── Dispatch + response capture ──────────────────────────────
+  processDispatch(item) {
+    return new Promise((resolve2) => {
+      const binding = this.findBinding(item.officeId, item.agentId);
+      if (!this.started || !binding || !binding.online) {
+        resolve2();
+        return;
+      }
+      const record = {
+        officeId: item.officeId,
+        agentId: item.agentId,
+        binding,
+        chunks: [],
+        resolve: resolve2,
+        startedAt: this.now(),
+        lastCheckIn: this.now(),
+        settleTimer: null
+      };
+      this.pending.set(item.agentId, record);
+      this.deps.gateway.setForwarding(item.officeId, item.agentId, true);
+      const label = item.senderName ? `Teams \xB7 ${item.senderName}` : "Teams";
+      this.deps.gateway.submitPrompt(item.officeId, item.agentId, item.prompt, label).catch((e) => {
+        twarn("submitPrompt failed:", e.message);
+        this.pending.delete(item.agentId);
+        resolve2();
+      });
+      setTimeout(() => {
+        if (this.pending.get(item.agentId) === record) {
+          void this.finalizeDispatch(item.agentId);
+        }
+      }, 10 * 60 * 1e3);
+    });
+  }
+  onAgentEvent(e) {
+    const rec = this.pending.get(e.agentId);
+    if (!rec) {
+      this.onAmbientEvent(e);
+      return;
+    }
+    if (e.kind === "message" && e.content) {
+      this.cancelSettle(rec);
+      rec.chunks.push(e.content);
+    } else if (e.kind === "turn-start") {
+      this.cancelSettle(rec);
+    } else if (e.kind === "user-message") {
+      return;
+    } else if (e.kind === "turn-end") {
+      void this.flushTurn(rec);
+      this.scheduleSettle(e.agentId, rec);
+    } else if (e.kind === "tool-start") {
+      this.cancelSettle(rec);
+      void this.maybeCheckIn(rec, e.toolName);
+    }
+  }
+  /** Clear the pending dispatch close-out timer, if armed. */
+  cancelSettle(rec) {
+    if (rec.settleTimer) {
+      clearTimeout(rec.settleTimer);
+      rec.settleTimer = null;
+    }
+  }
+  /** (Re)arm the debounce that closes out the dispatch once the agent goes idle. */
+  scheduleSettle(agentId, rec) {
+    this.cancelSettle(rec);
+    rec.settleTimer = setTimeout(() => {
+      rec.settleTimer = null;
+      void this.finalizeDispatch(agentId);
+    }, this.settleMs);
+  }
+  /**
+   * Post everything accumulated for the current turn as a Teams reply, then clear
+   * the buffer. Does NOT stop forwarding or end the dispatch — a multi-turn
+   * response keeps flushing per turn. No-op when the turn produced no text.
+   */
+  async flushTurn(rec) {
+    const text = rec.chunks.join("\n\n").trim();
+    rec.chunks = [];
+    if (!text) return;
+    const elapsed = Math.round((this.now() - rec.startedAt) / 1e3);
+    tlog(`Reply \u2192 @${rec.binding.handle} thread (${text.length} chars, ${elapsed}s): ${truncate(text, 80)}`);
+    rec.lastReplyText = text;
+    await this.postReply(rec.binding, text);
+  }
+  // ── Ambient (locally-driven) turn streaming ──────────────────
+  /**
+   * Handle a copilot event for an online agent that has NO in-flight Teams dispatch —
+   * i.e. the agent was driven from the app's own terminal. Streams the resulting
+   * request + reply into the bound thread so the channel mirrors everything the online
+   * agent does. Silently ignores agents that are offline / not bound.
+   */
+  onAmbientEvent(e) {
+    const binding = this.bindings.find((b) => b.agentId === e.agentId && b.online);
+    if (!binding) return;
+    if (e.kind === "user-message") {
+      const text = (e.content ?? "").trim();
+      if (text) void this.postLocalRequest(binding, text);
+      return;
+    }
+    if (e.kind === "message" && e.content) {
+      const rec = this.ensureAmbient(e.agentId, binding);
+      this.cancelAmbientSettle(rec);
+      rec.chunks.push(e.content);
+    } else if (e.kind === "turn-start") {
+      const rec = this.ensureAmbient(e.agentId, binding);
+      this.cancelAmbientSettle(rec);
+    } else if (e.kind === "turn-end") {
+      const rec = this.ambient.get(e.agentId);
+      if (!rec) return;
+      void this.flushAmbient(rec);
+      this.scheduleAmbientSettle(e.agentId, rec);
+    }
+  }
+  ensureAmbient(agentId, binding) {
+    let rec = this.ambient.get(agentId);
+    if (!rec) {
+      rec = {
+        officeId: binding.officeId,
+        agentId,
+        binding,
+        chunks: [],
+        startedAt: this.now(),
+        settleTimer: null
+      };
+      this.ambient.set(agentId, rec);
+    }
+    return rec;
+  }
+  cancelAmbientSettle(rec) {
+    if (rec.settleTimer) {
+      clearTimeout(rec.settleTimer);
+      rec.settleTimer = null;
+    }
+  }
+  scheduleAmbientSettle(agentId, rec) {
+    this.cancelAmbientSettle(rec);
+    rec.settleTimer = setTimeout(() => {
+      rec.settleTimer = null;
+      void this.finalizeAmbient(agentId);
+    }, this.settleMs);
+  }
+  /** Post the current ambient turn's accumulated text; clears the buffer. No-op when empty. */
+  async flushAmbient(rec) {
+    const text = rec.chunks.join("\n\n").trim();
+    rec.chunks = [];
+    if (!text) return;
+    const elapsed = Math.round((this.now() - rec.startedAt) / 1e3);
+    tlog(`Local reply \u2192 @${rec.binding.handle} thread (${text.length} chars, ${elapsed}s): ${truncate(text, 80)}`);
+    await this.postReply(rec.binding, text);
+  }
+  /** Close out an ambient turn once the agent goes idle: flush residual text, drop record. */
+  async finalizeAmbient(agentId) {
+    const rec = this.ambient.get(agentId);
+    if (!rec) return;
+    this.cancelAmbientSettle(rec);
+    this.ambient.delete(agentId);
+    await this.flushAmbient(rec);
+  }
+  /** Post a locally-typed user request into the thread, tagged so it's distinct from replies. */
+  async postLocalRequest(binding, text) {
+    const chunks = chunkReply(text, 3500);
+    for (const chunk of chunks) {
+      await this.safeReply(
+        binding,
+        `\u{1F464} <b>Human</b> \u{1F4AC} <i>local request:</i><br>${escapeHtml(chunk).replace(/\n/g, "<br>")}`
+      );
+    }
+  }
+  /**
+   * Close out a dispatch once the agent has gone idle: flush any residual text,
+   * drop the pending record, and resolve the dispatch promise so the per-agent
+   * queue advances. Event mirroring stays on for the agent's whole online lifetime
+   * (it's toggled in register/reconnect ↔ goOffline), so it is NOT disabled here.
+   */
+  async finalizeDispatch(agentId) {
+    const rec = this.pending.get(agentId);
+    if (!rec) return;
+    this.cancelSettle(rec);
+    this.pending.delete(agentId);
+    await this.flushTurn(rec);
+    await this.maybeNotifyComplete(rec);
+    rec.resolve();
+  }
+  /**
+   * Post a single end-of-response notification via the distinct-identity {@link
+   * TeamsServiceDeps.notifier} (relay/Dump channel) so a Power Automate flow re-posts it
+   * under the Flow-bot identity with an @mention. Active only when a notifier is wired and
+   * {@link TeamsServiceDeps.isNotifyActive} is true. Skips silently when the dispatch
+   * produced no text. Never throws — a notification failure must not wedge the queue.
+   */
+  async maybeNotifyComplete(rec) {
+    const notifier = this.deps.notifier;
+    if (!notifier || !(this.deps.isNotifyActive?.() ?? false)) return;
+    if (!rec.lastReplyText) return;
+    const title = (rec.binding.sessionTitle || "").trim();
+    const where = title ? ` in \u201C${escapeHtml(title)}\u201D` : "";
+    const html = `${this.agentLabel(rec.binding)} has finished responding${where}`;
+    try {
+      const posted = await notifier.replyToThread({
+        teamId: rec.binding.teamId,
+        channelId: rec.binding.channelId,
+        threadRootId: rec.binding.threadRootId,
+        html
+      });
+      if (posted?.messageId) this.rememberPosted(posted.messageId);
+    } catch (e) {
+      twarn("completion notify failed:", e.message);
+    }
+  }
+  async maybeCheckIn(rec, toolName) {
+    const settings = this.deps.getSettings();
+    if (!settings.checkInEnabled) return;
+    const t = this.now();
+    if (t - rec.startedAt < settings.checkInThresholdMs) return;
+    if (t - rec.lastCheckIn < settings.checkInThrottleMs) return;
+    rec.lastCheckIn = t;
+    const label = toolName ? ` (running: ${escapeHtml(toolName)})` : "";
+    await this.safeReply(rec.binding, `${this.agentLabel(rec.binding)} \u23F3 Still working\u2026${label}`);
+  }
+  /**
+   * Bold agent-name prefix for every app-posted message. Since replies are posted
+   * under the operator's own Teams identity, this makes automated agent output
+   * visually distinct from messages the operator typed by hand.
+   */
+  agentLabel(binding) {
+    return `\u{1F916} <b>${escapeHtml(binding.displayName)}</b>`;
+  }
+  async postReply(binding, text) {
+    const prefix = this.agentLabel(binding);
+    const { text: cleaned, paths } = extractImageMarkers(text);
+    let images = [];
+    if (paths.length) {
+      tlog(`office-image: @${binding.handle} reply has ${paths.length} sentinel(s): ${paths.join(", ")} (baseDir=${binding.workingDir})`);
+      images = await loadHostedImages(paths, { baseDir: binding.workingDir, warn: (m) => twarn(m) });
+      if (images.length) {
+        tlog(`office-image: loaded ${images.length}/${paths.length} image(s) for @${binding.handle} \u2014 will attach inline.`);
+      } else {
+        twarn(`office-image: no images loaded for @${binding.handle} despite ${paths.length} sentinel(s) \u2014 all paths rejected (see warnings above).`);
+      }
+    }
+    if (cleaned) {
+      const chunks = chunkReply(cleaned, 3500);
+      for (const chunk of chunks) {
+        await this.safeReply(binding, `${prefix}<br>${escapeHtml(chunk).replace(/\n/g, "<br>")}`);
+      }
+    }
+    if (images.length) {
+      tlog(`office-image: posting ${images.length} inline image reply to @${binding.handle} thread.`);
+      await this.safeReply(binding, `${prefix}<br>${hostedImagesHtml(images)}`, images);
+    }
+  }
+  /** Reply to a thread, swallowing errors (logs only) so the queue keeps moving. */
+  async safeReply(binding, html, hostedImages) {
+    try {
+      const posted = await this.deps.graph.replyToThread({
+        teamId: binding.teamId,
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+        html,
+        hostedImages
+      });
+      if (posted?.messageId) this.rememberPosted(posted.messageId);
+    } catch (e) {
+      twarn("replyToThread failed:", e.message);
+    }
+  }
+  // ── Reconnect / teardown reconcile (FR-022/024) ──────────────
+  /**
+   * Run a reconcile pass on demand (e.g. right after the renderer re-attaches
+   * terminal sessions on startup / office switch), so Teams bindings re-online
+   * immediately instead of waiting for the next periodic tick. No-op until started.
+   */
+  async reconcileNow() {
+    if (!this.started) return;
+    await this.reconcile();
+  }
+  async reconcile() {
+    let changed = false;
+    for (const b of [...this.bindings]) {
+      if (!this.started) return;
+      let current = null;
+      try {
+        current = await this.deps.gateway.getSessionId(b.officeId, b.agentId);
+      } catch {
+        continue;
+      }
+      if (!this.started) return;
+      if (b.online) {
+        if (current !== b.sessionId) {
+          tlog(`Session changed for @${b.handle} (${b.sessionId} \u2192 ${current ?? "none"}) \u2014 taking offline (FR-022).`);
+          await this.goOffline(b.officeId, b.agentId, true);
+          changed = true;
+        } else {
+          b.lastConnected = this.now();
+        }
+      } else {
+        if (current && current === b.sessionId) {
+          const ready = await this.deps.gateway.isAgentReady(b.officeId, b.agentId).catch(() => false);
+          if (!ready) continue;
+          if (!this.started) return;
+          b.online = true;
+          b.lastConnected = this.now();
+          this.deps.gateway.setForwarding(b.officeId, b.agentId, true);
+          this.deps.emitStatus(this.toStatus(b));
+          tlog(`Reconnected @${b.handle} to its persisted thread (session ${b.sessionId}).`);
+          void this.safeReply(b, `${this.agentLabel(b)} \u{1F504} Reconnected \u2014 back online and ready. Reply here to continue.`);
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      await this.persist();
+      this.updateSourceChannels();
+    }
+  }
+  async onSessionExit(agentId) {
+    const b = this.bindings.find((x) => x.agentId === agentId && x.online);
+    if (b) {
+      tlog(`Session exited for @${b.handle} \u2014 taking offline.`);
+      await this.goOffline(b.officeId, b.agentId, true);
+    }
+  }
+  // ── Helpers ──────────────────────────────────────────────────
+  buildIntro(info, handle, sessionTitle) {
+    const lines = [
+      `<p>\u{1F7E2} <b>${escapeHtml(info.displayName)}</b> is now online via Copilot Office.</p>`,
+      `<p>Reply in this thread to talk to the agent. Send <code>/stop</code> to take it offline.</p>`,
+      `<ul>`,
+      `<li><b>Handle:</b> ${escapeHtml(handle)}</li>`,
+      `<li><b>Folder:</b> ${escapeHtml(info.workingDir)}</li>`
+    ];
+    if (sessionTitle) lines.push(`<li><b>Session:</b> ${escapeHtml(sessionTitle)}</li>`);
+    lines.push(`</ul>`);
+    return lines.join("");
+  }
+  toStatus(b) {
+    return {
+      agentId: b.agentId,
+      officeId: b.officeId,
+      online: b.online,
+      handle: b.handle,
+      threadWebUrl: b.threadWebUrl,
+      health: b.online ? this.deps.source.health : "disconnected"
+    };
+  }
+  findBinding(officeId, agentId) {
+    return this.bindings.find((b) => b.officeId === officeId && b.agentId === agentId);
+  }
+  onlineHandles() {
+    return new Set(this.bindings.filter((b) => b.online).map((b) => b.handle));
+  }
+  rememberThread(threadRootId) {
+    if (!this.knownThreads.some((t) => t.threadRootId === threadRootId)) {
+      this.knownThreads.push({ threadRootId, noticePosted: false });
+    }
+  }
+  /** Record a message id the app posted, so its Trouter echo is dropped (D9). Capped FIFO. */
+  rememberPosted(messageId) {
+    if (!messageId || this.postedMessageIds.has(messageId)) return;
+    this.postedMessageIds.add(messageId);
+    this.postedOrder.push(messageId);
+    if (this.postedOrder.length > _TeamsService.MAX_POSTED_IDS) {
+      const old = this.postedOrder.shift();
+      if (old) this.postedMessageIds.delete(old);
+    }
+  }
+  coordsForChannel(channelId) {
+    const b = this.bindings.find((x) => x.channelId === channelId);
+    if (b) return { teamId: b.teamId, tenantId: b.tenantId };
+    return null;
+  }
+  /** Push the current active-channel set to a pollable source (chatsvc fallback). */
+  updateSourceChannels() {
+    const src = this.deps.source;
+    if (typeof src.setChannels === "function") {
+      src.setChannels([...activeChannelSet(this.bindings)]);
+    }
+  }
+  async persist() {
+    await this.deps.store.save({ bindings: this.bindings, knownThreads: this.knownThreads });
+  }
+};
+function truncate(text, max) {
+  const oneLine = (text ?? "").replace(/\s+/g, " ").trim();
+  return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max)}\u2026`;
+}
+
+// electron/teams/auth.ts
+var import_child_process3 = require("child_process");
+var RESOURCE_URLS = {
+  graph: "https://graph.microsoft.com",
+  ic3: "https://ic3.teams.office.com"
+};
+var REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function decodeJwtExpMs(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2) return 0;
+    const payload = JSON.parse(
+      Buffer.from(parts[1].replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8")
+    );
+    const exp = Number(payload?.exp);
+    return Number.isFinite(exp) ? exp * 1e3 : 0;
+  } catch {
+    return 0;
+  }
+}
+var defaultAzRunner = (resourceUrl) => new Promise((resolve2, reject) => {
+  const isWin = process.platform === "win32";
+  const azArgs = ["account", "get-access-token", "--resource", resourceUrl, "--output", "json"];
+  const [file, args] = isWin ? [process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `az ${azArgs.join(" ")}`]] : ["az", azArgs];
+  (0, import_child_process3.execFile)(
+    file,
+    args,
+    { windowsHide: true, maxBuffer: 1024 * 1024 },
+    (err, stdout) => {
+      if (err) {
+        reject(new Error(`az token acquisition failed for ${resourceUrl} (${err.message})`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        const token = String(parsed?.accessToken || "");
+        if (!token) {
+          reject(new Error(`az returned no accessToken for ${resourceUrl}`));
+          return;
+        }
+        resolve2(token);
+      } catch {
+        reject(new Error(`Failed to parse az token output for ${resourceUrl}`));
+      }
+    }
+  );
+});
+var AzTokenProvider = class {
+  /**
+   * `runner` is injectable for tests (defaults to the real `az` CLI). `persistence`
+   * (optional) seeds the in-memory cache from an encrypted on-disk store at startup
+   * and is updated on every successful acquisition, so a still-valid token survives
+   * app restarts and avoids a slow `az` cold-start.
+   */
+  constructor(runner = defaultAzRunner, persistence) {
+    this.runner = runner;
+    this.persistence = persistence;
+    this.cache = /* @__PURE__ */ new Map();
+    if (persistence) {
+      try {
+        const loaded = persistence.load();
+        for (const [res, ct] of Object.entries(loaded)) {
+          if (ct && typeof ct.token === "string" && ct.token && typeof ct.expiresAt === "number") {
+            this.cache.set(res, ct);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  saveCache() {
+    if (!this.persistence) return;
+    try {
+      const all = {};
+      for (const [res, ct] of this.cache.entries()) all[res] = ct;
+      this.persistence.save(all);
+    } catch {
+    }
+  }
+  async getToken(resource) {
+    const now = Date.now();
+    const cached = this.cache.get(resource);
+    if (cached && cached.expiresAt - now > REFRESH_BUFFER_MS) {
+      return cached.token;
+    }
+    try {
+      const token = await this.runner(RESOURCE_URLS[resource]);
+      const expMs = decodeJwtExpMs(token);
+      const expiresAt = expMs > 0 ? expMs : now + 30 * 60 * 1e3;
+      this.cache.set(resource, { token, expiresAt });
+      this.saveCache();
+      tlog(`Acquired ${resource} token (expires ${new Date(expiresAt).toISOString()}).`);
+      return token;
+    } catch (e) {
+      if (cached && cached.expiresAt > now) {
+        twarn(`Token refresh failed for ${resource}; reusing cached token.`);
+        return cached.token;
+      }
+      throw e;
+    }
+  }
+};
+
+// electron/teams/tokenCacheStore.ts
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var RESOURCES = ["graph", "ic3"];
+function createSafeStorageTokenPersistence(filePath, safeStorage2, opts = {}) {
+  const fsLike = opts.fsLike ?? fs5;
+  const now = opts.now ?? Date.now;
+  return {
+    load() {
+      try {
+        if (!safeStorage2.isEncryptionAvailable()) return {};
+        if (!fsLike.existsSync(filePath)) return {};
+        const buf = fsLike.readFileSync(filePath);
+        const json = safeStorage2.decryptString(buf);
+        const parsed = JSON.parse(json);
+        const out = {};
+        for (const res of RESOURCES) {
+          const ct = parsed?.[res];
+          if (ct && typeof ct.token === "string" && ct.token && typeof ct.expiresAt === "number" && ct.expiresAt > now()) {
+            out[res] = { token: ct.token, expiresAt: ct.expiresAt };
+          }
+        }
+        return out;
+      } catch {
+        try {
+          fsLike.rmSync(filePath, { force: true });
+        } catch {
+        }
+        return {};
+      }
+    },
+    save(all) {
+      try {
+        if (!safeStorage2.isEncryptionAvailable()) return;
+        const json = JSON.stringify(all);
+        const enc = safeStorage2.encryptString(json);
+        fsLike.mkdirSync(path6.dirname(filePath), { recursive: true });
+        fsLike.writeFileSync(filePath, enc);
+      } catch {
+      }
+    }
+  };
+}
+
+// electron/teams/marker.ts
+var TEAMS_MARKER = "copilotoffice-agent-post-v1";
+var ZW_MARKER = "\u200B\u200C\u200D\u200B\u200C\u200D";
+function embedMarker(html) {
+  if (hasMarker(html)) return html;
+  const body = html ?? "";
+  const firstTag = body.match(/^\s*<[a-zA-Z][^>]*>/);
+  if (firstTag) {
+    const insertAt = firstTag.index + firstTag[0].length;
+    return body.slice(0, insertAt) + ZW_MARKER + body.slice(insertAt);
+  }
+  return ZW_MARKER + body;
+}
+function hasMarker(content) {
+  if (!content) return false;
+  return content.includes(ZW_MARKER) || content.includes(TEAMS_MARKER);
+}
+
+// electron/teams/graphClient.ts
+function buildHostedContents(images) {
+  if (!images || images.length === 0) return void 0;
+  return images.map((img) => ({
+    "@microsoft.graph.temporaryId": img.id,
+    contentBytes: img.contentBytesBase64,
+    contentType: img.contentType
+  }));
+}
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+var GraphClient = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  async authHeaders() {
+    const token = await this.tokens.getToken("graph");
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async createThread(p) {
+    const url = `${GRAPH_BASE}/teams/${encodeURIComponent(p.teamId)}/channels/${encodeURIComponent(
+      p.channelId
+    )}/messages`;
+    const body = {
+      subject: p.subject,
+      body: { contentType: "html", content: embedMarker(p.html) }
+    };
+    const hostedContents = buildHostedContents(p.hostedImages);
+    if (hostedContents) body.hostedContents = hostedContents;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: await this.authHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Graph createThread failed: ${res.status} ${await safeText(res)}`);
+    }
+    const json = await res.json();
+    if (!json.id) throw new Error("Graph createThread: response missing message id");
+    return { threadRootId: json.id, webUrl: json.webUrl || "" };
+  }
+  async replyToThread(p) {
+    const url = `${GRAPH_BASE}/teams/${encodeURIComponent(p.teamId)}/channels/${encodeURIComponent(
+      p.channelId
+    )}/messages/${encodeURIComponent(p.threadRootId)}/replies`;
+    const body = { body: { contentType: "html", content: embedMarker(p.html) } };
+    const hostedContents = buildHostedContents(p.hostedImages);
+    if (hostedContents) body.hostedContents = hostedContents;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: await this.authHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Graph replyToThread failed: ${res.status} ${await safeText(res)}`);
+    }
+    const json = await res.json();
+    return { messageId: json.id || "" };
+  }
+  async listChannels(teamId) {
+    const url = `${GRAPH_BASE}/teams/${encodeURIComponent(teamId)}/channels`;
+    const res = await fetch(url, { headers: await this.authHeaders() });
+    if (!res.ok) throw new Error(`Graph listChannels failed: ${res.status}`);
+    const json = await res.json();
+    return json.value || [];
+  }
+  /** List a team's tags (id + displayName) — used to resolve a tag name to its tagId. */
+  async listTags(teamId) {
+    const url = `${GRAPH_BASE}/teams/${encodeURIComponent(teamId)}/tags?$select=id,displayName`;
+    const res = await fetch(url, { headers: await this.authHeaders() });
+    if (!res.ok) throw new Error(`Graph listTags failed: ${res.status} ${await safeText(res)}`);
+    const json = await res.json();
+    return json.value || [];
+  }
+  /**
+   * Resolve a user reference to an AAD object id. A UPN (contains '@') or a GUID is
+   * looked up / passed through directly; anything else is treated as a display name and
+   * matched (exact, case-insensitive) against Graph. Returns '' when unresolved.
+   */
+  async findUserId(query) {
+    const q = query.trim();
+    if (!q) return "";
+    const isGuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(q);
+    const isUpn = q.includes("@");
+    if (isGuid || isUpn) {
+      const url2 = `${GRAPH_BASE}/users/${encodeURIComponent(q)}?$select=id`;
+      const res2 = await fetch(url2, { headers: await this.authHeaders() });
+      if (!res2.ok) return "";
+      const json2 = await res2.json();
+      return json2.id || "";
+    }
+    const filter = `displayName eq '${q.replace(/'/g, "''")}'`;
+    const url = `${GRAPH_BASE}/users?$filter=${encodeURIComponent(filter)}&$select=id&$top=1`;
+    const res = await fetch(url, { headers: await this.authHeaders() });
+    if (!res.ok) return "";
+    const json = await res.json();
+    return json.value?.[0]?.id || "";
+  }
+};
+async function safeText(res) {
+  try {
+    return (await res.text()).slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+
+// electron/teams/trouterClient.ts
+var import_ws = __toESM(require("ws"));
+var crypto3 = __toESM(require("crypto"));
+var DEFAULT_GATEWAY = "go-msit.trouter.teams.microsoft.com";
+var V2_REGISTRAR = "https://teams.cloud.microsoft/registrar/prod/V2/registrations";
+var ORIGIN = "https://teams.cloud.microsoft";
+var HEARTBEAT_MS = 3e4;
+var REREGISTER_MS = 45 * 60 * 1e3;
+function extractThreadRootId(conversationLink) {
+  if (!conversationLink) return "";
+  const m = /;messageid=([^;&/?]+)/i.exec(conversationLink);
+  return m ? m[1] : "";
+}
+function extractChannelId(conversationLink) {
+  if (!conversationLink) return "";
+  let convo = conversationLink;
+  const idx = convo.indexOf("/conversations/");
+  if (idx >= 0) convo = convo.slice(idx + "/conversations/".length);
+  convo = convo.split(";")[0];
+  try {
+    convo = decodeURIComponent(convo);
+  } catch {
+  }
+  return convo;
+}
+function parseFrame(raw) {
+  if (raw.startsWith("1::")) return { type: "connect" };
+  if (raw.startsWith("5")) {
+    const m = /^5(?::[^:]*)?::([\s\S]*)$/.exec(raw);
+    if (m) {
+      try {
+        return { type: "event", payload: JSON.parse(m[1]) };
+      } catch {
+        return { type: "event", payload: m[1] };
+      }
+    }
+  }
+  if (raw.startsWith("3:::")) {
+    try {
+      return { type: "message", payload: JSON.parse(raw.slice(4)) };
+    } catch {
+      return { type: "message", payload: raw.slice(4) };
+    }
+  }
+  if (raw.startsWith("6:::")) return { type: "ack", payload: raw.slice(4) };
+  return { type: "unknown", payload: raw };
+}
+function parseEventMessage(body) {
+  let data = body;
+  if (typeof data === "string") {
+    try {
+      data = JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  const d = data;
+  if (!d || d.type !== "EventMessage" || d.resourceType !== "NewMessage") return null;
+  const resource = d.resource || {};
+  const convLink = String(resource.conversationLink || "");
+  const content = String(resource.content || "");
+  return {
+    messageId: String(resource.id || ""),
+    channelId: extractChannelId(convLink),
+    threadRootId: extractThreadRootId(convLink),
+    senderName: String(resource.imdisplayname || ""),
+    senderId: String(resource.from || ""),
+    content: stripHtml(content),
+    composeTime: String(resource.composetime || ""),
+    hasMarker: hasMarker(content)
+  };
+}
+var TrouterClient = class {
+  constructor(tokens, gateway = DEFAULT_GATEWAY) {
+    this.tokens = tokens;
+    this.gateway = gateway;
+    this.health = "disconnected";
+    this.ws = null;
+    this.running = false;
+    this.frameCounter = 0;
+    this.surl = "";
+    this.registrarUrl = "";
+    this.registrationId = "";
+    this.heartbeatTimer = null;
+    this.reregisterTimer = null;
+    this.reconnectTimer = null;
+    this.onMessage = null;
+  }
+  async start(onMessage) {
+    this.onMessage = onMessage;
+    this.running = true;
+    await this.connect();
+  }
+  async stop() {
+    this.running = false;
+    this.clearTimers();
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.health = "disconnected";
+  }
+  clearTimers() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.reregisterTimer) clearInterval(this.reregisterTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.heartbeatTimer = this.reregisterTimer = null;
+    this.reconnectTimer = null;
+  }
+  scheduleReconnect() {
+    if (!this.running || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.running) this.connect().catch((e) => twarn("Trouter reconnect failed:", e.message));
+    }, 5e3);
+  }
+  async connect() {
+    const token = await this.tokens.getToken("ic3");
+    const epid = crypto3.randomUUID();
+    this.registrationId = epid;
+    const tc = JSON.stringify({ cv: "2026.03.01.1", ua: "TeamsCDL", hr: "", v: "1415/26020101120" });
+    const qs = new URLSearchParams({
+      tc,
+      timeout: "40",
+      epid,
+      ccid: "",
+      dom: "teams.cloud.microsoft",
+      cor_id: crypto3.randomUUID(),
+      con_num: `${Date.now()}_0`
+    });
+    const wsUrl = `wss://${this.gateway}/v4/c?${qs.toString()}`;
+    const ws = new import_ws.default(wsUrl, { headers: { Origin: ORIGIN }, maxPayload: 2 ** 22 });
+    this.ws = ws;
+    ws.on("open", () => {
+    });
+    ws.on("message", (data) => {
+      this.handleRaw(String(data), token, epid).catch(
+        (e) => twarn("Trouter frame handler error:", e.message)
+      );
+    });
+    ws.on("error", (err) => {
+      this.health = "error";
+      twarn("Trouter socket error:", err.message);
+    });
+    ws.on("close", () => {
+      this.health = "disconnected";
+      this.clearTimers();
+      this.scheduleReconnect();
+    });
+  }
+  send(frame) {
+    if (this.ws && this.ws.readyState === import_ws.default.OPEN) this.ws.send(frame);
+  }
+  async handleRaw(raw, token, epid) {
+    const { type, payload } = parseFrame(raw);
+    if (type === "connect") {
+      const now = Math.floor(Date.now() / 1e3);
+      const auth = JSON.stringify({
+        name: "user.authenticate",
+        args: [
+          {
+            headers: {
+              "X-Ms-Test-User": "False",
+              Authorization: `Bearer ${token}`,
+              "X-MS-Migration": "True"
+            },
+            connectparams: {
+              issuer: "",
+              scae: "1",
+              sig: "",
+              sr: epid,
+              sp: "",
+              se: String((now + 600) * 1e3),
+              st: String(now * 1e3)
+            }
+          }
+        ]
+      });
+      this.send(`5:::${auth}`);
+      return;
+    }
+    if (type === "event" && payload && typeof payload === "object") {
+      const evt = payload;
+      if (evt.name === "trouter.connected") {
+        const info = evt.args?.[0] || {};
+        this.surl = info.surl || "";
+        this.registrarUrl = info.registrarUrl || V2_REGISTRAR;
+        this.health = "connected";
+        tlog("Trouter connected \u2014 registering for channel push\u2026");
+        await this.register(token);
+        this.startHeartbeat(token);
+        return;
+      }
+      if (evt.name === "ping") {
+        this.frameCounter += 1;
+        this.send(`6:::${this.frameCounter}["pong"]`);
+        return;
+      }
+      if (evt.name === "trouter.message_loss") {
+        this.frameCounter += 1;
+        const ack = JSON.stringify({ name: "trouter.processed_message_loss", args: evt.args || [{}] });
+        this.send(`5:${this.frameCounter}+::${ack}`);
+        return;
+      }
+      return;
+    }
+    if (type === "message" && payload && typeof payload === "object") {
+      const msg = payload;
+      if (msg.id) {
+        const ack = JSON.stringify({ id: msg.id, status: 200, headers: {}, body: "" });
+        this.send(`3:::${ack}`);
+      }
+      const inbound = parseEventMessage(msg.body);
+      if (!inbound || !this.onMessage) return;
+      this.onMessage(inbound);
+    }
+  }
+  startHeartbeat(token) {
+    this.clearTimers();
+    this.heartbeatTimer = setInterval(() => {
+      this.frameCounter += 1;
+      this.send(`5:${this.frameCounter}+::{"name":"ping"}`);
+    }, HEARTBEAT_MS);
+    this.reregisterTimer = setInterval(() => {
+      this.register(token).catch((e) => twarn("Trouter re-register failed:", e.message));
+    }, REREGISTER_MS);
+  }
+  async register(token) {
+    const payload = {
+      clientDescription: {
+        appId: "TeamsCDLWebWorker",
+        aesKey: "",
+        languageId: "en-US",
+        platform: "edge",
+        templateKey: "TeamsCDLWebWorker_2.6",
+        platformUIVersion: "1415/26020101120"
+      },
+      registrationId: this.registrationId,
+      nodeId: "",
+      transports: { TROUTER: [{ context: "", path: this.surl, ttl: 3600 }] }
+    };
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Origin: ORIGIN
+    };
+    const urls = Array.from(new Set([this.registrarUrl, V2_REGISTRAR].filter(Boolean)));
+    for (const url of urls) {
+      try {
+        const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
+        if (!res.ok && res.status !== 202) {
+          twarn(`Registrar ${url.slice(0, 60)} returned ${res.status}`);
+        }
+      } catch (e) {
+        twarn(`Registrar ${url.slice(0, 60)} failed:`, e.message);
+      }
+    }
+  }
+};
+
+// electron/teams/sessionGateway.ts
+var RelaySessionGateway = class {
+  constructor(relay2) {
+    this.relay = relay2;
+  }
+  getSessionId(officeId, agentId) {
+    return this.relay.mainGetSessionId(officeId, agentId);
+  }
+  getSessionMeta(officeId, agentId) {
+    return this.relay.mainGetSessionMeta(officeId, agentId);
+  }
+  isAgentReady(officeId, agentId) {
+    return this.relay.mainIsAgentReady(officeId, agentId);
+  }
+  async submitPrompt(officeId, agentId, prompt, label) {
+    const res = await this.relay.mainSubmitPrompt(officeId, agentId, prompt, label);
+    if (!res.success) {
+      throw new Error(res.error || `Failed to submit prompt to ${officeId}:${agentId}`);
+    }
+  }
+  setForwarding(officeId, agentId, enabled) {
+    this.relay.mainSetAgentForwarding(officeId, agentId, enabled);
+  }
+  onAgentEvent(cb) {
+    const onCopilotEvent = (...args) => {
+      const agentId = args[0];
+      const event = args[1];
+      if (event?.type === "assistant.message") {
+        const content = extractMessageContent(event);
+        if (content) cb({ agentId, kind: "message", content });
+      }
+    };
+    const onTurnStart = (...args) => cb({ agentId: args[0], kind: "turn-start" });
+    const onTurnEnd = (...args) => cb({ agentId: args[0], kind: "turn-end" });
+    const onToolStart = (...args) => cb({ agentId: args[0], kind: "tool-start", toolName: args[1] });
+    const onUserMessage = (...args) => cb({ agentId: args[0], kind: "user-message", content: args[1] ?? "" });
+    this.relay.mainEvents.on("copilot-event", onCopilotEvent);
+    this.relay.mainEvents.on("copilot-turn-start", onTurnStart);
+    this.relay.mainEvents.on("copilot-turn-end", onTurnEnd);
+    this.relay.mainEvents.on("copilot-tool-start", onToolStart);
+    this.relay.mainEvents.on("copilot-user-message", onUserMessage);
+    return () => {
+      this.relay.mainEvents.off("copilot-event", onCopilotEvent);
+      this.relay.mainEvents.off("copilot-turn-start", onTurnStart);
+      this.relay.mainEvents.off("copilot-turn-end", onTurnEnd);
+      this.relay.mainEvents.off("copilot-tool-start", onToolStart);
+      this.relay.mainEvents.off("copilot-user-message", onUserMessage);
+    };
+  }
+  onSessionExit(cb) {
+    const onExit = (...args) => cb(args[0]);
+    this.relay.mainEvents.on("terminal-exit", onExit);
+    return () => this.relay.mainEvents.off("terminal-exit", onExit);
+  }
+};
+function extractMessageContent(event) {
+  const data = event?.data ?? {};
+  const content = data.content ?? data.text ?? data.message;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => typeof c === "string" ? c : c?.text).filter((s) => typeof s === "string").join("");
+  }
+  return "";
+}
+
+// electron/teams/teamsSettingsStore.ts
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var DEFAULT_TEAMS_SETTINGS = {
+  enabled: false,
+  defaultChannelUrl: "",
+  relayChannelUrl: "",
+  relayMentionType: "none",
+  relayMentionValue: "",
+  notifyOnCompleteEnabled: true,
+  ackEnabled: true,
+  checkInEnabled: true,
+  checkInThresholdMs: 12e4,
+  checkInThrottleMs: 6e4
+};
+function normalizeTeamsSettings(partial) {
+  return {
+    enabled: partial?.enabled ?? DEFAULT_TEAMS_SETTINGS.enabled,
+    defaultChannelUrl: partial?.defaultChannelUrl ?? DEFAULT_TEAMS_SETTINGS.defaultChannelUrl,
+    relayChannelUrl: partial?.relayChannelUrl ?? DEFAULT_TEAMS_SETTINGS.relayChannelUrl,
+    relayMentionType: partial?.relayMentionType ?? DEFAULT_TEAMS_SETTINGS.relayMentionType,
+    relayMentionValue: partial?.relayMentionValue ?? DEFAULT_TEAMS_SETTINGS.relayMentionValue,
+    notifyOnCompleteEnabled: partial?.notifyOnCompleteEnabled ?? DEFAULT_TEAMS_SETTINGS.notifyOnCompleteEnabled,
+    ackEnabled: partial?.ackEnabled ?? DEFAULT_TEAMS_SETTINGS.ackEnabled,
+    checkInEnabled: partial?.checkInEnabled ?? DEFAULT_TEAMS_SETTINGS.checkInEnabled,
+    checkInThresholdMs: partial?.checkInThresholdMs ?? DEFAULT_TEAMS_SETTINGS.checkInThresholdMs,
+    checkInThrottleMs: partial?.checkInThrottleMs ?? DEFAULT_TEAMS_SETTINGS.checkInThrottleMs
+  };
+}
+function createTeamsSettingsStore(cwd = process.cwd()) {
+  const dataDir = path7.join(cwd, ".data");
+  const filePath = path7.join(dataDir, "teams-settings.json");
+  return {
+    filePath,
+    load() {
+      try {
+        if (!fs6.existsSync(filePath)) return { ...DEFAULT_TEAMS_SETTINGS };
+        return normalizeTeamsSettings(JSON.parse(fs6.readFileSync(filePath, "utf8")));
+      } catch {
+        return { ...DEFAULT_TEAMS_SETTINGS };
+      }
+    },
+    save(settings) {
+      fs6.mkdirSync(dataDir, { recursive: true });
+      fs6.writeFileSync(filePath, JSON.stringify(normalizeTeamsSettings(settings), null, 2), "utf8");
+    }
+  };
+}
+
+// electron/teams/channelAllowlist.ts
+function allowedChannelIdSet(defaultChannelUrl, overrideUrls = []) {
+  const set = /* @__PURE__ */ new Set();
+  for (const url of [defaultChannelUrl, ...overrideUrls]) {
+    const trimmed = (url ?? "").trim();
+    if (!trimmed) continue;
+    const coords = parseChannelLink(trimmed);
+    if (coords?.channelId) set.add(coords.channelId);
+  }
+  return set;
+}
+function createAllowlistedGraphSender(inner, getAllowed) {
+  const assertAllowed = (channelId, op) => {
+    if (!getAllowed().has(channelId)) {
+      throw new Error(
+        `Teams outbound blocked: channel ${channelId} is not in the settings/overrides allowlist (${op}).`
+      );
+    }
+  };
+  const wrapped = {
+    createThread: async (p) => {
+      assertAllowed(p.channelId, "createThread");
+      return inner.createThread(p);
+    },
+    replyToThread: async (p) => {
+      assertAllowed(p.channelId, "replyToThread");
+      return inner.replyToThread(p);
+    }
+  };
+  if (inner.listChannels) {
+    wrapped.listChannels = (teamId) => inner.listChannels(teamId);
+  }
+  return wrapped;
+}
+function officeChannelOverridesFromJson(json) {
+  if (!json) return [];
+  try {
+    const record = JSON.parse(json);
+    const offices = Array.isArray(record?.offices) ? record.offices : [];
+    const urls = [];
+    for (const o of offices) {
+      const u = o?.teamsChannelUrl;
+      if (typeof u === "string" && u.trim()) urls.push(u.trim());
+    }
+    return urls;
+  } catch {
+    return [];
+  }
+}
+function createCachedAllowedChannels(compute, ttlMs = 2e3, now = Date.now) {
+  let cached = null;
+  let computedAt = 0;
+  return () => {
+    const t = now();
+    if (cached && t - computedAt < ttlMs) return cached;
+    try {
+      cached = compute();
+      computedAt = t;
+    } catch {
+      if (!cached) cached = /* @__PURE__ */ new Set();
+    }
+    return cached;
+  };
+}
+
+// electron/teams/relaySender.ts
+var META_OPEN = "[[CO-META]]";
+var META_CLOSE = "[[/CO-META]]";
+function stripMetaMarkers(html) {
+  let out = html;
+  let prev;
+  do {
+    prev = out;
+    out = out.split(META_OPEN).join("").split(META_CLOSE).join("");
+  } while (out !== prev);
+  return out;
+}
+function encodeMetaBlock(meta) {
+  const b64 = Buffer.from(JSON.stringify(meta), "utf8").toString("base64");
+  return `<p>${META_OPEN}${b64}${META_CLOSE}</p>`;
+}
+function createRelaySender(opts) {
+  const resolveDump = () => {
+    const url = opts.getDumpChannelUrl().trim();
+    if (!url) throw new Error("Teams Dump channel URL is not configured.");
+    const coords = parseChannelLink(url);
+    if (!coords) throw new Error("Teams Dump channel URL could not be parsed.");
+    return { teamId: coords.teamId, channelId: coords.channelId };
+  };
+  const postToDump = async (dest, title, html, hostedImages) => {
+    if (!opts.isDestinationAllowed(dest.channelId)) {
+      throw new Error(
+        `Teams outbound blocked: destination channel ${dest.channelId} is not in the allowlist (relay).`
+      );
+    }
+    const dump = resolveDump();
+    let resolved = { mentionType: "none", mentionId: "" };
+    const ref = opts.getMention();
+    if (ref && ref.type !== "none" && ref.value.trim()) {
+      try {
+        resolved = await opts.resolveMention({ type: ref.type, value: ref.value.trim() }, dest.teamId);
+      } catch (err) {
+        tlog(`Relay mention resolution failed (${err.message}); posting without mention.`);
+        resolved = { mentionType: "none", mentionId: "" };
+      }
+    }
+    const humanHtml = embedMarker(stripMetaMarkers(html));
+    const meta = {
+      v: 1,
+      destTeamId: dest.teamId,
+      destChannelId: dest.channelId,
+      threadRootId: dest.threadRootId,
+      mentionType: resolved.mentionType,
+      mentionId: resolved.mentionId,
+      title,
+      html: humanHtml
+    };
+    const body = `${humanHtml}${encodeMetaBlock(meta)}`;
+    await opts.primary.createThread({
+      teamId: dump.teamId,
+      channelId: dump.channelId,
+      subject: "CopilotOffice",
+      html: body,
+      hostedImages
+    });
+    tlog(`Relay post to Dump channel ok (dest=${dest.channelId}, thread=${dest.threadRootId || "root"}, mention=${resolved.mentionType}).`);
+  };
+  return {
+    async createThread(p) {
+      await postToDump({ teamId: p.teamId, channelId: p.channelId, threadRootId: "" }, p.subject, p.html, p.hostedImages);
+      return { threadRootId: "", webUrl: "" };
+    },
+    async replyToThread(p) {
+      await postToDump(
+        { teamId: p.teamId, channelId: p.channelId, threadRootId: p.threadRootId },
+        "",
+        p.html,
+        p.hostedImages
+      );
+      return { messageId: "" };
+    }
+  };
+}
+
+// electron/teams/teamsIpc.ts
+var import_electron3 = require("electron");
+function registerTeamsIpc(hooks) {
+  const { service, settingsStore } = hooks;
+  import_electron3.ipcMain.handle("teams:status", (_e, args) => {
+    if (args?.officeId && args?.agentId) {
+      const status = service.getStatus(args.officeId, args.agentId);
+      return { success: true, connected: !!status?.online, bindings: status ? [status] : [] };
+    }
+    const bindings = service.getStatuses();
+    return { success: true, connected: bindings.some((b) => b.online), bindings };
+  });
+  import_electron3.ipcMain.handle("teams:register", (_e, ctx) => service.register(ctx));
+  import_electron3.ipcMain.handle(
+    "teams:stop",
+    (_e, args) => service.goOffline(args.officeId, args.agentId, true)
+  );
+  import_electron3.ipcMain.handle("teams:reconcile", async () => {
+    await service.reconcileNow();
+    return { success: true };
+  });
+  import_electron3.ipcMain.handle("teams:getSettings", () => {
+    return { success: true, settings: settingsStore.load() };
+  });
+  import_electron3.ipcMain.handle("teams:saveSettings", (_e, args) => {
+    const settings = normalizeTeamsSettings(args?.settings);
+    let parsed;
+    if (settings.defaultChannelUrl.trim()) {
+      const coords = parseChannelLink(settings.defaultChannelUrl);
+      if (!coords) {
+        return { success: false, error: "The default channel link could not be parsed." };
+      }
+      parsed = coords;
+    }
+    if (settings.relayChannelUrl.trim()) {
+      if (!parseChannelLink(settings.relayChannelUrl)) {
+        return { success: false, error: "The relay trigger channel link could not be parsed." };
+      }
+    }
+    settingsStore.save(settings);
+    hooks.onSettingsChanged?.(settings);
+    return { success: true, parsed };
+  });
+}
+function makeStatusEmitter(getWindow) {
+  return (status) => {
+    const win = getWindow();
+    if (win && !win.isDestroyed()) win.webContents.send("teams:status:changed", status);
+  };
+}
+function makeToastEmitter(getWindow) {
+  return (toast) => {
+    const win = getWindow();
+    if (win && !win.isDestroyed()) win.webContents.send("teams:toast", toast);
+  };
+}
+
+// electron/main.ts
+var OPEN_DEVTOOLS_ON_START = process.env.COPILOT_OFFICE_OPEN_DEVTOOLS !== "0";
+var ENABLE_FILE_WATCHER = process.env.COPILOT_OFFICE_ENABLE_WATCHER !== "0";
+function killOrphanedProcesses() {
+  try {
+    const { reaped, skipped } = reapRegisteredPtys();
+    if (reaped.length > 0) {
+      console.log(`[Main] Reaped ${reaped.length} orphaned PTY process tree(s):`, reaped);
+    }
+    if (skipped.length > 0) {
+      console.log(`[Main] Skipped ${skipped.length} already-dead PTY record(s) from registry`);
+    }
+  } catch {
+  }
+}
+var mainWindow = null;
+var watcherProcess = null;
+var relay = new TerminalRelay(() => mainWindow);
+var teamsService = null;
+var pendingHardReload = false;
+function startFileWatcher() {
+  const copilotOfficePath = path8.join(process.cwd(), "CopilotOffice");
+  if (!fs7.existsSync(path8.join(copilotOfficePath, "package.json"))) {
+    if (fs7.existsSync(path8.join(process.cwd(), "src", "main.ts"))) {
+      watcherProcess = (0, import_child_process4.spawn)("npx", ["esbuild", "src/main.ts", "--bundle", "--outfile=dist/game.bundle.js", "--platform=browser", "--format=iife", "--global-name=CopilotOffice", "--watch"], {
+        cwd: process.cwd(),
+        shell: true,
+        stdio: "pipe"
+      });
+    }
+  } else {
+    watcherProcess = (0, import_child_process4.spawn)("npx", ["esbuild", "src/main.ts", "--bundle", "--outfile=dist/game.bundle.js", "--platform=browser", "--format=iife", "--global-name=CopilotOffice", "--watch"], {
+      cwd: copilotOfficePath,
+      shell: true,
+      stdio: "pipe"
+    });
+  }
+  if (watcherProcess) {
+    watcherProcess.stdout?.on("data", (data) => {
+      const msg = data.toString();
+      console.log("[Watcher]", msg);
+      if (msg.includes("watching") || msg.includes("built")) {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send("build-complete");
+        }
+      }
+    });
+    watcherProcess.stderr?.on("data", (data) => {
+      console.error("[Watcher Error]", data.toString());
+    });
+    console.log("File watcher started");
+  }
+}
+function createWindow() {
+  mainWindow = new import_electron4.BrowserWindow({
+    width: 2560,
+    height: 1440,
+    title: "Copilot Office",
+    webPreferences: {
+      preload: path8.join(__dirname, "terminal", "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      backgroundThrottling: false
+    }
+  });
+  mainWindow.maximize();
+  mainWindow.loadFile(path8.join(__dirname, "../../src/index.html"));
+  if (OPEN_DEVTOOLS_ON_START) {
+    mainWindow.webContents.openDevTools({ mode: "detach" });
+  }
+  mainWindow.webContents.on("did-start-navigation", (_event, _url, isInPlace) => {
+    if (isInPlace && pendingHardReload) {
+      console.log("[Main] Hard reload \u2014 restarting terminal server");
+      pendingHardReload = false;
+      relay.shutdown().then(
+        () => relay.spawnServer(__dirname)
+      ).catch(
+        (e) => console.error("[Main] Failed to respawn after reload:", e)
+      );
+    } else if (isInPlace) {
+      console.log("[Main] Soft reload \u2014 keeping terminal server alive");
+    }
+  });
+  mainWindow.on("closed", () => {
+    if (watcherProcess) {
+      watcherProcess.kill();
+      watcherProcess = null;
+    }
+    mainWindow = null;
+  });
+}
+import_electron4.app.whenReady().then(async () => {
+  import_electron4.Menu.setApplicationMenu(null);
+  killOrphanedProcesses();
+  relay.registerIpc();
+  const officeStore = createOfficeFileStore();
+  registerNonTerminalIpc({
+    getMainWindow: () => mainWindow,
+    onHardReloadRequested: () => {
+      pendingHardReload = true;
+    },
+    officeStore
+  });
+  await relay.spawnServer(__dirname);
+  if (ENABLE_FILE_WATCHER) {
+    startFileWatcher();
+  } else {
+    console.log("[Main] File watcher disabled");
+  }
+  createWindow();
+  import_electron4.app.on("activate", () => {
+    if (import_electron4.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+  try {
+    const settingsStore = createTeamsSettingsStore(process.cwd());
+    const tokenPersistence = createSafeStorageTokenPersistence(
+      path8.join(process.cwd(), ".data", "teams-token.enc"),
+      import_electron4.safeStorage
+    );
+    const tokens = new AzTokenProvider(void 0, tokenPersistence);
+    const getAllowedChannels = createCachedAllowedChannels(
+      () => allowedChannelIdSet(
+        settingsStore.load().defaultChannelUrl,
+        officeChannelOverridesFromJson(officeStore.load().data)
+      )
+    );
+    let cachedTeamsSettings = settingsStore.load();
+    let teamsSettingsAt = Date.now();
+    const getTeamsSettingsCached = () => {
+      const now = Date.now();
+      if (now - teamsSettingsAt >= 2e3) {
+        cachedTeamsSettings = settingsStore.load();
+        teamsSettingsAt = now;
+      }
+      return cachedTeamsSettings;
+    };
+    const rawGraph = new GraphClient(tokens);
+    const allowlistedGraph = createAllowlistedGraphSender(rawGraph, getAllowedChannels);
+    const resolveMention = async (ref, destTeamId) => {
+      try {
+        if (ref.type === "user") {
+          const id = await rawGraph.findUserId(ref.value);
+          return id ? { mentionType: "user", mentionId: id } : { mentionType: "none", mentionId: "" };
+        }
+        if (ref.type === "tag") {
+          const raw = ref.value.trim();
+          return raw ? { mentionType: "tag", mentionId: raw } : { mentionType: "none", mentionId: "" };
+        }
+      } catch {
+      }
+      return { mentionType: "none", mentionId: "" };
+    };
+    const relaySender = createRelaySender({
+      primary: rawGraph,
+      getDumpChannelUrl: () => getTeamsSettingsCached().relayChannelUrl,
+      getMention: () => ({
+        type: getTeamsSettingsCached().relayMentionType,
+        value: getTeamsSettingsCached().relayMentionValue
+      }),
+      resolveMention,
+      // The fan-out destination must satisfy the same outbound allowlist as the direct path.
+      isDestinationAllowed: (channelId) => getAllowedChannels().has(channelId)
+    });
+    const graph = allowlistedGraph;
+    const isNotifyActive = () => {
+      const s = getTeamsSettingsCached();
+      return s.notifyOnCompleteEnabled && !!s.relayChannelUrl.trim();
+    };
+    const source = new TrouterClient(tokens);
+    const gateway = new RelaySessionGateway(relay);
+    const store = new FileTeamsOnlineStore(
+      FileTeamsOnlineStore.defaultPath(path8.join(process.cwd(), ".data"))
+    );
+    const emitStatus = makeStatusEmitter(() => mainWindow);
+    const emitToast = makeToastEmitter(() => mainWindow);
+    teamsService = new TeamsService({
+      store,
+      tokens,
+      graph,
+      notifier: relaySender,
+      isNotifyActive,
+      source,
+      gateway,
+      getSettings: () => settingsStore.load(),
+      emitStatus,
+      emitToast
+    });
+    registerTeamsIpc({
+      service: teamsService,
+      settingsStore,
+      getMainWindow: () => mainWindow,
+      onSettingsChanged: (settings) => {
+        if (settings.enabled) teamsService?.start().catch((e) => console.error("[Main] Teams start failed:", e));
+        else teamsService?.stop().catch((e) => console.error("[Main] Teams stop failed:", e));
+      }
+    });
+    if (settingsStore.load().enabled) {
+      teamsService.start().catch((e) => console.error("[Main] Teams start failed:", e));
+    } else {
+      console.log("[TeamsRemote] Feature disabled \u2014 service idle (enable it in Settings \u2192 Teams Remote).");
+    }
+  } catch (e) {
+    console.error("[Main] Failed to initialize Teams service:", e);
   }
-  createWindow();
-  import_electron3.app.on("activate", () => {
-    if (import_electron3.BrowserWindow.getAllWindows().length === 0) createWindow();
-  });
-});
-import_electron3.app.on("window-all-closed", () => {
-  if (watcherProcess) watcherProcess.kill();
-  if (process.platform !== "darwin") import_electron3.app.quit();
+});
+import_electron4.app.on("window-all-closed", () => {
+  if (watcherProcess) watcherProcess.kill();
+  if (process.platform !== "darwin") import_electron4.app.quit();
 });
 var isShuttingDown = false;
-import_electron3.app.on("before-quit", (event) => {
+import_electron4.app.on("before-quit", (event) => {
   if (isShuttingDown) return;
   isShuttingDown = true;
   event.preventDefault();
   console.log("[Main] Awaiting relay shutdown before quit\u2026");
-  relay.shutdown().finally(() => {
-    console.log("[Main] Relay shutdown complete \u2014 quitting");
-    import_electron3.app.quit();
+  const teamsStop = teamsService ? teamsService.stop().catch(() => void 0) : Promise.resolve();
+  Promise.resolve(teamsStop).finally(() => {
+    relay.shutdown().finally(() => {
+      console.log("[Main] Relay shutdown complete \u2014 quitting");
+      import_electron4.app.quit();
+    });
   });
 });