@launchsecure/launch-kit 0.0.39 → 0.0.41

package/dist/server/deck-mcp-entry.js

@@ -128,24 +128,24 @@ var init_deck_lockfile = __esm({
 
 // src/server/deck-config.ts
 function loadDeckConfig(rootDir) {
-  const configPath = (0, import_node_path2.join)(rootDir, CONFIG_FILENAME);
-  if (!(0, import_node_fs2.existsSync)(configPath)) return {};
+  const configPath = (0, import_node_path3.join)(rootDir, CONFIG_FILENAME);
+  if (!(0, import_node_fs3.existsSync)(configPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(configPath, "utf-8"));
+    return JSON.parse((0, import_node_fs3.readFileSync)(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveDeckConfig(rootDir, config) {
-  const configPath = (0, import_node_path2.join)(rootDir, CONFIG_FILENAME);
-  (0, import_node_fs2.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configPath = (0, import_node_path3.join)(rootDir, CONFIG_FILENAME);
+  (0, import_node_fs3.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
-var import_node_fs2, import_node_path2, CONFIG_FILENAME;
+var import_node_fs3, import_node_path3, CONFIG_FILENAME;
 var init_deck_config = __esm({
   "src/server/deck-config.ts"() {
     "use strict";
-    import_node_fs2 = require("node:fs");
-    import_node_path2 = require("node:path");
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
     CONFIG_FILENAME = ".launchdeck.json";
   }
 });
@@ -1250,7 +1250,7 @@ var init_cred_shape = __esm({
 });
 
 // src/server/mcp-client.ts
-function mcpConfigFromCourse(projectRoot) {
+function mcpConfigForProfile(projectRoot, name) {
   let cred;
   try {
     cred = readCredFile(projectRoot);
@@ -1260,7 +1260,7 @@ function mcpConfigFromCourse(projectRoot) {
   if (!cred) return null;
   const nested = toNested(cred);
   if (!nested) return null;
-  const profile = nested.profiles[nested.active];
+  const profile = nested.profiles[name];
   if (!profile?.pat || !profile.serverUrl || !profile.orgSlug || !profile.projectSlug) {
     return null;
   }
@@ -1273,6 +1273,37 @@ function mcpConfigFromCourse(projectRoot) {
     }
   };
 }
+function mcpConfigFromCourse(projectRoot) {
+  let cred;
+  try {
+    cred = readCredFile(projectRoot);
+  } catch {
+    return null;
+  }
+  if (!cred) return null;
+  const nested = toNested(cred);
+  if (!nested) return null;
+  return mcpConfigForProfile(projectRoot, nested.active);
+}
+function listCourses(projectRoot) {
+  let cred;
+  try {
+    cred = readCredFile(projectRoot);
+  } catch {
+    return [];
+  }
+  if (!cred) return [];
+  const nested = toNested(cred);
+  if (!nested) return [];
+  return Object.entries(nested.profiles).map(([name, p]) => ({
+    name,
+    org: p.orgSlug ?? "",
+    project: p.projectSlug ?? "",
+    serverUrl: p.serverUrl ?? "",
+    active: name === nested.active,
+    usable: Boolean(p.pat && p.serverUrl && p.orgSlug && p.projectSlug)
+  }));
+}
 function loadMcpConfig(projectRoot) {
   if (_config) return _config;
   const fromCourse = mcpConfigFromCourse(projectRoot);
@@ -1280,13 +1311,13 @@ function loadMcpConfig(projectRoot) {
     _config = fromCourse;
     return _config;
   }
-  const mcpPath = (0, import_node_path3.join)(projectRoot, ".mcp.json");
-  if (!(0, import_node_fs3.existsSync)(mcpPath)) {
+  const mcpPath = (0, import_node_path4.join)(projectRoot, ".mcp.json");
+  if (!(0, import_node_fs4.existsSync)(mcpPath)) {
     throw new Error(
       `No active course in ${CONFIG_FILENAME2} and no .mcp.json at ${mcpPath}. Run \`launch-course\` or bootstrap with \`launch-kit init\`.`
     );
   }
-  const raw = JSON.parse((0, import_node_fs3.readFileSync)(mcpPath, "utf-8"));
+  const raw = JSON.parse((0, import_node_fs4.readFileSync)(mcpPath, "utf-8"));
   const entry = raw.mcpServers["launch-secure"];
   if (!entry?.url) {
     throw new Error(
@@ -1299,6 +1330,23 @@ function loadMcpConfig(projectRoot) {
   };
   return _config;
 }
+function withMcpConfig(override, fn) {
+  const run = async () => {
+    const prevConfig = _config;
+    const prevSession = _sessionId;
+    _config = override;
+    _sessionId = null;
+    try {
+      return await fn();
+    } finally {
+      _config = prevConfig;
+      _sessionId = prevSession;
+    }
+  };
+  const result = _overrideLock.then(run, run);
+  _overrideLock = result.then(() => void 0, () => void 0);
+  return result;
+}
 function parseSSE(text2) {
   const lines = text2.split("\n");
   for (const line of lines) {
@@ -1373,7 +1421,13 @@ async function callTool(toolName, args) {
   }
   const textContent = result.result?.content?.[0]?.text;
   if (!textContent) return null;
-  return JSON.parse(textContent);
+  try {
+    return JSON.parse(textContent);
+  } catch {
+    const match = textContent.match(/──+\s*Error\s*──+\s*\n([\s\S]*?)(?:\n\n──|$)/i);
+    const message = (match?.[1] ?? textContent).trim();
+    throw new Error(message || "MCP tool returned an unparseable response");
+  }
 }
 async function writeDeck(input) {
   const result = await callTool("communication_write", {
@@ -1382,6 +1436,7 @@ async function writeDeck(input) {
     resource_type: "deck",
     fields: {
       deckHtml: input.html,
+      deckBlocks: input.blocks,
       sessionId: input.sessionId,
       blockCount: input.blockCount,
       sharedFrom: "launch-deck"
@@ -1396,6 +1451,7 @@ async function updateDeck(commentId, input) {
     body: input.body,
     fields: {
       deckHtml: input.html,
+      deckBlocks: input.blocks,
       sessionId: input.sessionId,
       blockCount: input.blockCount,
       sharedFrom: "launch-deck"
@@ -1406,16 +1462,42 @@ async function updateDeck(commentId, input) {
 async function deleteDeck(commentId) {
   await callTool("communication_delete", { comment_id: commentId });
 }
-var import_node_fs3, import_node_path3, _config, _requestId, _sessionId;
+function currentMcpOrigin() {
+  const config = _config;
+  if (!config) throw new Error("MCP config not loaded \u2014 call loadMcpConfig first");
+  return new URL(config.url).origin;
+}
+async function createDeckShareLink(commentId) {
+  const result = await callTool("deck_share_link", {
+    comment_id: commentId,
+    action: "create"
+  });
+  const token = result.link.token;
+  return {
+    linkId: result.link.id,
+    token,
+    shareUrl: `${currentMcpOrigin()}/s/deck/${token}`,
+    reused: Boolean(result.reused)
+  };
+}
+async function revokeDeckShareLink(commentId, linkId) {
+  await callTool("deck_share_link", {
+    comment_id: commentId,
+    action: "revoke",
+    link_id: linkId
+  });
+}
+var import_node_fs4, import_node_path4, _config, _requestId, _sessionId, _overrideLock;
 var init_mcp_client = __esm({
   "src/server/mcp-client.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
     init_cred_shape();
     _config = null;
     _requestId = 0;
     _sessionId = null;
+    _overrideLock = Promise.resolve();
   }
 });
 
@@ -1423,6 +1505,7 @@ var init_mcp_client = __esm({
 var deck_serve_exports = {};
 __export(deck_serve_exports, {
   broadcastToClients: () => broadcastToClients,
+  buildSharePayload: () => buildSharePayload,
   consumeRenderError: () => consumeRenderError,
   createFeedbackWaiter: () => createFeedbackWaiter,
   resolveFeedback: () => resolveFeedback,
@@ -1430,14 +1513,14 @@ __export(deck_serve_exports, {
   startDeckServer: () => startDeckServer
 });
 function sessionDir(cwd, session) {
-  return import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", session);
+  return import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", session);
 }
 function sessionJsonPath(cwd, session) {
-  return import_node_path4.default.join(sessionDir(cwd, session), "session.json");
+  return import_node_path5.default.join(sessionDir(cwd, session), "session.json");
 }
 function readPersistedSession(cwd, session) {
   try {
-    const raw = import_node_fs4.default.readFileSync(sessionJsonPath(cwd, session), "utf-8");
+    const raw = import_node_fs5.default.readFileSync(sessionJsonPath(cwd, session), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1445,7 +1528,7 @@ function readPersistedSession(cwd, session) {
 }
 function writePersistedSession(cwd, session, payload) {
   const dir = sessionDir(cwd, session);
-  import_node_fs4.default.mkdirSync(dir, { recursive: true });
+  import_node_fs5.default.mkdirSync(dir, { recursive: true });
   const existing = readPersistedSession(cwd, session);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const next = {
@@ -1457,13 +1540,13 @@ function writePersistedSession(cwd, session, payload) {
     createdAt: existing?.createdAt ?? now,
     updatedAt: now
   };
-  import_node_fs4.default.writeFileSync(sessionJsonPath(cwd, session), JSON.stringify(next, null, 2));
+  import_node_fs5.default.writeFileSync(sessionJsonPath(cwd, session), JSON.stringify(next, null, 2));
   return next;
 }
 function listPersistedSessions(cwd) {
-  const base = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files");
-  if (!import_node_fs4.default.existsSync(base)) return [];
-  const entries = import_node_fs4.default.readdirSync(base, { withFileTypes: true });
+  const base = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files");
+  if (!import_node_fs5.default.existsSync(base)) return [];
+  const entries = import_node_fs5.default.readdirSync(base, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -1478,33 +1561,53 @@ function listPersistedSessions(cwd) {
       createdAt: persisted.createdAt,
       updatedAt: persisted.updatedAt,
       shared: Boolean(sync),
-      stale: Boolean(sync) && persisted.version > (sync?.version ?? 0)
+      stale: Boolean(sync) && persisted.version > (sync?.version ?? 0),
+      shareUrl: sync?.publicShareUrl,
+      course: sync?.course
     });
   }
   sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   return sessions;
 }
 function deletePersistedSession(cwd, session) {
-  const base = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files");
+  const base = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files");
   if (session === "all") {
-    if (import_node_fs4.default.existsSync(base)) import_node_fs4.default.rmSync(base, { recursive: true, force: true });
+    if (import_node_fs5.default.existsSync(base)) import_node_fs5.default.rmSync(base, { recursive: true, force: true });
     return;
   }
   const dir = sessionDir(cwd, session);
-  if (import_node_fs4.default.existsSync(dir)) import_node_fs4.default.rmSync(dir, { recursive: true, force: true });
+  if (import_node_fs5.default.existsSync(dir)) import_node_fs5.default.rmSync(dir, { recursive: true, force: true });
 }
 function syncJsonPath(cwd, session) {
-  return import_node_path4.default.join(sessionDir(cwd, session), ".sync.json");
+  return import_node_path5.default.join(sessionDir(cwd, session), ".sync.json");
 }
 function readSyncRecord(cwd, session) {
   try {
-    return JSON.parse(import_node_fs4.default.readFileSync(syncJsonPath(cwd, session), "utf-8"));
+    return JSON.parse(import_node_fs5.default.readFileSync(syncJsonPath(cwd, session), "utf-8"));
   } catch {
     return null;
   }
 }
 function writeSyncRecord(cwd, session, rec) {
-  import_node_fs4.default.writeFileSync(syncJsonPath(cwd, session), JSON.stringify(rec, null, 2));
+  import_node_fs5.default.writeFileSync(syncJsonPath(cwd, session), JSON.stringify(rec, null, 2));
+}
+function resolveShareConfig(cwd, course) {
+  if (course) {
+    const override = mcpConfigForProfile(cwd, course);
+    if (!override) {
+      return { error: `Course "${course}" is not a usable profile in .launch-secure.cred.config (missing pat/serverUrl/orgSlug/projectSlug?).` };
+    }
+    return { override };
+  }
+  try {
+    loadMcpConfig(cwd);
+  } catch (err) {
+    return { error: `Cloud sharing needs an active LaunchSecure course (.launch-secure.cred.config) or a "launch-secure" entry in .mcp.json: ${String(err)}` };
+  }
+  return { override: null };
+}
+function runWithShareConfig(override, fn) {
+  return override ? withMcpConfig(override, fn) : fn();
 }
 function escHtml2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -1517,36 +1620,54 @@ function readIframeArtifact(cwd, src) {
   const rel = decodeURIComponent(src.slice("/deck-files/".length));
   if (rel.includes("..")) return null;
   try {
-    return import_node_fs4.default.readFileSync(import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", rel), "utf-8");
+    return import_node_fs5.default.readFileSync(import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", rel), "utf-8");
   } catch {
     return null;
   }
 }
-function renderShareSection(cwd, block) {
-  const label = block?.label ? `<h2 class="db-title">${escHtml2(String(block.label))}</h2>` : "";
+function renderShareSection(cwd, block, showLabel = true) {
+  const label = showLabel && block?.label ? `<h2 class="db-title">${escHtml2(String(block.label))}</h2>` : "";
   switch (block?.type) {
     case "iframe": {
       const doc = readIframeArtifact(cwd, block.src) ?? "<p>(missing artifact)</p>";
-      return `<section class="db">${label}<iframe class="db-frame" sandbox="allow-scripts allow-popups" srcdoc="${escAttr(doc)}"></iframe></section>`;
+      return `${label}<iframe class="db-frame" sandbox="allow-scripts allow-popups" srcdoc="${escAttr(doc)}"></iframe>`;
     }
     case "rich-html":
     case "html":
-      return `<section class="db">${label}<div class="db-html">${typeof block.content === "string" ? block.content : ""}</div></section>`;
+      return `${label}<div class="db-html">${typeof block.content === "string" ? block.content : ""}</div>`;
     case "markdown":
-      return `<section class="db">${label}<div class="db-md" data-md="${escAttr(typeof block.content === "string" ? block.content : "")}"></div></section>`;
+      return `${label}<div class="db-md" data-md="${escAttr(typeof block.content === "string" ? block.content : "")}"></div>`;
     case "mermaid":
-      return `<section class="db">${label}<pre class="mermaid">${escHtml2(typeof block.content === "string" ? block.content : "")}</pre></section>`;
+      if (typeof block.renderedSvg === "string" && block.renderedSvg.trim()) {
+        return `${label}<div class="mermaid-svg">${block.renderedSvg}</div>`;
+      }
+      return `${label}<pre class="mermaid">${escHtml2(typeof block.content === "string" ? block.content : "")}</pre>`;
     case "options": {
       const opts = Array.isArray(block.options) ? block.options : [];
-      const lis = opts.map(
-        (o) => `<li><strong>${escHtml2(String(o?.label ?? o?.id ?? ""))}</strong>${o?.description ? ` \u2014 ${escHtml2(String(o.description))}` : ""}</li>`
+      const cards = opts.map(
+        (o) => `<div class="db-option"><div class="db-option-label">${escHtml2(String(o?.label ?? o?.id ?? ""))}</div>${o?.description ? `<div class="db-option-desc">${escHtml2(String(o.description))}</div>` : ""}${o?.preview ? `<pre class="db-option-pre">${escHtml2(String(o.preview))}</pre>` : ""}</div>`
       ).join("");
-      return `<section class="db">${label}<ul>${lis}</ul></section>`;
+      return `${label}<div class="db-options">${cards}</div>`;
     }
     default:
-      return `<section class="db">${label}</section>`;
+      return label;
   }
 }
+function buildSharePayload(cwd, session, blocks, svgByIndex = {}) {
+  const enriched = blocks.map((b, i) => {
+    const svg = svgByIndex[String(i)];
+    return b?.type === "mermaid" && typeof svg === "string" && svg.trim() ? { ...b, renderedSvg: svg } : b;
+  });
+  const html = buildShareHtml(cwd, session, enriched);
+  const cloudBlocks = enriched.map((b) => {
+    if (b?.type === "iframe" && typeof b.src === "string") {
+      const content = readIframeArtifact(cwd, b.src);
+      return content ? { ...b, content } : b;
+    }
+    return b;
+  });
+  return { html, cloudBlocks };
+}
 function buildShareHtml(cwd, session, blocks) {
   if (blocks.length === 1) {
     const only = blocks[0];
@@ -1556,28 +1677,57 @@ function buildShareHtml(cwd, session, blocks) {
     }
   }
   const list = blocks;
-  const sections = list.map((b) => renderShareSection(cwd, b)).join("\n");
+  const multi = list.length > 1;
+  const tabBar = multi ? `<nav class="deck-tabs">${list.map(
+    (b, i) => `<button class="deck-tab${i === 0 ? " active" : ""}" data-tab-btn="${i}">${escHtml2(String(b?.label ?? `Tab ${i + 1}`))}</button>`
+  ).join("")}</nav>` : "";
+  const sections = list.map(
+    (b, i) => `<section class="db" data-tab="${i}"${multi && i > 0 ? " hidden" : ""}>${renderShareSection(cwd, b, !multi)}</section>`
+  ).join("\n");
   const hasMd = list.some((b) => b?.type === "markdown");
-  const hasMermaid = list.some((b) => b?.type === "mermaid");
+  const hasUnrenderedMermaid = list.some(
+    (b) => b?.type === "mermaid" && !(typeof b?.renderedSvg === "string" && b.renderedSvg.trim())
+  );
   return `<!DOCTYPE html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${escHtml2(session)}</title>
+<link href="https://fonts.googleapis.com/css2?family=DM+Sans:opsz,wght@9..40,100..1000&display=swap" rel="stylesheet">
 <style>
-  body { margin:0; font-family: ui-sans-serif, system-ui, sans-serif; background:#0b0e14; color:#e6e9ef; }
+  body { margin:0; font-family: 'DM Sans', system-ui, sans-serif; background:#0b0e14; color:#e6e9ef; }
   .db { padding:20px 24px; border-bottom:1px solid #1e2433; }
   .db-title { font-size:13px; font-weight:600; margin:0 0 12px; color:#9aa4b2; text-transform:uppercase; letter-spacing:.05em; }
   .db-frame { width:100%; height:70vh; border:0; border-radius:8px; background:#fff; }
   .db-html { background:#fff; color:#111; border-radius:8px; padding:16px; overflow:auto; }
   ul { line-height:1.7; }
-  .mermaid { background:#fff; border-radius:8px; padding:16px; }
+  /* The embedded SVG is dark-themed (captured from the deck client); keep its
+     backdrop transparent so it sits on the dark page, matching the in-app
+     DeckView \u2014 not a white card. The CDN-source fallback also renders dark. */
+  .mermaid { background:transparent; border-radius:8px; padding:16px; }
+  .mermaid-svg { background:transparent; border-radius:8px; padding:16px; overflow:auto; }
+  .mermaid-svg svg { max-width:100%; height:auto; }
+  .db-options { display:grid; gap:12px; grid-template-columns:repeat(auto-fill, minmax(220px, 1fr)); }
+  .db-option { border:2px solid #1e2433; border-radius:8px; padding:16px; }
+  .db-option-label { font-size:14px; font-weight:600; color:#e6e9ef; }
+  .db-option-desc { margin-top:4px; font-size:12px; color:#9aa4b2; }
+  .db-option-pre { margin-top:8px; padding:8px; border-radius:6px; background:#11151f; font-size:12px; overflow:auto; }
+  .deck-tabs { position:sticky; top:0; z-index:5; display:flex; flex-wrap:wrap; gap:2px; background:#0b0e14; border-bottom:1px solid #1e2433; padding:0 16px; }
+  .deck-tab { appearance:none; border:0; background:transparent; color:#9aa4b2; font:inherit; font-size:13px; font-weight:500; padding:12px 16px; cursor:pointer; border-bottom:2px solid transparent; }
+  .deck-tab:hover { color:#e6e9ef; }
+  .deck-tab.active { color:#c084fc; border-bottom-color:#c084fc; }
+  .db[hidden] { display:none; }
 </style></head>
 <body>
+${tabBar}
 ${sections}
+${multi ? `<script>(function(){var b=[].slice.call(document.querySelectorAll('[data-tab-btn]')),s=[].slice.call(document.querySelectorAll('[data-tab]'));b.forEach(function(x){x.addEventListener('click',function(){var i=x.getAttribute('data-tab-btn');s.forEach(function(y){y.hidden=y.getAttribute('data-tab')!==i;});b.forEach(function(z){z.classList.toggle('active',z===x);});});});})();</script>` : ""}
 ${hasMd ? `<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
 <script>document.querySelectorAll('.db-md').forEach(function(el){try{el.innerHTML=marked.parse(el.dataset.md||'')}catch(e){el.textContent=el.dataset.md||''}});</script>` : ""}
-${hasMermaid ? `<script type="module">import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.esm.min.mjs';mermaid.initialize({startOnLoad:true,theme:'dark'});</script>` : ""}
+${hasUnrenderedMermaid ? `<script type="module">import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';mermaid.initialize({startOnLoad:true,theme:document.documentElement.classList.contains('light')?'default':'dark',securityLevel:'loose',fontFamily:"'DM Sans', system-ui, sans-serif"});</script>` : ""}
 </body></html>`;
 }
+function broadcastDiscuss() {
+  broadcastToClients({ type: "discuss_session", sessions: discussSessions.map((d) => d.id) });
+}
 function consumeRenderError() {
   const err = lastRenderError;
   lastRenderError = null;
@@ -1614,23 +1764,23 @@ function broadcastToClients(message) {
   }
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs4.default.existsSync(filePath) || !import_node_fs4.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path4.default.extname(filePath).toLowerCase();
+  if (!import_node_fs5.default.existsSync(filePath) || !import_node_fs5.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path5.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs4.default.createReadStream(filePath).pipe(res);
+  import_node_fs5.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function resolveClientDir() {
-  const sibling = import_node_path4.default.join(__dirname, "..", "deck-client");
-  if (import_node_fs4.default.existsSync(import_node_path4.default.join(sibling, "assets"))) return sibling;
-  const devDist = import_node_path4.default.join(__dirname, "..", "..", "dist", "deck-client");
-  if (import_node_fs4.default.existsSync(import_node_path4.default.join(devDist, "assets"))) return devDist;
+  const sibling = import_node_path5.default.join(__dirname, "..", "deck-client");
+  if (import_node_fs5.default.existsSync(import_node_path5.default.join(sibling, "assets"))) return sibling;
+  const devDist = import_node_path5.default.join(__dirname, "..", "..", "dist", "deck-client");
+  if (import_node_fs5.default.existsSync(import_node_path5.default.join(devDist, "assets"))) return devDist;
   return sibling;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path4.default.join(clientDir, "index.html");
-  if (!import_node_fs4.default.existsSync(indexPath)) {
+  const indexPath = import_node_path5.default.join(clientDir, "index.html");
+  if (!import_node_fs5.default.existsSync(indexPath)) {
     res.writeHead(500, { "Content-Type": "text/plain" });
     res.end(`LaunchDeck client bundle not found at ${clientDir}. Run 'npm run build:client'.`);
     return;
@@ -1713,6 +1863,10 @@ async function startDeckServer(opts = {}) {
         jsonResponse(res, 200, { config: cfg });
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/deck/courses") {
+        jsonResponse(res, 200, { courses: listCourses(cwd) });
+        return;
+      }
       if (req.method === "POST" && url2.pathname === "/api/deck/config") {
         try {
           const body = JSON.parse(await readBody(req));
@@ -1734,15 +1888,15 @@ async function startDeckServer(opts = {}) {
               const baseUrl = `/deck-files/${sessionEncoded}`;
               const html = generateBlastRadiusHtml(block.manifest, baseUrl);
               const report = generateBlastRadiusReport(block.manifest);
-              const dir = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", body.session);
-              import_node_fs4.default.mkdirSync(dir, { recursive: true });
-              import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, "blast-radius.html"), html);
-              import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, "blast-radius-report.md"), report);
-              import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, "blast-radius-manifest.json"), JSON.stringify(block.manifest, null, 2));
+              const dir = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", body.session);
+              import_node_fs5.default.mkdirSync(dir, { recursive: true });
+              import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, "blast-radius.html"), html);
+              import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, "blast-radius-report.md"), report);
+              import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, "blast-radius-manifest.json"), JSON.stringify(block.manifest, null, 2));
               const contractData = generateContract(block.manifest);
               const contractMd = contractToMarkdown(contractData);
-              import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, "contract.json"), JSON.stringify(contractData, null, 2));
-              import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, "contract.md"), contractMd);
+              import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, "contract.json"), JSON.stringify(contractData, null, 2));
+              import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, "contract.md"), contractMd);
               block.type = "iframe";
               block.src = `${baseUrl}/blast-radius.html`;
               delete block.manifest;
@@ -1769,9 +1923,9 @@ async function startDeckServer(opts = {}) {
                 const sessionEncoded = encodeURIComponent(body.session);
                 const baseUrl = `/deck-files/${sessionEncoded}`;
                 const filename = `${slugify(block.label)}.html`;
-                const dir = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", body.session);
-                import_node_fs4.default.mkdirSync(dir, { recursive: true });
-                import_node_fs4.default.writeFileSync(import_node_path4.default.join(dir, filename), html);
+                const dir = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", body.session);
+                import_node_fs5.default.mkdirSync(dir, { recursive: true });
+                import_node_fs5.default.writeFileSync(import_node_path5.default.join(dir, filename), html);
                 block.type = "iframe";
                 block.src = `${baseUrl}/${filename}`;
                 delete block.content;
@@ -1811,40 +1965,128 @@ async function startDeckServer(opts = {}) {
           jsonResponse(res, 404, { ok: false, error: "session not found" });
           return;
         }
+        let course;
+        let svgByIndex = {};
+        let publicLink = false;
         try {
-          loadMcpConfig(cwd);
-        } catch (err) {
-          jsonResponse(res, 400, {
-            ok: false,
-            error: `Cloud sharing needs an active LaunchSecure course (.launch-secure.cred.config) or a "launch-secure" entry in .mcp.json: ${String(err)}`
-          });
+          const raw = await readBody(req);
+          if (raw.trim()) {
+            const parsed = JSON.parse(raw);
+            course = parsed.course?.trim() || void 0;
+            if (parsed.svgByIndex && typeof parsed.svgByIndex === "object") svgByIndex = parsed.svgByIndex;
+            publicLink = parsed.publicLink === true;
+          }
+        } catch {
+        }
+        const cfg = resolveShareConfig(cwd, course);
+        if ("error" in cfg) {
+          jsonResponse(res, 400, { ok: false, error: cfg.error });
           return;
         }
+        const { override } = cfg;
         try {
           const blocks = Array.isArray(persisted.blocks) ? persisted.blocks : [];
-          const html = buildShareHtml(cwd, id, blocks);
+          const { html, cloudBlocks } = buildSharePayload(cwd, id, blocks, svgByIndex);
           const types = blocks.map((b) => b?.type).filter(Boolean);
           const body = `Shared deck "${id}" \u2014 ${blocks.length} block${blocks.length === 1 ? "" : "s"}${types.length ? ` (${types.join(", ")})` : ""}. Open the Decks tab in the Communication Center to view.`;
-          const input = { title: id, body, html, sessionId: id, blockCount: blocks.length };
-          const existing2 = readSyncRecord(cwd, id);
-          let resourceId;
-          let updated = false;
-          if (existing2?.resourceId) {
+          const input = { title: id, body, html, blocks: cloudBlocks, sessionId: id, blockCount: blocks.length };
+          const existingSync = readSyncRecord(cwd, id);
+          const doShare = async () => {
+            if (existingSync?.resourceId) {
+              try {
+                const { id: rid2 } = await updateDeck(existingSync.resourceId, input);
+                return { resourceId: rid2, updated: true };
+              } catch {
+                const { id: rid2 } = await writeDeck(input);
+                return { resourceId: rid2, updated: false };
+              }
+            }
+            const { id: rid } = await writeDeck(input);
+            return { resourceId: rid, updated: false };
+          };
+          const result = await runWithShareConfig(override, async () => {
+            const shared = await doShare();
+            let link = null;
+            let linkError;
+            if (publicLink) {
+              try {
+                const minted = await createDeckShareLink(shared.resourceId);
+                link = { shareUrl: minted.shareUrl, linkId: minted.linkId };
+              } catch (err) {
+                linkError = err instanceof Error ? err.message : String(err);
+              }
+            }
+            return { shared, link, linkError };
+          });
+          if (publicLink && result.linkError && !result.shared.updated) {
             try {
-              ({ id: resourceId } = await updateDeck(existing2.resourceId, input));
-              updated = true;
+              await runWithShareConfig(override, () => deleteDeck(result.shared.resourceId));
             } catch {
-              ({ id: resourceId } = await writeDeck(input));
             }
-          } else {
-            ({ id: resourceId } = await writeDeck(input));
+            jsonResponse(res, 200, {
+              ok: false,
+              error: `Couldn't create the public link, so the deck wasn't shared: ${result.linkError}`
+            });
+            return;
           }
+          const publicShareUrl = result.link?.shareUrl ?? existingSync?.publicShareUrl;
+          const publicLinkId = result.link?.linkId ?? existingSync?.publicLinkId;
           writeSyncRecord(cwd, id, {
-            resourceId,
+            resourceId: result.shared.resourceId,
             sharedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            version: persisted.version
+            version: persisted.version,
+            course,
+            ...publicShareUrl ? { publicShareUrl } : {},
+            ...publicLinkId ? { publicLinkId } : {}
+          });
+          jsonResponse(res, 200, {
+            ok: true,
+            resourceId: result.shared.resourceId,
+            updated: result.shared.updated,
+            course,
+            shareUrl: publicShareUrl ?? null,
+            ...result.linkError ? { linkWarning: result.linkError } : {}
           });
-          jsonResponse(res, 200, { ok: true, resourceId, updated });
+        } catch (err) {
+          jsonResponse(res, 500, { ok: false, error: String(err) });
+        }
+        return;
+      }
+      const publicLinkMatch = url2.pathname.match(/^\/api\/sessions\/([^/]+)\/public-link$/);
+      if (publicLinkMatch && (req.method === "POST" || req.method === "DELETE")) {
+        const id = decodeURIComponent(publicLinkMatch[1]);
+        const sync = readSyncRecord(cwd, id);
+        if (!sync?.resourceId) {
+          jsonResponse(res, 409, { ok: false, error: "Share this deck to the cloud first, then create a public link." });
+          return;
+        }
+        const cfg = resolveShareConfig(cwd, sync.course);
+        if ("error" in cfg) {
+          jsonResponse(res, 400, { ok: false, error: cfg.error });
+          return;
+        }
+        const { override } = cfg;
+        if (req.method === "DELETE") {
+          if (!sync.publicLinkId) {
+            if (sync.publicShareUrl) {
+              writeSyncRecord(cwd, id, { ...sync, publicShareUrl: void 0, publicLinkId: void 0 });
+            }
+            jsonResponse(res, 200, { ok: true, revoked: false });
+            return;
+          }
+          try {
+            await runWithShareConfig(override, () => revokeDeckShareLink(sync.resourceId, sync.publicLinkId));
+            writeSyncRecord(cwd, id, { ...sync, publicShareUrl: void 0, publicLinkId: void 0 });
+            jsonResponse(res, 200, { ok: true, revoked: true });
+          } catch (err) {
+            jsonResponse(res, 500, { ok: false, error: String(err) });
+          }
+          return;
+        }
+        try {
+          const minted = await runWithShareConfig(override, () => createDeckShareLink(sync.resourceId));
+          writeSyncRecord(cwd, id, { ...sync, publicShareUrl: minted.shareUrl, publicLinkId: minted.linkId });
+          jsonResponse(res, 200, { ok: true, shareUrl: minted.shareUrl });
         } catch (err) {
           jsonResponse(res, 500, { ok: false, error: String(err) });
         }
@@ -1867,12 +2109,21 @@ async function startDeckServer(opts = {}) {
         try {
           await deleteDeck(sync.resourceId);
           try {
-            import_node_fs4.default.rmSync(syncJsonPath(cwd, id), { force: true });
+            import_node_fs5.default.rmSync(syncJsonPath(cwd, id), { force: true });
           } catch {
           }
           jsonResponse(res, 200, { ok: true, deleted: true });
         } catch (err) {
-          jsonResponse(res, 500, { ok: false, error: String(err) });
+          const msg = err instanceof Error ? err.message : String(err);
+          if (/not\s*found/i.test(msg)) {
+            try {
+              import_node_fs5.default.rmSync(syncJsonPath(cwd, id), { force: true });
+            } catch {
+            }
+            jsonResponse(res, 200, { ok: true, deleted: false, reason: "already removed" });
+            return;
+          }
+          jsonResponse(res, 500, { ok: false, error: msg });
         }
         return;
       }
@@ -1963,6 +2214,10 @@ async function startDeckServer(opts = {}) {
           deletePersistedSession(cwd, session);
         } catch {
         }
+        const beforePins = discussSessions.length;
+        discussSessions = session === "all" ? [] : discussSessions.filter((d) => d.id !== session);
+        if (discussSessions.length !== beforePins) broadcastDiscuss();
+        if (session === "all" || activeSession?.id === session) activeSession = null;
         jsonResponse(res, 200, { ok: true });
         return;
       }
@@ -1971,6 +2226,16 @@ async function startDeckServer(opts = {}) {
         jsonResponse(res, 200, err ?? null);
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/active-session") {
+        jsonResponse(res, 200, {
+          discuss: discussSessions.map((d) => d.id),
+          // ordered = pin number
+          active: activeSession?.id ?? null,
+          focused: activeSession?.focused ?? false,
+          activeAt: activeSession?.at ?? null
+        });
+        return;
+      }
       if (req.method === "GET" && url2.pathname.startsWith("/deck-files/")) {
         const relative = decodeURIComponent(url2.pathname.slice("/deck-files/".length));
         if (relative.includes("..") || relative.startsWith("/")) {
@@ -1978,7 +2243,7 @@ async function startDeckServer(opts = {}) {
           res.end("Forbidden");
           return;
         }
-        const filePath = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", relative);
+        const filePath = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", relative);
         if (serveStatic(res, filePath)) return;
         res.writeHead(404);
         res.end("Not found");
@@ -1991,25 +2256,25 @@ async function startDeckServer(opts = {}) {
           res.end("Forbidden");
           return;
         }
-        const filePath = import_node_path4.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", relative);
-        if (!import_node_fs4.default.existsSync(filePath) || !import_node_fs4.default.statSync(filePath).isFile()) {
+        const filePath = import_node_path5.default.join(cwd, LAUNCHSECURE_DIR, "deck-files", relative);
+        if (!import_node_fs5.default.existsSync(filePath) || !import_node_fs5.default.statSync(filePath).isFile()) {
           res.writeHead(404);
           res.end("Not found");
           return;
         }
-        const ext = import_node_path4.default.extname(filePath).toLowerCase();
+        const ext = import_node_path5.default.extname(filePath).toLowerCase();
         const mime = MIME_TYPES[ext] ?? "application/octet-stream";
-        const filename = import_node_path4.default.basename(filePath);
+        const filename = import_node_path5.default.basename(filePath);
         res.writeHead(200, {
           "Content-Type": mime,
           "Content-Disposition": `attachment; filename="${filename}"`,
           "Cache-Control": "no-cache"
         });
-        import_node_fs4.default.createReadStream(filePath).pipe(res);
+        import_node_fs5.default.createReadStream(filePath).pipe(res);
         return;
       }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path4.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path5.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);
@@ -2043,6 +2308,24 @@ async function startDeckServer(opts = {}) {
             source: msg.source ?? ""
           };
         }
+        if (msg.type === "active_session" && msg.session) {
+          activeSession = {
+            id: msg.session,
+            focused: msg.focused ?? false,
+            at: Date.now()
+          };
+        }
+        if (msg.type === "discuss_session" && msg.session) {
+          const id = msg.session;
+          const idx = discussSessions.findIndex((d) => d.id === id);
+          if (idx >= 0) discussSessions.splice(idx, 1);
+          else discussSessions.push({ id, at: Date.now() });
+          broadcastDiscuss();
+        }
+        if (msg.type === "discuss_clear_all") {
+          discussSessions = [];
+          broadcastDiscuss();
+        }
       } catch {
       }
     });
@@ -2108,13 +2391,13 @@ function runServeCli(argv) {
     process.exit(1);
   });
 }
-var import_node_http, import_node_fs4, import_node_path4, import_ws, DEFAULT_PORT, MAX_PORT_SCAN, MIME_TYPES, pendingFeedback, lastRenderError, wss;
+var import_node_http, import_node_fs5, import_node_path5, import_ws, DEFAULT_PORT, MAX_PORT_SCAN, MIME_TYPES, pendingFeedback, lastRenderError, activeSession, discussSessions, wss;
 var init_deck_serve = __esm({
   "src/server/deck-serve.ts"() {
     "use strict";
     import_node_http = __toESM(require("node:http"));
-    import_node_fs4 = __toESM(require("node:fs"));
-    import_node_path4 = __toESM(require("node:path"));
+    import_node_fs5 = __toESM(require("node:fs"));
+    import_node_path5 = __toESM(require("node:path"));
     import_ws = require("ws");
     init_launch_kit_paths();
     init_deck_lockfile();
@@ -2138,6 +2421,8 @@ var init_deck_serve = __esm({
     };
     pendingFeedback = /* @__PURE__ */ new Map();
     lastRenderError = null;
+    activeSession = null;
+    discussSessions = [];
     wss = null;
   }
 });
@@ -2208,15 +2493,15 @@ async function handleTool(name, args) {
             const baseUrl = `/deck-files/${sessionEncoded}`;
             const html = generateBlastRadiusHtml(block.manifest, baseUrl);
             const report = generateBlastRadiusReport(block.manifest);
-            const dir = (0, import_node_path5.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
-            import_node_fs5.default.mkdirSync(dir, { recursive: true });
-            import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "blast-radius.html"), html);
-            import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "blast-radius-report.md"), report);
-            import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "blast-radius-manifest.json"), JSON.stringify(block.manifest, null, 2));
+            const dir = (0, import_node_path6.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
+            import_node_fs6.default.mkdirSync(dir, { recursive: true });
+            import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "blast-radius.html"), html);
+            import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "blast-radius-report.md"), report);
+            import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "blast-radius-manifest.json"), JSON.stringify(block.manifest, null, 2));
             const contractData = generateContract(block.manifest);
             const contractMd = contractToMarkdown(contractData);
-            import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "contract.json"), JSON.stringify(contractData, null, 2));
-            import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "contract.md"), contractMd);
+            import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "contract.json"), JSON.stringify(contractData, null, 2));
+            import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "contract.md"), contractMd);
             block.type = "iframe";
             block.src = `${baseUrl}/blast-radius.html`;
             delete block.manifest;
@@ -2243,9 +2528,9 @@ async function handleTool(name, args) {
               const sessionEncoded = encodeURIComponent(session);
               const baseUrl = `/deck-files/${sessionEncoded}`;
               const filename = `${slugify(block.label)}.html`;
-              const dir = (0, import_node_path5.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
-              import_node_fs5.default.mkdirSync(dir, { recursive: true });
-              import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, filename), html);
+              const dir = (0, import_node_path6.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
+              import_node_fs6.default.mkdirSync(dir, { recursive: true });
+              import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, filename), html);
               block.type = "iframe";
               block.src = `${baseUrl}/${filename}`;
               delete block.content;
@@ -2339,11 +2624,11 @@ async function handleTool(name, args) {
         }));
       }
       try {
-        const logDir = (0, import_node_path5.join)((0, import_node_os2.homedir)(), LAUNCHSECURE_DIR);
-        (0, import_node_fs6.mkdirSync)(logDir, { recursive: true });
-        const logPath = (0, import_node_path5.join)(logDir, "launch-deck.log");
-        const out = (0, import_node_fs6.openSync)(logPath, "a");
-        const err = (0, import_node_fs6.openSync)(logPath, "a");
+        const logDir = (0, import_node_path6.join)((0, import_node_os3.homedir)(), LAUNCHSECURE_DIR);
+        (0, import_node_fs7.mkdirSync)(logDir, { recursive: true });
+        const logPath = (0, import_node_path6.join)(logDir, "launch-deck.log");
+        const out = (0, import_node_fs7.openSync)(logPath, "a");
+        const err = (0, import_node_fs7.openSync)(logPath, "a");
         const entryPath = process.argv[1];
         const config = loadDeckConfig(projectRoot);
         const resolvedPort = args.port ?? config.port;
@@ -2397,23 +2682,47 @@ async function handleTool(name, args) {
       }
       return text(JSON.stringify({ running: false }));
     }
+    case "active_session": {
+      const lock = getLiveLock(projectRoot);
+      if (!lock) {
+        return text(JSON.stringify({
+          error: "LaunchDeck server is not running \u2014 nothing is open.",
+          hint: "Start it with start_server, or ask the user to open the deck."
+        }));
+      }
+      try {
+        const resp = await fetch(`${lock.url}/api/active-session`, {
+          signal: AbortSignal.timeout(3e3)
+        });
+        const data = await resp.json();
+        const pins = data.discuss ?? [];
+        const targets = pins.length ? pins : data.active ? [data.active] : [];
+        return text(JSON.stringify({
+          ...data,
+          targets,
+          targetSource: pins.length ? "pinned" : data.active ? "active-tab" : "none"
+        }));
+      } catch (err) {
+        return text(JSON.stringify({ error: `Failed to read active session: ${err}` }));
+      }
+    }
     case "generate_contract": {
       const session = args.session;
-      const dir = (0, import_node_path5.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
-      const manifestPath = (0, import_node_path5.join)(dir, "blast-radius-manifest.json");
-      if (!import_node_fs5.default.existsSync(manifestPath)) {
+      const dir = (0, import_node_path6.join)(projectRoot, LAUNCHSECURE_DIR, "deck-files", session);
+      const manifestPath = (0, import_node_path6.join)(dir, "blast-radius-manifest.json");
+      if (!import_node_fs6.default.existsSync(manifestPath)) {
         return text(JSON.stringify({
           error: `No blast radius manifest found for session "${session}". Push a blast-radius block first.`,
           hint: "Use the deck tool with a blast-radius block type to create a session."
         }));
       }
       try {
-        const raw = import_node_fs5.default.readFileSync(manifestPath, "utf-8");
+        const raw = import_node_fs6.default.readFileSync(manifestPath, "utf-8");
         const manifest = JSON.parse(raw);
         const contract = generateContract(manifest);
         const markdown = contractToMarkdown(contract);
-        import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "contract.json"), JSON.stringify(contract, null, 2));
-        import_node_fs5.default.writeFileSync((0, import_node_path5.join)(dir, "contract.md"), markdown);
+        import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "contract.json"), JSON.stringify(contract, null, 2));
+        import_node_fs6.default.writeFileSync((0, import_node_path6.join)(dir, "contract.md"), markdown);
         return text(JSON.stringify(contract));
       } catch (err) {
         return text(JSON.stringify({ error: `Failed to generate contract: ${err}` }));
@@ -2504,16 +2813,16 @@ function startDeckMcpServer() {
     process.exit(0);
   });
 }
-var import_node_http2, import_node_fs5, import_node_path5, import_node_child_process2, import_node_fs6, import_node_os2, SERVER_INFO, TOOLS;
+var import_node_http2, import_node_fs6, import_node_path6, import_node_child_process2, import_node_fs7, import_node_os3, SERVER_INFO, TOOLS;
 var init_deck_mcp = __esm({
   "src/server/deck-mcp.ts"() {
     "use strict";
     import_node_http2 = __toESM(require("node:http"));
-    import_node_fs5 = __toESM(require("node:fs"));
-    import_node_path5 = require("node:path");
+    import_node_fs6 = __toESM(require("node:fs"));
+    import_node_path6 = require("node:path");
     import_node_child_process2 = require("node:child_process");
-    import_node_fs6 = require("node:fs");
-    import_node_os2 = require("node:os");
+    import_node_fs7 = require("node:fs");
+    import_node_os3 = require("node:os");
     init_launch_kit_paths();
     init_deck_lockfile();
     init_deck_config();
@@ -2637,6 +2946,11 @@ var init_deck_mcp = __esm({
         description: "Check whether the LaunchDeck UI server is running.",
         inputSchema: { type: "object", properties: {} }
       },
+      {
+        name: "active_session",
+        description: 'Find out which deck(s) the user is currently looking at or watching. Returns `discuss` (an ORDERED list of sessions the user is explicitly WATCHING via the \u{1F441} eye button \u2014 order = the number shown in the UI; the strongest signal, use these when non-empty), `active` (the tab last shown in the browser), `focused` (whether the deck window itself was focused when `active` was reported \u2014 if false, the user is probably elsewhere and `active` is just the last-viewed tab), and `targets` (the resolved answer to "which deck(s) does the user mean": the watched decks if any, else the active tab). Use this instead of guessing from the session list when the user says "this deck" / "the open one" / "the ones I\'m watching".',
+        inputSchema: { type: "object", properties: {} }
+      },
       {
         name: "generate_contract",
         description: "Generate a contract from a previously pushed blast-radius session.\n\nReads the blast radius manifest from the session's saved files and produces a structured contract with actionable items, acceptance criteria, dependencies, and a verify-unchanged checklist.\n\nReturns JSON contract. Also saves contract.json and contract.md to the session directory.",
@@ -2657,8 +2971,92 @@ var init_deck_mcp = __esm({
 
 // src/server/deck-mcp-entry.ts
 init_deck_lockfile();
+
+// src/server/prune-npx-cache.ts
+var import_node_fs2 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path2 = require("node:path");
+var import_node_util = require("node:util");
+var PKG = "@launchsecure/launch-kit";
+var readFileAsync = (0, import_node_util.promisify)(import_node_fs2.readFile);
+var readdirAsync = (0, import_node_util.promisify)(import_node_fs2.readdir);
+var rmAsync = (0, import_node_util.promisify)(import_node_fs2.rm);
+var realpathAsync = (0, import_node_util.promisify)(import_node_fs2.realpath);
+function npxCacheRoot() {
+  const cache = process.env.npm_config_cache;
+  if (cache && cache.trim()) return (0, import_node_path2.join)(cache, "_npx");
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) return (0, import_node_path2.join)(localAppData, "npm-cache", "_npx");
+  }
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".npm", "_npx");
+}
+function ownVersion() {
+  let dir = __dirname;
+  for (let i = 0; i < 8; i++) {
+    try {
+      const pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(dir, "package.json"), "utf8"));
+      if (pkg && pkg.name === PKG) return typeof pkg.version === "string" ? pkg.version : null;
+    } catch {
+    }
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function pruneStaleNpxCache() {
+  try {
+    const version = ownVersion();
+    if (!version) return;
+    const root = npxCacheRoot();
+    let hashes;
+    try {
+      hashes = await readdirAsync(root);
+    } catch {
+      return;
+    }
+    const selfPath = await realpathAsync(process.argv[1] || __dirname).catch(() => __dirname);
+    let reaped = 0;
+    for (const hash of hashes) {
+      const dir = (0, import_node_path2.join)(root, hash);
+      if (selfPath === dir || selfPath.startsWith(dir + import_node_path2.sep)) continue;
+      let ver;
+      try {
+        const lkPkg = JSON.parse(
+          await readFileAsync((0, import_node_path2.join)(dir, "node_modules", PKG, "package.json"), "utf8")
+        );
+        ver = lkPkg.version;
+      } catch {
+        continue;
+      }
+      if (ver === version) continue;
+      try {
+        const top = JSON.parse(await readFileAsync((0, import_node_path2.join)(dir, "package.json"), "utf8"));
+        const spec = top?.dependencies?.[PKG];
+        if (typeof spec === "string" && spec.startsWith("file:")) continue;
+      } catch {
+      }
+      try {
+        await rmAsync(dir, { recursive: true, force: true });
+        reaped++;
+      } catch {
+      }
+    }
+    if (reaped > 0) {
+      process.stderr.write(
+        `[launch-kit] npx-cache: reaped ${reaped} stale copy(ies), kept v${version}
+`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/server/deck-mcp-entry.ts
 async function main() {
   setProjectRoot(process.cwd());
+  void pruneStaleNpxCache();
   const argv = process.argv.slice(2);
   const subcommand = argv[0];
   if (subcommand === "serve") {