copilotoffice 2.1.0 → 2.3.0

package/dist/electron/main.js

@@ -152,7 +152,9 @@ var TerminalRelay = class _TerminalRelay {
      * 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),
+     * 'copilot-ask-user' (agentId, toolId, requestId, question, options, freeform),
      * 'session-meta-updated' (agentId, meta), 'terminal-exit' (agentId, exitCode).
+     * Accepts (via mainSubmitAnswer): 'submit-answer' (officeId, agentId, requestId?, answer, wasFreeform).
      */
     this.mainEvents = new import_events.EventEmitter();
     this.server = null;
@@ -161,6 +163,8 @@ var TerminalRelay = class _TerminalRelay {
     this.shuttingDown = false;
     /** Requests that arrived while the server was not connected. Flushed on ready. */
     this.queuedRequests = [];
+    /** Latest backend-selection outcome reported by the server on 'ready'. */
+    this.backendInfo = null;
     this.getWindow = getWindow;
   }
   static {
@@ -311,6 +315,22 @@ var TerminalRelay = class _TerminalRelay {
   mainSubmitPrompt(officeId, agentId, prompt, label) {
     return this.request({ type: "submit-prompt", requestId: this.id(), officeId, agentId, prompt, label });
   }
+  /**
+   * spec 015: answer a pending `ask_user` interaction. Distinct from
+   * mainSubmitPrompt — resolves the pending user-input interaction (SDK/ui-server)
+   * or injects keystrokes (node-pty). `requestId` is the single-resolution key.
+   */
+  mainSubmitAnswer(officeId, agentId, a) {
+    return this.request({
+      type: "submit-answer",
+      requestId: this.id(),
+      officeId,
+      agentId,
+      answerRequestId: a.requestId,
+      answer: a.answer,
+      wasFreeform: a.wasFreeform
+    });
+  }
   /** 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 });
@@ -320,6 +340,15 @@ var TerminalRelay = class _TerminalRelay {
       clearTimeout(readyTimeout);
       this.shuttingDown = false;
       console.log("[Relay] Terminal server ready");
+      if (msg.backend) {
+        this.backendInfo = msg.backend;
+        if (msg.backend.fellBack) {
+          const win2 = this.getWindow();
+          if (win2 && !win2.isDestroyed()) {
+            win2.webContents.send("backend-fallback", this.backendInfo);
+          }
+        }
+      }
       if (this.queuedRequests.length > 0) {
         console.log(`[Relay] Flushing ${this.queuedRequests.length} queued request(s)`);
         for (const queued of this.queuedRequests) {
@@ -355,6 +384,12 @@ var TerminalRelay = class _TerminalRelay {
       case "copilot-tool-start":
         this.mainEvents.emit("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
         break;
+      case "copilot-ask-user":
+        this.mainEvents.emit("copilot-ask-user", msg.agentId, msg.toolId, msg.requestId, msg.question, msg.options, msg.freeform);
+        break;
+      case "copilot-ask-user-complete":
+        this.mainEvents.emit("copilot-ask-user-complete", msg.agentId, msg.requestId);
+        break;
       case "session-meta-updated":
         this.mainEvents.emit("session-meta-updated", msg.agentId, msg.meta);
         break;
@@ -377,6 +412,12 @@ var TerminalRelay = class _TerminalRelay {
       case "copilot-tool-start":
         win.webContents.send("copilot-tool-start", msg.agentId, msg.toolName, msg.toolId, msg.status);
         break;
+      case "copilot-ask-user":
+        win.webContents.send("copilot-ask-user", msg.agentId, msg.toolId, msg.requestId, msg.question, msg.options, msg.freeform);
+        break;
+      case "copilot-ask-user-complete":
+        win.webContents.send("copilot-ask-user-complete", msg.agentId, msg.requestId);
+        break;
       case "copilot-tool-complete":
         win.webContents.send("copilot-tool-complete", msg.agentId, msg.toolId, msg.success);
         break;
@@ -395,17 +436,24 @@ var TerminalRelay = class _TerminalRelay {
       case "terminal-preload-status":
         win.webContents.send("terminal-preload-status", msg.agentId, msg.status);
         break;
+      case "backend-online":
+        win.webContents.send("backend-online", msg.officeId, msg.backend);
+        break;
+      case "backend-session-fallback":
+        win.webContents.send("backend-session-fallback", msg.officeId, msg.agentId, msg.reason);
+        break;
     }
   }
   // ── IPC Handler Registration ──────────────────────────────────
   registerIpc() {
+    import_electron.ipcMain.handle("terminal-backend-info", () => this.backendInfo);
     import_electron.ipcMain.handle(
       "terminal-start",
       (_event, officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode) => this.request({ type: "start", requestId: this.id(), officeId, agentId, workingDir, cols, rows, preseededPrompt, launchMode })
     );
     import_electron.ipcMain.handle(
       "terminal-attach",
-      (_event, officeId, agentId) => this.request({ type: "attach", requestId: this.id(), officeId, agentId })
+      (_event, officeId, agentId, foreground) => this.request({ type: "attach", requestId: this.id(), officeId, agentId, foreground })
     );
     import_electron.ipcMain.handle("terminal-detach", (_event, officeId, agentId) => {
       this.send({ type: "detach", officeId, agentId });
@@ -909,9 +957,12 @@ function sniffImageType(buf) {
 }
 function resolveWithinBase(rawPath, baseDir) {
   if (!baseDir) return null;
-  if (path5.isAbsolute(rawPath)) return null;
+  if (path5.isAbsolute(rawPath) || path5.win32.isAbsolute(rawPath) || path5.posix.isAbsolute(rawPath)) {
+    return null;
+  }
+  const normalizedRaw = rawPath.replace(/\\/g, "/");
   const root = path5.resolve(baseDir);
-  const resolved = path5.resolve(root, rawPath);
+  const resolved = path5.resolve(root, normalizedRaw);
   const rel = path5.relative(root, resolved);
   if (rel === "" || rel.startsWith("..") || path5.isAbsolute(rel)) return null;
   return resolved;
@@ -992,9 +1043,131 @@ function pickAckQuip(rng = Math.random) {
   return ACK_QUIPS[Math.floor(rng() * ACK_QUIPS.length)] ?? ACK_QUIPS[0];
 }
 
+// electron/teams/auth.ts
+var import_child_process3 = require("child_process");
+function isAzLoginError(err) {
+  const msg = (err instanceof Error ? err.message : String(err ?? "")).toLowerCase();
+  if (!msg) return false;
+  return msg.includes("az login") || msg.includes("please run") || msg.includes("not logged in") || msg.includes("no subscription") || msg.includes("refresh token") || msg.includes("aadsts") || msg.includes("interaction_required") || msg.includes("token acquisition failed");
+}
+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, observer) {
+    this.runner = runner;
+    this.persistence = persistence;
+    this.observer = observer;
+    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()}).`);
+      this.notifyObserver(() => this.observer?.onAcquire?.(resource));
+      return token;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (cached && cached.expiresAt > now) {
+        twarn(`Token refresh failed for ${resource}; reusing cached token.`);
+        this.notifyObserver(() => this.observer?.onFailure?.(resource, err, true));
+        return cached.token;
+      }
+      this.notifyObserver(() => this.observer?.onFailure?.(resource, err, false));
+      throw err;
+    }
+  }
+  /** Run an observer callback defensively — a buggy observer must never break token flow. */
+  notifyObserver(fn) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+};
+
 // electron/teams/teamsService.ts
 var RECONCILE_MS = 15e3;
 var TURN_SETTLE_MS = 2500;
+var AUTH_TOAST_DURATION_MS = 6e4;
+var AUTH_TOAST_REPEAT_MS = 5 * 60 * 1e3;
 var TeamsService = class _TeamsService {
   constructor(deps) {
     this.deps = deps;
@@ -1012,6 +1185,14 @@ var TeamsService = class _TeamsService {
      */
     this.ambient = /* @__PURE__ */ new Map();
     // key = agentId
+    /**
+     * Pending `ask_user` questions awaiting an answer, keyed by agentId (spec 015).
+     * At most one per online agent — a new `ask-user` supersedes the prior record.
+     * Transient, in-memory, main-process only (never persisted). Distinct from
+     * {@link pending} (in-flight Teams dispatches) and {@link ambient}.
+     */
+    this.pendingQuestions = /* @__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
@@ -1024,6 +1205,12 @@ var TeamsService = class _TeamsService {
     this.unsubExit = null;
     this.reconcileTimer = null;
     this.started = false;
+    /** True once a hard token failure has been surfaced and not yet recovered. */
+    this.authBroken = false;
+    /** Timestamp of the last az-login toast (throttle guard). 0 ⇒ never shown. */
+    this.lastAuthToastAt = 0;
+    /** Last observed receive-transport health, to emit connect/reconnect notices once per transition. */
+    this.lastTransportHealth = "unknown";
     this.now = deps.now ?? Date.now;
     this.settleMs = deps.turnSettleMs ?? TURN_SETTLE_MS;
     this.filter = new MessageFilter(this.now);
@@ -1146,6 +1333,8 @@ var TeamsService = class _TeamsService {
       teamId: coords.teamId,
       channelId: coords.channelId,
       tenantId: coords.tenantId,
+      mentionType: ctx.officeMentionType,
+      mentionValue: ctx.officeMentionValue,
       threadRootId: thread.threadRootId,
       threadWebUrl: thread.webUrl,
       online: true,
@@ -1166,6 +1355,13 @@ var TeamsService = class _TeamsService {
     const b = this.findBinding(officeId, agentId);
     if (!b) return { success: true };
     tlog(`OFFLINE: @${b.handle} (${officeId}:${agentId}).`);
+    const abandoned = this.pendingQuestions.get(agentId);
+    if (abandoned) {
+      this.pendingQuestions.delete(agentId);
+      if (postNotice && b.online && b.threadRootId) {
+        await this.safeReply(b, `${this.agentLabel(b)} \u26A0\uFE0F This question is no longer answerable (agent offline).`);
+      }
+    }
     if (postNotice && b.online && b.threadRootId) {
       await this.safeReply(b, "\u{1F50C} This agent has gone offline. Replies here will not be answered.");
     }
@@ -1185,7 +1381,7 @@ var TeamsService = class _TeamsService {
     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" });
+    this.deps.emitStatus({ agentId, officeId, online: false, handle: b.handle, health: "disconnected", workingDir: b.workingDir });
     return { success: true };
   }
   // ── Inbound handling ─────────────────────────────────────────
@@ -1213,6 +1409,13 @@ var TeamsService = class _TeamsService {
       await this.goOffline(binding.officeId, binding.agentId, true);
       return;
     }
+    const pendingQ = this.pendingQuestions.get(binding.agentId);
+    if (pendingQ) {
+      if (!pendingQ.resolved) {
+        await this.resolveAnswer(pendingQ, msg.content);
+      }
+      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,
@@ -1279,6 +1482,15 @@ var TeamsService = class _TeamsService {
     });
   }
   onAgentEvent(e) {
+    if (e.kind === "ask-user") {
+      void this.onAskUserEvent(e);
+      return;
+    }
+    if (e.kind === "ask-user-complete") {
+      this.maybeLocalResolveByRequestId(e.agentId, e.requestId ?? "");
+      return;
+    }
+    this.maybeLocalResolve(e.agentId);
     const rec = this.pending.get(e.agentId);
     if (!rec) {
       this.onAmbientEvent(e);
@@ -1392,6 +1604,7 @@ var TeamsService = class _TeamsService {
     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)}`);
+    rec.lastReplyText = text;
     await this.postReply(rec.binding, text);
   }
   /** Close out an ambient turn once the agent goes idle: flush residual text, drop record. */
@@ -1401,6 +1614,7 @@ var TeamsService = class _TeamsService {
     this.cancelAmbientSettle(rec);
     this.ambient.delete(agentId);
     await this.flushAmbient(rec);
+    await this.maybeNotifyComplete(rec.binding, rec.lastReplyText);
   }
   /** Post a locally-typed user request into the thread, tagged so it's distinct from replies. */
   async postLocalRequest(binding, text) {
@@ -1424,29 +1638,33 @@ var TeamsService = class _TeamsService {
     this.cancelSettle(rec);
     this.pending.delete(agentId);
     await this.flushTurn(rec);
-    await this.maybeNotifyComplete(rec);
+    await this.maybeNotifyComplete(rec.binding, rec.lastReplyText);
     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
+   * {@link TeamsServiceDeps.isNotifyActive} is true. Skips silently when the response
    * produced no text. Never throws — a notification failure must not wedge the queue.
+   * Shared by the Teams-dispatch ({@link finalizeDispatch}) and locally-driven ambient
+   * ({@link finalizeAmbient}) idle-finalize paths.
    */
-  async maybeNotifyComplete(rec) {
+  async maybeNotifyComplete(binding, lastReplyText) {
     const notifier = this.deps.notifier;
     if (!notifier || !(this.deps.isNotifyActive?.() ?? false)) return;
-    if (!rec.lastReplyText) return;
-    const title = (rec.binding.sessionTitle || "").trim();
+    if (!lastReplyText) return;
+    const title = (binding.sessionTitle || "").trim();
     const where = title ? ` in \u201C${escapeHtml(title)}\u201D` : "";
-    const html = `${this.agentLabel(rec.binding)} has finished responding${where}`;
+    const html = `${this.agentLabel(binding)} has finished responding${where}`;
     try {
       const posted = await notifier.replyToThread({
-        teamId: rec.binding.teamId,
-        channelId: rec.binding.channelId,
-        threadRootId: rec.binding.threadRootId,
-        html
+        teamId: binding.teamId,
+        channelId: binding.channelId,
+        threadRootId: binding.threadRootId,
+        html,
+        // Per-office relay @mention override (frozen at register); empty ⇒ global mention.
+        mentionOverride: { type: binding.mentionType ?? "none", value: binding.mentionValue ?? "" }
       });
       if (posted?.messageId) this.rememberPosted(posted.messageId);
     } catch (e) {
@@ -1468,6 +1686,170 @@ var TeamsService = class _TeamsService {
    * under the operator's own Teams identity, this makes automated agent output
    * visually distinct from messages the operator typed by hand.
    */
+  // ── ask_user question / answer flow (spec 015) ───────────────
+  /**
+   * Handle an `ask-user` AgentEvent for an online agent (contract §A). Resolves the
+   * binding, assigns stable selector labels (A, B, C…) to options in order, supersedes any
+   * existing record for the agent, and posts one framed question message listing all
+   * options (+ a freeform hint iff allowed). Ignored when the agent isn't online.
+   */
+  async onAskUserEvent(e) {
+    if (!e.askUser) return;
+    const binding = this.bindings.find((b) => b.agentId === e.agentId && b.online);
+    if (!binding) return;
+    const options = e.askUser.options.map((o, i) => ({
+      label: selectorLabel(i),
+      text: o.text
+    }));
+    const record = {
+      agentId: e.agentId,
+      officeId: binding.officeId,
+      binding,
+      toolId: e.askUser.toolId,
+      requestId: e.askUser.requestId ?? "",
+      question: e.askUser.question,
+      options,
+      freeform: e.askUser.freeform,
+      resolved: false,
+      createdAt: this.now()
+    };
+    this.pendingQuestions.set(e.agentId, record);
+    tlog(`ask_user \u2192 @${binding.handle}: "${truncate(record.question, 80)}" (${options.length} options, freeform=${record.freeform}, requestId=${record.requestId || "\u2205"})`);
+    const html = this.composeQuestion(record);
+    let firstId;
+    for (const chunk of chunkReply(html, 3500)) {
+      const id = await this.safeReply(binding, chunk);
+      if (!firstId) firstId = id;
+    }
+    if (this.pendingQuestions.get(e.agentId) === record) {
+      record.postedMessageId = firstId;
+    }
+  }
+  /** Compose the HTML for a pending question: attention framing + question + labeled
+   *  options + optional freeform hint (contract §A, FR-001/002/006; framing per FR-002/T031). */
+  composeQuestion(record) {
+    const lines = [
+      `${this.agentLabel(record.binding)} \u2753 <b>needs your answer</b>`,
+      `<br><br>${escapeHtml(record.question)}`
+    ];
+    for (const opt of record.options) {
+      lines.push(`<br><b>${escapeHtml(opt.label)}</b> \u2014 ${escapeHtml(opt.text)}`);
+    }
+    lines.push(`<br><br><i>Reply with a letter (${record.options.map((o) => escapeHtml(o.label)).join(", ")}) to choose.</i>`);
+    if (record.freeform) {
+      lines.push(`<br><i>Or reply with your own answer.</i>`);
+    }
+    return lines.join("");
+  }
+  /** Compose the nudge re-listing options when a choices-only reply doesn't match a label
+   *  (contract §B, FR-005/SC-005). Leaves the record pending. */
+  composeNudge(record) {
+    const lines = [
+      `${this.agentLabel(record.binding)} \u{1F914} I didn't recognize that as one of the choices. Reply with a letter:`
+    ];
+    for (const opt of record.options) {
+      lines.push(`<br><b>${escapeHtml(opt.label)}</b> \u2014 ${escapeHtml(opt.text)}`);
+    }
+    return lines.join("");
+  }
+  /**
+   * Resolve a thread reply against a pending question (contract §B). Selector-label-only
+   * matching (FR-014). The `resolved` check-and-set is synchronous (main process is
+   * single-threaded) so the first resolver wins — a near-simultaneous second reply finds
+   * `resolved === true` and is dropped (single-resolution, FR-007/SC-004). The record is
+   * deleted after the answer is submitted so genuine follow-up prompts dispatch normally.
+   */
+  async resolveAnswer(record, rawText) {
+    const token = (rawText.trim().split(/\s+/)[0] ?? "").replace(/[).:]$/, "");
+    const matched = token ? record.options.find((o) => o.label.toLowerCase() === token.toLowerCase()) : void 0;
+    if (matched) {
+      if (record.resolved) return;
+      record.resolved = true;
+      tlog(`answer \u2192 @${record.binding.handle}: label "${matched.label}" \u21D2 "${truncate(matched.text, 60)}"`);
+      const ok = await this.submitAnswerSafe(record, matched.text, false);
+      this.settleResolution(record, ok);
+      return;
+    }
+    if (record.freeform) {
+      if (record.resolved) return;
+      record.resolved = true;
+      tlog(`answer \u2192 @${record.binding.handle}: freeform "${truncate(rawText, 60)}"`);
+      const ok = await this.submitAnswerSafe(record, rawText.trim(), true);
+      this.settleResolution(record, ok);
+      return;
+    }
+    await this.safeReply(record.binding, this.composeNudge(record));
+  }
+  /**
+   * Finalize a resolution attempt (spec 015 hardening h2). On success, delete the record
+   * so genuine follow-up prompts dispatch normally. On transport FAILURE, RELEASE the
+   * single-resolution latch and KEEP the record so the human can simply reply again, and
+   * post a thread notice — instead of silently dropping the answer and hanging the agent.
+   */
+  settleResolution(record, ok) {
+    if (ok) {
+      this.pendingQuestions.delete(record.agentId);
+      return;
+    }
+    if (this.pendingQuestions.get(record.agentId) === record) {
+      record.resolved = false;
+      void this.safeReply(
+        record.binding,
+        `${this.agentLabel(record.binding)} \u26A0\uFE0F I couldn't deliver that answer \u2014 please reply again.`
+      );
+    }
+  }
+  /** Submit an answer through the gateway. Returns true iff the transport reported success;
+   *  a failure (thrown by the gateway when the runtime had no pending interaction to resolve,
+   *  or a transient IPC error) returns false so the caller can keep the question open and
+   *  re-prompt (FR hardening h2). The submitted value is the option TEXT (never the label)
+   *  or the raw freeform text — identical to a local answer (FR-003/004/014). */
+  async submitAnswerSafe(record, answer, wasFreeform) {
+    try {
+      await this.deps.gateway.submitAnswer(record.officeId, record.agentId, {
+        requestId: record.requestId || void 0,
+        answer,
+        wasFreeform
+      });
+      return true;
+    } catch (e) {
+      twarn("submitAnswer failed:", e.message);
+      return false;
+    }
+  }
+  /**
+   * Local-resolution detection for the node-pty degraded path (contract §C, FR-008): if
+   * `agentId` has a still-pending, unresolved node-pty question (empty requestId) and a
+   * non-`ask-user` event arrives, the ask_user was answered in-app. Latch it, clear the
+   * record, and post a one-time "answered in the app" notice. SDK records (non-empty
+   * requestId) are ignored here — they resolve precisely via {@link maybeLocalResolveByRequestId}
+   * on the explicit `user_input.completed` signal, avoiding false positives when an agent
+   * emits events while still blocked on the question.
+   */
+  maybeLocalResolve(agentId) {
+    const record = this.pendingQuestions.get(agentId);
+    if (!record || record.resolved) return;
+    if (record.requestId) return;
+    record.resolved = true;
+    this.pendingQuestions.delete(agentId);
+    tlog(`ask_user answered locally (node-pty) for @${record.binding.handle} \u2014 posting in-app notice.`);
+    void this.safeReply(record.binding, `${this.agentLabel(record.binding)} \u2705 Answered in the app.`);
+  }
+  /**
+   * Precise local-resolution for the SDK/ui-server path (spec 015 hardening h1). Fired on
+   * `user_input.completed`: clear the pending question ONLY when its requestId matches the
+   * resolved interaction. A Teams answer clears the record synchronously before this fires,
+   * so a matching record here means the answer came from the app → post the one-time notice.
+   */
+  maybeLocalResolveByRequestId(agentId, requestId) {
+    const record = this.pendingQuestions.get(agentId);
+    if (!record || record.resolved) return;
+    if (!requestId || record.requestId !== requestId) return;
+    record.resolved = true;
+    this.pendingQuestions.delete(agentId);
+    tlog(`ask_user answered locally (SDK requestId=${requestId}) for @${record.binding.handle} \u2014 posting in-app notice.`);
+    void this.safeReply(record.binding, `${this.agentLabel(record.binding)} \u2705 Answered in the app.`);
+  }
   agentLabel(binding) {
     return `\u{1F916} <b>${escapeHtml(binding.displayName)}</b>`;
   }
@@ -1495,7 +1877,9 @@ var TeamsService = class _TeamsService {
       await this.safeReply(binding, `${prefix}<br>${hostedImagesHtml(images)}`, images);
     }
   }
-  /** Reply to a thread, swallowing errors (logs only) so the queue keeps moving. */
+  /** Reply to a thread, swallowing errors (logs only) so the queue keeps moving.
+   *  Returns the posted messageId when Graph reports one (used to record the ask_user
+   *  question's message id — spec 015 T021), or undefined on failure. */
   async safeReply(binding, html, hostedImages) {
     try {
       const posted = await this.deps.graph.replyToThread({
@@ -1506,11 +1890,129 @@ var TeamsService = class _TeamsService {
         hostedImages
       });
       if (posted?.messageId) this.rememberPosted(posted.messageId);
+      return posted?.messageId;
     } catch (e) {
       twarn("replyToThread failed:", e.message);
+      return void 0;
     }
   }
   // ── Reconnect / teardown reconcile (FR-022/024) ──────────────
+  // ── Credential / connection health (auth + transport) ────────
+  /** True when at least one agent is bound (online or persisted); gates health noise. */
+  hasBoundAgents() {
+    return this.bindings.length > 0;
+  }
+  /**
+   * Called by the token provider (wired in main.ts) on every acquisition outcome.
+   * Owns the actionable credential toast and its throttle, and clears the warning once a
+   * token is acquired again. Only surfaces while an agent is bound (avoid noise when Teams
+   * isn't in use). A soft failure (cached-token fallback) is not user-facing — the agent is
+   * still working — so only hard failures raise the prompt. `err` is used only to tailor the
+   * message (az-login vs generic connectivity); it is never logged or shown verbatim.
+   */
+  onTokenOutcome(kind, _resource, usedCache, err) {
+    if (kind === "acquire") {
+      if (this.authBroken) {
+        const hadToast = this.lastAuthToastAt > 0;
+        this.authBroken = false;
+        this.lastAuthToastAt = 0;
+        if (hadToast && this.hasBoundAgents()) {
+          this.deps.emitToast({ level: "info", message: "Teams: Azure credential restored \u2014 reconnected." });
+          this.lastTransportHealth = "unknown";
+        }
+      }
+      return;
+    }
+    if (usedCache) return;
+    if (!this.hasBoundAgents()) {
+      this.authBroken = true;
+      return;
+    }
+    const now = this.now();
+    const dueForRepeat = now - this.lastAuthToastAt >= AUTH_TOAST_REPEAT_MS;
+    if (!this.authBroken || dueForRepeat) {
+      this.authBroken = true;
+      this.lastAuthToastAt = now;
+      const looksLikeLogin = !err || isAzLoginError(err);
+      this.deps.emitToast({
+        level: "error",
+        message: looksLikeLogin ? 'Teams: Azure credential expired. Run "az login" in a new terminal to reconnect.' : "Teams: can\u2019t reach Azure to authenticate (network issue?). Retrying automatically.",
+        durationMs: AUTH_TOAST_DURATION_MS
+      });
+    }
+  }
+  /**
+   * Emit a one-shot notice when the receive transport (re)connects. Called each reconcile
+   * tick. The az-login prompt is owned by {@link onTokenOutcome}; a transport drop that is
+   * NOT an auth failure (e.g. a network blip) stays quiet — only its eventual recovery is
+   * announced. Gated on bound agents to avoid noise when Teams isn't in use.
+   */
+  checkTransportHealth() {
+    const health = this.deps.source.health;
+    const prev = this.lastTransportHealth;
+    this.lastTransportHealth = health;
+    if (!this.hasBoundAgents()) return;
+    if (health === "connected" && prev !== "connected" && prev !== "unknown") {
+      this.deps.emitToast({ level: "info", message: "Teams: reconnected." });
+    }
+  }
+  /**
+   * One-shot access check run when the feature is enabled + saved in Settings. Confirms the
+   * signed-in user can actually reach the configured default + relay/Dump channels. Acquiring
+   * the graph token here exercises `az`, so a broken credential trips the token observer →
+   * az-login toast automatically. Purely reports via toast; never throws.
+   */
+  async verifyAccess(settings) {
+    const targets = [];
+    if (settings.defaultChannelUrl?.trim()) targets.push({ label: "default", url: settings.defaultChannelUrl });
+    if (settings.relayChannelUrl?.trim()) targets.push({ label: "Dump", url: settings.relayChannelUrl });
+    if (targets.length === 0) return;
+    const getChannel = this.deps.graph.getChannel?.bind(this.deps.graph);
+    if (!getChannel) return;
+    const ok = [];
+    const failed = [];
+    const authFailed = [];
+    let unknownFailure = false;
+    for (const t of targets) {
+      const coords = parseChannelLink(t.url);
+      if (!coords) {
+        failed.push(`${t.label} (unparseable link)`);
+        continue;
+      }
+      try {
+        await getChannel(coords.teamId, coords.channelId);
+        ok.push(t.label);
+      } catch (e) {
+        const msg = e.message || "";
+        if (/\b401\b/.test(msg)) {
+          authFailed.push(t.label);
+        } else if (/\b(403|404)\b/.test(msg)) {
+          failed.push(t.label);
+        } else {
+          unknownFailure = true;
+        }
+      }
+    }
+    if (authFailed.length > 0) {
+      this.deps.emitToast({
+        level: "error",
+        message: `Teams: Azure sign-in was rejected for the ${authFailed.join(" + ")} channel${authFailed.length > 1 ? "s" : ""}. Run "az login" (correct tenant) and re-enable.`,
+        durationMs: AUTH_TOAST_DURATION_MS
+      });
+    }
+    if (failed.length > 0) {
+      this.deps.emitToast({
+        level: "warn",
+        message: `Teams: can't access the ${failed.join(" + ")} channel${failed.length > 1 ? "s" : ""}. Check the link and your Teams membership.`
+      });
+    }
+    if (authFailed.length === 0 && failed.length === 0 && !unknownFailure && ok.length > 0) {
+      this.deps.emitToast({
+        level: "info",
+        message: `Teams: verified access to the ${ok.join(" + ")} channel${ok.length > 1 ? "s" : ""}.`
+      });
+    }
+  }
   /**
    * 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
@@ -1521,6 +2023,7 @@ var TeamsService = class _TeamsService {
     await this.reconcile();
   }
   async reconcile() {
+    this.checkTransportHealth();
     let changed = false;
     for (const b of [...this.bindings]) {
       if (!this.started) return;
@@ -1586,7 +2089,8 @@ var TeamsService = class _TeamsService {
       online: b.online,
       handle: b.handle,
       threadWebUrl: b.threadWebUrl,
-      health: b.online ? this.deps.source.health : "disconnected"
+      health: b.online ? this.deps.source.health : "disconnected",
+      workingDir: b.workingDir
     };
   }
   findBinding(officeId, agentId) {
@@ -1630,109 +2134,15 @@ 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;
-  }
+function selectorLabel(index) {
+  let n = index;
+  let s = "";
+  do {
+    s = String.fromCharCode(65 + n % 26) + s;
+    n = Math.floor(n / 26) - 1;
+  } while (n >= 0);
+  return s;
 }
-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"));
@@ -1864,6 +2274,21 @@ var GraphClient = class {
     const json = await res.json();
     return json.value || [];
   }
+  /**
+   * Probe access to a single channel (`GET /teams/{teamId}/channels/{channelId}`). Used by
+   * the settings-save access check to confirm the signed-in user can actually reach the
+   * configured default / Dump channels. Throws with the HTTP status on non-OK so the caller
+   * can classify 401/403 (permission) vs 404 (wrong link).
+   */
+  async getChannel(teamId, channelId) {
+    const url = `${GRAPH_BASE}/teams/${encodeURIComponent(teamId)}/channels/${encodeURIComponent(
+      channelId
+    )}?$select=id,displayName`;
+    const res = await fetch(url, { headers: await this.authHeaders() });
+    if (!res.ok) throw new Error(`Graph getChannel failed: ${res.status} ${await safeText(res)}`);
+    const json = await res.json();
+    return { id: json.id || channelId, displayName: json.displayName || "" };
+  }
   /** 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`;
@@ -2191,6 +2616,12 @@ var RelaySessionGateway = class {
   setForwarding(officeId, agentId, enabled) {
     this.relay.mainSetAgentForwarding(officeId, agentId, enabled);
   }
+  async submitAnswer(officeId, agentId, a) {
+    const res = await this.relay.mainSubmitAnswer(officeId, agentId, a);
+    if (!res.success) {
+      throw new Error(res.error || `Failed to submit answer to ${officeId}:${agentId}`);
+    }
+  }
   onAgentEvent(cb) {
     const onCopilotEvent = (...args) => {
       const agentId = args[0];
@@ -2204,17 +2635,35 @@ var RelaySessionGateway = class {
     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] ?? "" });
+    const onAskUser = (...args) => {
+      const agentId = args[0];
+      const toolId = args[1] ?? "";
+      const requestId = args[2] ?? "";
+      const question = args[3] ?? "";
+      const options = args[4] ?? [];
+      const freeform = Boolean(args[5]);
+      cb({ agentId, kind: "ask-user", askUser: { toolId, requestId, question, options, freeform } });
+    };
+    const onAskUserComplete = (...args) => {
+      const agentId = args[0];
+      const requestId = args[1] ?? "";
+      cb({ agentId, kind: "ask-user-complete", requestId });
+    };
     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);
+    this.relay.mainEvents.on("copilot-ask-user", onAskUser);
+    this.relay.mainEvents.on("copilot-ask-user-complete", onAskUserComplete);
     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);
+      this.relay.mainEvents.off("copilot-ask-user", onAskUser);
+      this.relay.mainEvents.off("copilot-ask-user-complete", onAskUserComplete);
     };
   }
   onSessionExit(cb) {
@@ -2314,6 +2763,9 @@ function createAllowlistedGraphSender(inner, getAllowed) {
   if (inner.listChannels) {
     wrapped.listChannels = (teamId) => inner.listChannels(teamId);
   }
+  if (inner.getChannel) {
+    wrapped.getChannel = (teamId, channelId) => inner.getChannel(teamId, channelId);
+  }
   return wrapped;
 }
 function officeChannelOverridesFromJson(json) {
@@ -2363,6 +2815,19 @@ function encodeMetaBlock(meta) {
   const b64 = Buffer.from(JSON.stringify(meta), "utf8").toString("base64");
   return `<p>${META_OPEN}${b64}${META_CLOSE}</p>`;
 }
+function renderRoutingSummary(meta) {
+  const mention = meta.mentionType === "none" || !meta.mentionId ? "none" : `${meta.mentionType}: ${meta.mentionId}`;
+  const rows = [
+    ["Destination channel", meta.destChannelId],
+    ["Destination team", meta.destTeamId],
+    ["Thread", meta.threadRootId || "(new root)"],
+    ["Mention", mention],
+    ["Title", meta.title || "(none)"]
+  ];
+  const lines = rows.map(([label, value]) => `${escapeHtml(label)}: ${escapeHtml(value)}`).join("<br/>");
+  const block = `<p><em>Relay routing (diagnostic \u2014 ignored by flow)</em><br/>${lines}</p>`;
+  return stripMetaMarkers(block);
+}
 function createRelaySender(opts) {
   const resolveDump = () => {
     const url = opts.getDumpChannelUrl().trim();
@@ -2371,7 +2836,7 @@ function createRelaySender(opts) {
     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) => {
+  const postToDump = async (dest, title, html, hostedImages, mentionOverride) => {
     if (!opts.isDestinationAllowed(dest.channelId)) {
       throw new Error(
         `Teams outbound blocked: destination channel ${dest.channelId} is not in the allowlist (relay).`
@@ -2379,7 +2844,8 @@ function createRelaySender(opts) {
     }
     const dump = resolveDump();
     let resolved = { mentionType: "none", mentionId: "" };
-    const ref = opts.getMention();
+    const hasOverride = !!(mentionOverride && mentionOverride.type !== "none" && mentionOverride.value.trim());
+    const ref = hasOverride ? mentionOverride : opts.getMention();
     if (ref && ref.type !== "none" && ref.value.trim()) {
       try {
         resolved = await opts.resolveMention({ type: ref.type, value: ref.value.trim() }, dest.teamId);
@@ -2399,7 +2865,7 @@ function createRelaySender(opts) {
       title,
       html: humanHtml
     };
-    const body = `${humanHtml}${encodeMetaBlock(meta)}`;
+    const body = `${humanHtml}${renderRoutingSummary(meta)}${encodeMetaBlock(meta)}`;
     await opts.primary.createThread({
       teamId: dump.teamId,
       channelId: dump.channelId,
@@ -2411,7 +2877,7 @@ function createRelaySender(opts) {
   };
   return {
     async createThread(p) {
-      await postToDump({ teamId: p.teamId, channelId: p.channelId, threadRootId: "" }, p.subject, p.html, p.hostedImages);
+      await postToDump({ teamId: p.teamId, channelId: p.channelId, threadRootId: "" }, p.subject, p.html, p.hostedImages, p.mentionOverride);
       return { threadRootId: "", webUrl: "" };
     },
     async replyToThread(p) {
@@ -2419,7 +2885,8 @@ function createRelaySender(opts) {
         { teamId: p.teamId, channelId: p.channelId, threadRootId: p.threadRootId },
         "",
         p.html,
-        p.hostedImages
+        p.hostedImages,
+        p.mentionOverride
       );
       return { messageId: "" };
     }
@@ -2602,7 +3069,10 @@ import_electron4.app.whenReady().then(async () => {
       path8.join(process.cwd(), ".data", "teams-token.enc"),
       import_electron4.safeStorage
     );
-    const tokens = new AzTokenProvider(void 0, tokenPersistence);
+    const tokens = new AzTokenProvider(void 0, tokenPersistence, {
+      onAcquire: (resource) => teamsService?.onTokenOutcome("acquire", resource, false),
+      onFailure: (resource, err, usedCache) => teamsService?.onTokenOutcome("fail", resource, usedCache, err)
+    });
     const getAllowedChannels = createCachedAllowedChannels(
       () => allowedChannelIdSet(
         settingsStore.load().defaultChannelUrl,
@@ -2675,8 +3145,11 @@ import_electron4.app.whenReady().then(async () => {
       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 (settings.enabled) {
+          teamsService?.start().then(() => teamsService?.verifyAccess(settings)).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) {