copilotoffice 1.1.1 → 2.1.0

package/dist/electron/terminal/server.js

@@ -3044,7 +3044,7 @@ var require_main = __commonJS({
     exports2.createMessageConnection = exports2.createServerSocketTransport = exports2.createClientSocketTransport = exports2.createServerPipeTransport = exports2.createClientPipeTransport = exports2.generateRandomPipeName = exports2.StreamMessageWriter = exports2.StreamMessageReader = exports2.SocketMessageWriter = exports2.SocketMessageReader = exports2.PortMessageWriter = exports2.PortMessageReader = exports2.IPCMessageWriter = exports2.IPCMessageReader = void 0;
     var ril_1 = require_ril();
     ril_1.default.install();
-    var path4 = require("path");
+    var path5 = require("path");
     var os4 = require("os");
     var crypto_1 = require("crypto");
     var net_1 = require("net");
@@ -3180,9 +3180,9 @@ var require_main = __commonJS({
       }
       let result;
       if (XDG_RUNTIME_DIR) {
-        result = path4.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+        result = path5.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
       } else {
-        result = path4.join(os4.tmpdir(), `vscode-${randomSuffix}.sock`);
+        result = path5.join(os4.tmpdir(), `vscode-${randomSuffix}.sock`);
       }
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0 && result.length > limit) {
@@ -5067,10 +5067,10 @@ var init_dist = __esm({
 });
 
 // electron/terminal/server.ts
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
-var fs2 = __toESM(require("fs"));
-var crypto = __toESM(require("crypto"));
+var fs3 = __toESM(require("fs"));
+var crypto3 = __toESM(require("crypto"));
 var import_child_process2 = require("child_process");
 
 // electron/terminal/events-watcher.ts
@@ -5407,14 +5407,7 @@ var CopilotSdkProcess = class {
           this.emitPrompt();
           continue;
         }
-        this.promptPending = true;
-        this.queuedSend = this.queuedSend.then(async () => {
-          await this.session.send({ prompt, mode: "enqueue" });
-        }).catch((error) => {
-          this.emitData(`\x1B[31m[SDK send failed: ${String(error)}]\x1B[0m\r
-`);
-          this.emitPrompt();
-        });
+        this.enqueuePrompt(prompt);
         continue;
       }
       if (ch === "\b" || ch === "\x7F") {
@@ -5428,6 +5421,34 @@ var CopilotSdkProcess = class {
       this.emitData(ch);
     }
   }
+  /**
+   * Submit a complete prompt directly to the SDK session, bypassing the
+   * line-editor. Handles multi-line prompts atomically (no premature submit on
+   * embedded newlines) and echoes the prompt so it appears in the terminal as
+   * if typed. This is the robust path used by programmatic drivers (e.g. Teams
+   * remote dispatch) instead of racing keystrokes through `write()`.
+   */
+  submitPrompt(text, label) {
+    if (this.closed) return;
+    const prompt = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (!prompt) return;
+    this.lineBuffer = "";
+    const tag = label ? `\x1B[2;36m[${label}]\x1B[0m ` : "";
+    this.emitData(`${tag}${prompt.replace(/\n/g, "\r\n")}\r
+`);
+    this.enqueuePrompt(prompt);
+  }
+  /** Queue a prompt for the SDK session, serialized after any in-flight send. */
+  enqueuePrompt(prompt) {
+    this.promptPending = true;
+    this.queuedSend = this.queuedSend.then(async () => {
+      await this.session.send({ prompt, mode: "enqueue" });
+    }).catch((error) => {
+      this.emitData(`\x1B[31m[SDK send failed: ${String(error)}]\x1B[0m\r
+`);
+      this.emitPrompt();
+    });
+  }
   resize(_cols, _rows) {
   }
   onData(callback) {
@@ -5595,25 +5616,127 @@ function createSdkCliLaunchConfig(cliPath) {
   return { cliPath, cliArgs: [] };
 }
 
+// electron/terminal/agent-viewers.ts
+function addAgentViewer(ck, maps) {
+  maps.activeAgentViewers.add(ck);
+  const termKey = maps.agentToTerminal.get(ck);
+  if (termKey && termKey !== ck) {
+    maps.activeAgentViewers.add(termKey);
+    return { aliasKey: termKey };
+  }
+  return { aliasKey: null };
+}
+function removeAgentViewer(ck, maps) {
+  maps.activeAgentViewers.delete(ck);
+  const termKey = maps.agentToTerminal.get(ck);
+  if (termKey && termKey !== ck) {
+    maps.activeAgentViewers.delete(termKey);
+    return { aliasKey: termKey };
+  }
+  return { aliasKey: null };
+}
+function hasActiveViewer(ck, maps) {
+  if (maps.activeAgentViewers.has(ck)) return true;
+  for (const [alias, termKey] of maps.agentToTerminal) {
+    if (termKey === ck && maps.activeAgentViewers.has(alias)) return true;
+  }
+  return false;
+}
+
+// electron/terminal/session-repair.ts
+var crypto = __toESM(require("crypto"));
+function repairDuplicateSessionIds(officeId, data, options = {}) {
+  const logger = options.logger ?? { warn: (msg) => console.warn(msg) };
+  const mintId = options.mintId ?? (() => crypto.randomUUID());
+  const seen = /* @__PURE__ */ new Map();
+  let repaired = false;
+  for (const [agentId, sessionId] of data.sessionIds.entries()) {
+    const firstAgent = seen.get(sessionId);
+    if (firstAgent === void 0) {
+      seen.set(sessionId, agentId);
+      continue;
+    }
+    let fresh = mintId();
+    while (seen.has(fresh) || data.sessionIds.get(agentId) === fresh) {
+      fresh = mintId();
+    }
+    data.sessionIds.set(agentId, fresh);
+    seen.set(fresh, agentId);
+    logger.warn(
+      `[TermServer] Repaired duplicate sessionId for officeId=${officeId} agentId=${agentId} from=${sessionId} to=${fresh}`
+    );
+    repaired = true;
+  }
+  return repaired;
+}
+
+// electron/terminal/pty-registry.ts
+var crypto2 = __toESM(require("crypto"));
+var fs2 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var DEFAULT_REGISTRY_FILE = path3.join(process.cwd(), ".data", "pty-pids.json");
+function readPtyRegistry(file = DEFAULT_REGISTRY_FILE) {
+  try {
+    const raw = fs2.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 {
+    fs2.mkdirSync(path3.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${crypto2.randomBytes(4).toString("hex")}.tmp`;
+    fs2.writeFileSync(tmp, JSON.stringify(records, null, 2));
+    fs2.renameSync(tmp, file);
+  } catch {
+  }
+}
+function registerPty(record, file = DEFAULT_REGISTRY_FILE) {
+  const records = readPtyRegistry(file).filter((r) => r.pid !== record.pid);
+  records.push(record);
+  writePtyRegistry(records, file);
+}
+function unregisterPty(pid, file = DEFAULT_REGISTRY_FILE) {
+  const records = readPtyRegistry(file);
+  const next = records.filter((r) => r.pid !== pid);
+  if (next.length !== records.length) {
+    writePtyRegistry(next, file);
+  }
+}
+
 // electron/terminal/server.ts
 var ptyProcesses = /* @__PURE__ */ new Map();
+var DEBUG_COLD_START = process.env.COPILOT_OFFICE_DEBUG_COLD_START === "1";
 var agentToTerminal = /* @__PURE__ */ new Map();
 var activeAgentViewers = /* @__PURE__ */ new Set();
+var agentForwardKeys = /* @__PURE__ */ new Set();
+var lastPtyDataAt = /* @__PURE__ */ new Map();
+var viewerMaps = { activeAgentViewers, agentToTerminal };
 var agentWatchers = /* @__PURE__ */ new Map();
 var terminalBackend = null;
 var eventSourceFactory = new FileWatcherEventSourceFactory();
 var agentReadyState = /* @__PURE__ */ new Map();
 var agentInTurn = /* @__PURE__ */ new Map();
+var userMessageSeq = /* @__PURE__ */ new Map();
+var lastUserMessageText = /* @__PURE__ */ new Map();
+function normalizePromptText(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
 var MAX_BUFFER_BYTES = 512 * 1024;
 var agentScrollbackBuffers = /* @__PURE__ */ new Map();
 var agentScrollbackBytes = /* @__PURE__ */ new Map();
-var DATA_DIR = path3.join(process.cwd(), ".data");
-var OLD_SESSION_FILE = path3.join(DATA_DIR, "copilot-office-sessions.json");
-var OFFICES_FILE = path3.join(DATA_DIR, "copilot-offices.json");
+var DATA_DIR = path4.join(process.cwd(), ".data");
+var OLD_SESSION_FILE = path4.join(DATA_DIR, "copilot-office-sessions.json");
+var OFFICES_FILE = path4.join(DATA_DIR, "copilot-offices.json");
 var officeSessions = /* @__PURE__ */ new Map();
 var hasAutoTitled = /* @__PURE__ */ new Set();
 function getSessionFile(officeId) {
-  return path3.join(DATA_DIR, `${officeId}.sessions.json`);
+  return path4.join(DATA_DIR, `${officeId}.sessions.json`);
 }
 function getOfficeSession(officeId) {
   let data = officeSessions.get(officeId);
@@ -5626,12 +5749,8 @@ function getOfficeSession(officeId) {
 function compositeKey(officeId, agentId) {
   return `${officeId}:${agentId}`;
 }
-function hasActiveViewer(ck) {
-  if (activeAgentViewers.has(ck)) return true;
-  for (const [alias, termKey] of agentToTerminal) {
-    if (termKey === ck && activeAgentViewers.has(alias)) return true;
-  }
-  return false;
+function hasActiveViewer2(ck) {
+  return hasActiveViewer(ck, viewerMaps);
 }
 function send(msg) {
   if (process.send) {
@@ -5655,9 +5774,9 @@ function appendToScrollback(agentId, data) {
 }
 async function loadOfficeSessionFile(officeId) {
   try {
-    await fs2.promises.mkdir(DATA_DIR, { recursive: true });
+    await fs3.promises.mkdir(DATA_DIR, { recursive: true });
     const filePath = getSessionFile(officeId);
-    const raw = await fs2.promises.readFile(filePath, "utf8").catch(() => null);
+    const raw = await fs3.promises.readFile(filePath, "utf8").catch(() => null);
     const data = getOfficeSession(officeId);
     if (raw) {
       const parsed = JSON.parse(raw);
@@ -5675,6 +5794,10 @@ async function loadOfficeSessionFile(officeId) {
         data.sessionMeta = /* @__PURE__ */ new Map();
         await saveOfficeSessionFile(officeId);
       }
+      const repaired = repairDuplicateSessionIds(officeId, data);
+      if (repaired) {
+        await saveOfficeSessionFile(officeId);
+      }
       console.log(`[TermServer] Loaded sessions for ${officeId}: ${data.sessionIds.size} current, ${data.sessionHistory.size} history`);
     }
   } catch (e) {
@@ -5683,27 +5806,27 @@ async function loadOfficeSessionFile(officeId) {
 }
 async function saveOfficeSessionFile(officeId) {
   try {
-    await fs2.promises.mkdir(DATA_DIR, { recursive: true });
+    await fs3.promises.mkdir(DATA_DIR, { recursive: true });
     const data = getOfficeSession(officeId);
     const json = {
       current: Object.fromEntries(data.sessionIds),
       history: Object.fromEntries(data.sessionHistory),
       metadata: Object.fromEntries(data.sessionMeta)
     };
-    await fs2.promises.writeFile(getSessionFile(officeId), JSON.stringify(json, null, 2));
+    await fs3.promises.writeFile(getSessionFile(officeId), JSON.stringify(json, null, 2));
   } catch (e) {
     console.error(`[TermServer] Failed to save sessions for ${officeId}:`, e);
   }
 }
 async function createEmptySessionFile(officeId) {
-  await fs2.promises.mkdir(DATA_DIR, { recursive: true });
+  await fs3.promises.mkdir(DATA_DIR, { recursive: true });
   const filePath = getSessionFile(officeId);
   try {
-    await fs2.promises.access(filePath, fs2.constants.F_OK);
+    await fs3.promises.access(filePath, fs3.constants.F_OK);
     await loadOfficeSessionFile(officeId);
   } catch {
     const empty = { current: {}, history: {}, metadata: {} };
-    await fs2.promises.writeFile(filePath, JSON.stringify(empty, null, 2));
+    await fs3.promises.writeFile(filePath, JSON.stringify(empty, null, 2));
     getOfficeSession(officeId);
     console.log(`[TermServer] Created empty session file for ${officeId}: ${filePath}`);
   }
@@ -5723,19 +5846,19 @@ async function migrateGlobalSessionFile() {
   try {
     const migratedMarker = OLD_SESSION_FILE + ".migrated";
     try {
-      await fs2.promises.access(migratedMarker, fs2.constants.F_OK);
+      await fs3.promises.access(migratedMarker, fs3.constants.F_OK);
       return;
     } catch {
     }
     let oldRaw = null;
     try {
-      oldRaw = await fs2.promises.readFile(OLD_SESSION_FILE, "utf8");
+      oldRaw = await fs3.promises.readFile(OLD_SESSION_FILE, "utf8");
     } catch {
       return;
     }
     let firstOfficeId = "office-0";
     try {
-      const officesRaw = await fs2.promises.readFile(OFFICES_FILE, "utf8");
+      const officesRaw = await fs3.promises.readFile(OFFICES_FILE, "utf8");
       const officesData = JSON.parse(officesRaw);
       if (Array.isArray(officesData.offices) && officesData.offices.length > 0) {
         firstOfficeId = officesData.offices[0].id || "office-0";
@@ -5744,22 +5867,22 @@ async function migrateGlobalSessionFile() {
     }
     const firstOfficeFile = getSessionFile(firstOfficeId);
     try {
-      await fs2.promises.access(firstOfficeFile, fs2.constants.F_OK);
+      await fs3.promises.access(firstOfficeFile, fs3.constants.F_OK);
     } catch {
-      await fs2.promises.writeFile(firstOfficeFile, oldRaw);
+      await fs3.promises.writeFile(firstOfficeFile, oldRaw);
       console.log(`[TermServer] Migrated global sessions to ${firstOfficeFile}`);
     }
-    await fs2.promises.rename(OLD_SESSION_FILE, migratedMarker);
+    await fs3.promises.rename(OLD_SESSION_FILE, migratedMarker);
     console.log(`[TermServer] Renamed old session file to ${migratedMarker}`);
   } catch (e) {
     console.error("[TermServer] Migration error:", e);
   }
 }
 async function loadAllOfficeSessions() {
-  await fs2.promises.mkdir(DATA_DIR, { recursive: true });
+  await fs3.promises.mkdir(DATA_DIR, { recursive: true });
   await migrateGlobalSessionFile();
   try {
-    const files = await fs2.promises.readdir(DATA_DIR);
+    const files = await fs3.promises.readdir(DATA_DIR);
     for (const file of files) {
       const match = file.match(/^(.+)\.sessions\.json$/);
       if (match) {
@@ -5777,6 +5900,46 @@ function getTerminalKey(officeId, agentId) {
   if (ptyProcesses.has(ck)) return ck;
   return null;
 }
+function submitViaKeystrokes(proc, prompt, ck) {
+  const text = prompt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const safeWrite = (data) => {
+    try {
+      proc.write(data);
+    } catch {
+    }
+    lastPtyDataAt.set(ck, Date.now());
+  };
+  const waitForIdle = (quietMs, capMs) => new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      const last = lastPtyDataAt.get(ck) ?? 0;
+      if (Date.now() - last >= quietMs || Date.now() - start >= capMs) resolve();
+      else setTimeout(tick, 50);
+    };
+    tick();
+  });
+  void (async () => {
+    await waitForIdle(300, 3e3);
+    safeWrite("");
+    safeWrite(`\x1B[200~${text}\x1B[201~`);
+    await waitForIdle(250, 2e3);
+    const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+    const want = normalizePromptText(text);
+    const baseline = userMessageSeq.get(ck) ?? 0;
+    const accepted = () => (userMessageSeq.get(ck) ?? 0) > baseline && lastUserMessageText.get(ck) === want;
+    const MAX_ATTEMPTS = 12;
+    const POLL_MS = 500;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS && !accepted(); attempt++) {
+      safeWrite("\r");
+      for (let waited = 0; waited < POLL_MS && !accepted(); waited += 50) {
+        await delay(50);
+      }
+    }
+    if (!accepted()) {
+      console.warn(`[TermServer] submitViaKeystrokes: prompt not confirmed accepted after ${MAX_ATTEMPTS} Enter attempts for ${ck} \u2014 it may not have submitted.`);
+    }
+  })();
+}
 function killAllPtyProcesses() {
   console.log(`[TermServer] Killing ${ptyProcesses.size} PTY processes`);
   ptyProcesses.forEach((proc) => killPtyProcess(proc));
@@ -5787,9 +5950,15 @@ function killAllPtyProcesses() {
 }
 function killPtyProcess(proc) {
   proc.process.kill();
+  unregisterPty(proc.pid);
 }
+var yoloEnabled = false;
+var additionalParams = "";
 var pendingPreseededPrompts = /* @__PURE__ */ new Map();
 async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode = "copilot") {
+  if (process.env.COPILOT_E2E === "1") {
+    launchMode = "shell";
+  }
   if (!terminalBackend || !terminalBackend.isAvailable()) {
     return { success: false, error: "terminal backend not available" };
   }
@@ -5806,7 +5975,7 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
   const officeData = getOfficeSession(officeId);
   let sessionId = officeData.sessionIds.get(agentId);
   if (!sessionId) {
-    sessionId = crypto.randomUUID();
+    sessionId = crypto3.randomUUID();
     officeData.sessionIds.set(agentId, sessionId);
     await saveOfficeSessionFile(officeId);
     console.log(`[TermServer] New session GUID for ${ck}: ${sessionId}`);
@@ -5817,9 +5986,9 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
   const shell = os3.platform() === "win32" ? "powershell.exe" : "bash";
   let cwd = process.cwd();
   if (workingDir) {
-    const customPath = path3.isAbsolute(workingDir) ? workingDir : path3.join(process.cwd(), workingDir);
+    const customPath = path4.isAbsolute(workingDir) ? workingDir : path4.join(process.cwd(), workingDir);
     try {
-      await fs2.promises.access(customPath, fs2.constants.F_OK);
+      await fs3.promises.access(customPath, fs3.constants.F_OK);
       cwd = customPath;
     } catch {
     }
@@ -5847,6 +6016,9 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
       workingDir
     });
     agentToTerminal.set(ck, terminalKey);
+    if (terminalBackend.name === "node-pty") {
+      registerPty({ pid: proc.pid, agentId, sessionId, startedAt: Date.now() });
+    }
     if (!shellOnlyMode) {
       send({ type: "terminal-preload-status", agentId, status: "preloading" });
     }
@@ -5905,8 +6077,16 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
           console.log(`[TermServer] Forwarding turn_start for ${ck}`);
           send({ type: "copilot-turn-start", agentId });
         } else if (event.type === "user.message") {
+          userMessageSeq.set(ck, (userMessageSeq.get(ck) ?? 0) + 1);
+          let rawUserText = "";
+          {
+            const d = event.data ?? {};
+            const raw = d.content || d.message || d.text || d.input || d.prompt || d.body || "";
+            rawUserText = String(raw);
+            lastUserMessageText.set(ck, normalizePromptText(rawUserText));
+          }
           console.log(`[TermServer] Forwarding user_message for ${ck}, data keys: ${JSON.stringify(Object.keys(event.data || {}))}`);
-          send({ type: "copilot-user-message", agentId });
+          send({ type: "copilot-user-message", agentId, text: rawUserText });
           const existing = officeData.sessionMeta.get(agentId);
           const existingTitle = typeof existing?.title === "string" ? existing.title.trim() : "";
           if (existingTitle) {
@@ -5939,8 +6119,10 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
           console.log(`[TermServer] Subagent FAILED for ${ck}: ${d.agentName ?? "unknown"} (toolCallId: ${d.toolCallId ?? "?"}, error: ${d.error ?? "unknown"})`);
         }
         const isFleetCriticalEvent = event.type.startsWith("subagent.") || event.type === "system.notification" || event.type === "tool.execution_start" && event.data?.toolName === "task";
-        if (isFleetCriticalEvent || hasActiveViewer(ck)) {
+        if (isFleetCriticalEvent || hasActiveViewer2(ck)) {
           send({ type: "copilot-event", agentId, event });
+        } else if (agentForwardKeys.has(ck)) {
+          send({ type: "copilot-event", agentId, event, mainOnly: true });
         } else {
           console.warn(`[TermServer] Dropped copilot-event ${event.type} for ${ck} \u2014 no active viewer (viewers: [${[...activeAgentViewers].join(", ")}])`);
         }
@@ -5952,18 +6134,23 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
     let flushTimer = null;
     const flushData = () => {
       flushTimer = null;
-      if (pendingData && hasActiveViewer(ck)) {
+      if (pendingData && hasActiveViewer2(ck)) {
         send({ type: "terminal-data", agentId, data: pendingData });
       }
       pendingData = "";
     };
     proc.onData((data) => {
+      lastPtyDataAt.set(ck, Date.now());
       appendToScrollback(ck, data);
-      if (!shellOnlyMode && terminalBackend?.name === "node-pty" && !hasSignalledReady && data.includes("Environment loaded")) {
-        console.log(`[TermServer] Primary ready signal for ${ck}: "Environment loaded" detected`);
-        signalReady();
+      if (!shellOnlyMode && terminalBackend?.name === "node-pty" && !hasSignalledReady) {
+        const hasLegacyReadyMarker = data.includes("Environment loaded");
+        const hasInteractiveFooter = data.includes("/ commands") || data.includes("? help");
+        if (hasLegacyReadyMarker || hasInteractiveFooter) {
+          console.log(`[TermServer] Ready signal for ${ck}: PTY marker detected`);
+          signalReady();
+        }
       }
-      if (!hasActiveViewer(ck)) return;
+      if (!hasActiveViewer2(ck)) return;
       pendingData += data;
       if (pendingData.length >= MAX_PENDING_BYTES) {
         if (flushTimer) clearTimeout(flushTimer);
@@ -5974,12 +6161,16 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
     });
     proc.onExit(({ exitCode }) => {
       send({ type: "terminal-exit", agentId, exitCode });
+      unregisterPty(proc.pid);
       ptyProcesses.delete(terminalKey);
       activeAgentViewers.delete(ck);
       agentScrollbackBuffers.delete(ck);
       agentScrollbackBytes.delete(ck);
       agentReadyState.delete(ck);
       agentInTurn.delete(ck);
+      lastPtyDataAt.delete(ck);
+      userMessageSeq.delete(ck);
+      lastUserMessageText.delete(ck);
       const w = agentWatchers.get(ck);
       if (w) {
         w.stop();
@@ -5988,8 +6179,10 @@ async function startTerminalForAgent(officeId, agentId, workingDir, cols, rows,
     });
     if (!shellOnlyMode && terminalBackend.name === "node-pty") {
       setTimeout(() => {
-        console.log(`[TermServer] Starting copilot --session-id for ${ck}: ${sessionId}`);
-        proc.write(`copilot --session-id ${sessionId}\r`);
+        const yoloFlag = yoloEnabled ? " --yolo" : "";
+        const extraParams = additionalParams ? ` ${additionalParams}` : "";
+        console.log(`[TermServer] Starting copilot --session-id for ${ck}: ${sessionId}${yoloEnabled ? " (yolo)" : ""}${additionalParams ? ` (params: ${additionalParams})` : ""}`);
+        proc.write(`copilot --session-id=${sessionId}${yoloFlag}${extraParams}\r`);
       }, 500);
     }
     return { success: true, pid: proc.pid, sessionId };
@@ -6020,12 +6213,47 @@ async function handleMessage(msg) {
       }
       break;
     }
+    case "submit-prompt": {
+      const key = getTerminalKey(msg.officeId, msg.agentId);
+      const proc = key ? ptyProcesses.get(key) : null;
+      if (proc) {
+        agentForwardKeys.add(compositeKey(msg.officeId, msg.agentId));
+        const backendProc = proc.process;
+        if (typeof backendProc.submitPrompt === "function") {
+          backendProc.submitPrompt(msg.prompt, msg.label);
+        } else {
+          submitViaKeystrokes(backendProc, msg.prompt, key);
+        }
+        send({ type: "response", requestId: msg.requestId, result: { success: true } });
+      } else {
+        const ck = compositeKey(msg.officeId, msg.agentId);
+        console.log(`[TermServer] SUBMIT-PROMPT FAILED \u2014 no PTY for ${ck}`);
+        send({ type: "response", requestId: msg.requestId, result: { success: false, error: `No PTY for ${ck}` } });
+      }
+      break;
+    }
+    case "set-agent-forwarding": {
+      const ck = compositeKey(msg.officeId, msg.agentId);
+      if (msg.enabled) agentForwardKeys.add(ck);
+      else agentForwardKeys.delete(ck);
+      break;
+    }
     case "resize": {
       const key = getTerminalKey(msg.officeId, msg.agentId);
       const proc = key ? ptyProcesses.get(key) : null;
       if (proc) proc.process.resize(msg.cols, msg.rows);
       break;
     }
+    case "set-yolo": {
+      yoloEnabled = msg.enabled;
+      console.log(`[TermServer] YOLO mode ${yoloEnabled ? "ENABLED" : "disabled"}`);
+      break;
+    }
+    case "set-additional-params": {
+      additionalParams = (msg.params ?? "").trim();
+      console.log(`[TermServer] Additional params ${additionalParams ? `set: ${additionalParams}` : "cleared"}`);
+      break;
+    }
     case "kill": {
       const ck = compositeKey(msg.officeId, msg.agentId);
       const key = getTerminalKey(msg.officeId, msg.agentId);
@@ -6058,11 +6286,9 @@ async function handleMessage(msg) {
     case "attach": {
       const ck = compositeKey(msg.officeId, msg.agentId);
       console.log(`[TermServer] Attaching viewer for ${ck}`);
-      activeAgentViewers.add(ck);
-      const termKey = agentToTerminal.get(ck);
-      if (termKey && termKey !== ck) {
-        activeAgentViewers.add(termKey);
-        console.log(`[TermServer] Also marking original key ${termKey} as active viewer (transferred session)`);
+      const { aliasKey } = addAgentViewer(ck, viewerMaps);
+      if (aliasKey) {
+        console.log(`[TermServer] Also marking original key ${aliasKey} as active viewer (transferred session)`);
       }
       const chunks = agentScrollbackBuffers.get(ck) || [];
       const rawScrollback = chunks.join("");
@@ -6072,11 +6298,7 @@ async function handleMessage(msg) {
     case "detach": {
       const ck = compositeKey(msg.officeId, msg.agentId);
       console.log(`[TermServer] Detaching viewer for ${ck}`);
-      activeAgentViewers.delete(ck);
-      const termKey = agentToTerminal.get(ck);
-      if (termKey && termKey !== ck) {
-        activeAgentViewers.delete(termKey);
-      }
+      removeAgentViewer(ck, viewerMaps);
       break;
     }
     case "exists": {
@@ -6093,6 +6315,15 @@ async function handleMessage(msg) {
       const officeData = getOfficeSession(msg.officeId);
       const current = officeData.sessionIds.get(msg.agentId);
       const changed = !!normalized && current !== normalized;
+      if (changed && normalized) {
+        for (const [otherAgent, otherSid] of officeData.sessionIds) {
+          if (otherAgent !== msg.agentId && otherSid === normalized) {
+            console.warn(`[TermServer] Rejected set-session-id ${normalized} for ${compositeKey(msg.officeId, msg.agentId)} \u2014 already in use by ${otherAgent}`);
+            send({ type: "response", requestId: msg.requestId, result: { success: false, error: "sessionId already in use by another agent in this office" } });
+            return;
+          }
+        }
+      }
       if (changed) {
         archiveSessionId(msg.officeId, msg.agentId);
         officeData.sessionIds.set(msg.agentId, normalized);
@@ -6119,15 +6350,18 @@ async function handleMessage(msg) {
       const ptyProc = termKey ? ptyProcesses.get(termKey) : null;
       let cwd = process.cwd();
       if (ptyProc?.workingDir) {
-        const customPath = path3.join(process.cwd(), ptyProc.workingDir);
+        const customPath = path4.join(process.cwd(), ptyProc.workingDir);
         try {
-          await fs2.promises.access(customPath, fs2.constants.F_OK);
+          await fs3.promises.access(customPath, fs3.constants.F_OK);
           cwd = customPath;
         } catch {
         }
       }
       try {
-        (0, import_child_process2.spawn)("wt", ["-d", cwd, "copilot", "--session-id", sid], { detached: true, stdio: "ignore" }).unref();
+        const wtArgs = ["-d", cwd, "copilot", "--session-id", sid];
+        if (yoloEnabled) wtArgs.push("--yolo");
+        if (additionalParams) wtArgs.push(...additionalParams.split(/\s+/).filter(Boolean));
+        (0, import_child_process2.spawn)("wt", wtArgs, { detached: true, stdio: "ignore" }).unref();
         send({ type: "response", requestId: msg.requestId, result: { success: true } });
       } catch (error) {
         send({ type: "response", requestId: msg.requestId, result: { success: false, error: String(error) } });
@@ -6159,7 +6393,7 @@ async function handleMessage(msg) {
       hasAutoTitled.delete(ck);
       send({ type: "session-meta-updated", agentId: msg.agentId, meta: { title: "" } });
       archiveSessionId(msg.officeId, msg.agentId);
-      const newSessionId = crypto.randomUUID();
+      const newSessionId = crypto3.randomUUID();
       officeDataReset.sessionIds.set(msg.agentId, newSessionId);
       await saveOfficeSessionFile(msg.officeId);
       console.log(`[TermServer] Reset session for ${ck}: new GUID ${newSessionId}`);
@@ -6210,7 +6444,7 @@ async function handleMessage(msg) {
       }
       officeData.sessionMeta.clear();
       for (const agentId of officeData.sessionIds.keys()) {
-        officeData.sessionIds.set(agentId, crypto.randomUUID());
+        officeData.sessionIds.set(agentId, crypto3.randomUUID());
       }
       await saveOfficeSessionFile(officeId);
       console.log(`[TermServer] All sessions reset for ${officeId}`);
@@ -6266,7 +6500,15 @@ async function handleMessage(msg) {
     }
     case "get-all-session-meta": {
       const officeData = getOfficeSession(msg.officeId);
-      send({ type: "response", requestId: msg.requestId, result: Object.fromEntries(officeData.sessionMeta) });
+      const merged = {};
+      for (const [agentId, meta] of officeData.sessionMeta.entries()) {
+        const sessionId = officeData.sessionIds.get(agentId);
+        merged[agentId] = sessionId ? { ...meta, sessionId } : { ...meta };
+      }
+      for (const [agentId, sessionId] of officeData.sessionIds.entries()) {
+        if (!merged[agentId]) merged[agentId] = { title: "", sessionId };
+      }
+      send({ type: "response", requestId: msg.requestId, result: merged });
       break;
     }
     case "create-office-session": {
@@ -6277,7 +6519,7 @@ async function handleMessage(msg) {
     case "delete-office-session": {
       const filePath = getSessionFile(msg.officeId);
       try {
-        await fs2.promises.unlink(filePath);
+        await fs3.promises.unlink(filePath);
         officeSessions.delete(msg.officeId);
         console.log(`[TermServer] Deleted session file for ${msg.officeId}`);
       } catch {