flyspace-cli 0.1.32 → 0.1.34

package/dist/cli.js

@@ -18,6 +18,7 @@ import {
   SKIP_SUBTYPES,
   SLACK_ENV,
   SessionStore,
+  TRIAL_DAYS,
   UsageStore,
   activateMembership,
   agentLabel,
@@ -118,6 +119,7 @@ import {
   loadFullDashboardSettings,
   loadWorkspaceBranding,
   loadWorkspacePrompt,
+  markChannelGreeted,
   markInviteResent,
   markMemoryUsed,
   markWorkspaceGreeted,
@@ -159,6 +161,7 @@ import {
   setMembershipHandle,
   setMemoryAutoPaused,
   setOutputStyleDefault,
+  setWorkspaceArchived,
   setWorkspaceStripeSubscription,
   slackConfigured,
   startAutomationRegistryPolling,
@@ -184,7 +187,7 @@ import {
   warnOnBrokenChannelCwds,
   workspaceSkillsDir,
   writeSkillFile
-} from "./chunk-6YFDWUNF.js";
+} from "./chunk-KTMAS4TP.js";
 import {
   firstReplyBody,
   getThread,
@@ -618,14 +621,14 @@ function handleHostDbResult(id, res) {
 }
 function whenConnected() {
   if (sender) return Promise.resolve(sender);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timer2 = setTimeout(() => {
       onSender = onSender.filter((w) => w !== wake);
       reject(new Error("Host is not connected to the Data API"));
     }, REQUEST_TIMEOUT_MS);
     const wake = () => {
       clearTimeout(timer2);
-      resolve7(sender);
+      resolve8(sender);
     };
     onSender.push(wake);
   });
@@ -633,12 +636,12 @@ function whenConnected() {
 async function requestHostDb(req) {
   const send2 = await whenConnected();
   const id = randomUUID();
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timer2 = setTimeout(() => {
       pending.delete(id);
       reject(new Error("Data API did not answer in time"));
     }, REQUEST_TIMEOUT_MS);
-    pending.set(id, { resolve: resolve7, reject, timer: timer2 });
+    pending.set(id, { resolve: resolve8, reject, timer: timer2 });
     send2({ type: "db", id, req });
   });
 }
@@ -650,14 +653,14 @@ function handleAttachmentUrlResult(id, url) {
 async function requestAttachmentUrl(key) {
   const send2 = await whenConnected();
   const id = randomUUID();
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timer2 = setTimeout(() => {
       pendingUrls.delete(id);
       reject(new Error("Data API did not answer in time"));
     }, REQUEST_TIMEOUT_MS);
     pendingUrls.set(id, (url) => {
       clearTimeout(timer2);
-      resolve7(url);
+      resolve8(url);
     });
     send2({ type: "attachment-url", id, key });
   });
@@ -804,10 +807,10 @@ function editConfig() {
   const editor = process.env["EDITOR"] || "vi";
   console.log(`[flyspace] Opening ${paths.CONFIG_FILE} in ${editor}...`);
   const child = spawn(editor, [paths.CONFIG_FILE], { stdio: "inherit" });
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     child.on("close", (code) => {
       if (code === 0) {
-        resolve7();
+        resolve8();
       } else {
         reject(new Error(`Editor exited with code ${code}`));
       }
@@ -1858,7 +1861,7 @@ async function runAuthCmd(args) {
 }
 
 // ../api/src/version.ts
-var CLI_VERSION = true ? "0.1.32" : null;
+var CLI_VERSION = true ? "0.1.34" : null;
 function isOlderVersion(a, b) {
   const parse = (v) => v.replace(/^v/, "").split("-")[0].split(".").map(Number);
   const [pa, pb] = [parse(a), parse(b)];
@@ -2468,14 +2471,19 @@ function npmEnv(target) {
   return nodeBin ? { ...process.env, PATH: `${nodeBin}:${process.env.PATH ?? ""}` } : process.env;
 }
 async function runUpgrade() {
-  const current = "0.1.32";
+  const current = "0.1.34";
   console.log(`Current version: ${current}`);
   console.log("Checking for updates...\n");
   try {
     const latest2 = execSync6(`npm view ${"flyspace-cli"} version`, { encoding: "utf-8", env: npmEnv() }).trim();
     const stale = installTargets().filter((t) => installedVersion(t) !== latest2);
     if (stale.length === 0) {
-      console.log(`Already on the latest version (${current}).`);
+      if (current === latest2) {
+        console.log(`Already on the latest version (${current}).`);
+        return;
+      }
+      console.log(`${latest2} is installed but this process runs ${current}. Restarting...`);
+      restartInstalledProfiles();
       return;
     }
     console.log(`New version available: ${latest2}`);
@@ -4144,7 +4152,7 @@ async function startWorkspaceTrial(workspace, plan, ownerEmail) {
   const subscription = await stripe.subscriptions.create({
     customer: customer.id,
     items: [{ price: priceId }],
-    trial_period_days: 14,
+    trial_period_days: TRIAL_DAYS,
     trial_settings: { end_behavior: { missing_payment_method: "pause" } },
     metadata: { workspace_id: workspace.id, plan }
   });
@@ -4792,10 +4800,10 @@ var DEFAULT_DASHBOARD_PORT = 4747;
 var DEFAULT_DASHBOARD_HOST = "127.0.0.1";
 async function findFreePort(start, host = DEFAULT_DASHBOARD_HOST, attempts = 50) {
   for (let port = start; port < start + attempts; port++) {
-    const free = await new Promise((resolve7) => {
+    const free = await new Promise((resolve8) => {
       const probe3 = createServer();
-      probe3.once("error", () => resolve7(false));
-      probe3.once("listening", () => probe3.close(() => resolve7(true)));
+      probe3.once("error", () => resolve8(false));
+      probe3.once("listening", () => probe3.close(() => resolve8(true)));
       probe3.listen(port, host);
     });
     if (free) return port;
@@ -5623,14 +5631,14 @@ async function stepBrowserTokens(botName) {
     const appLink = page2.locator('a[href*="/apps/A"]').first();
     const hasExistingApp = await appLink.isVisible({ timeout: 3e3 }).catch(() => false);
     if (hasExistingApp) {
-      const tokenPromise = new Promise((resolve7) => {
+      const tokenPromise = new Promise((resolve8) => {
         page2.on("request", (req) => {
           if (token) return;
           const postData = req.postData() || "";
           const match = postData.match(/xoxc-[a-f0-9-]+/);
           if (match) {
             token = match[0];
-            resolve7(token);
+            resolve8(token);
           }
         });
       });
@@ -5681,7 +5689,7 @@ async function stepBrowserTokens(botName) {
     log4("Almost done! The browser will now open an install page.\n");
     console.log('  \x1B[1mPlease click "Install to Workspace", then click "Allow".\x1B[0m\n');
     await page2.goto(installUrl);
-    const installPage = await new Promise((resolve7, reject) => {
+    const installPage = await new Promise((resolve8, reject) => {
       let settled = false;
       let interval;
       let timeout;
@@ -5694,7 +5702,7 @@ async function stepBrowserTokens(botName) {
       };
       const checkUrl = (p) => {
         if (p.url().includes("install-on-team?success=1")) {
-          finish2(() => resolve7(p));
+          finish2(() => resolve8(p));
         }
       };
       context.on("page", (newPage) => {
@@ -6408,9 +6416,9 @@ async function runMcpCmd(args) {
 
 // src/commands/dashboard.ts
 import { spawn as spawn8, spawnSync } from "child_process";
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { platform as platform7 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 
 // src/reconcile.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
@@ -6583,7 +6591,7 @@ var requireDocsAccess = async (c, next) => {
 };
 
 // ../api/src/dashboard/api.ts
-import { Hono as Hono29 } from "hono";
+import { Hono as Hono31 } from "hono";
 
 // ../api/src/dashboard/public-share-routes.ts
 import { existsSync as existsSync17, readFileSync as readFileSync16, statSync as statSync3 } from "fs";
@@ -7648,7 +7656,7 @@ function truncationNotice(lang, voice) {
   if (lang === "en" || lang.startsWith("en-")) return TRUNCATION_NOTICE.en;
   return null;
 }
-var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep2 = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 async function synthesizeWithRetry(script, voice) {
   let lastError;
   for (let attempt = 1; attempt <= SYNTH_ATTEMPTS; attempt += 1) {
@@ -8735,7 +8743,17 @@ function pruneExpired(now) {
 }
 var SUPPORT_NAME = "Flyspace Support";
 var SUPPORT_AVATAR_URL = "/logo/flyspace-support.svg";
+function workspaceArchivedError() {
+  return new HTTPException2(403, {
+    res: Response.json({ error: "workspace archived", archived: true }, { status: 403 })
+  });
+}
 async function resolveAuthContext(c, opts = {}) {
+  const ctx = await resolveAuthContextCached(c, opts);
+  if (ctx?.archived && !ctx.isSupport) throw workspaceArchivedError();
+  return ctx;
+}
+async function resolveAuthContextCached(c, opts) {
   const cookie = c.req?.header("Cookie") ?? "";
   if (!cookie) return resolveAuthContextUncached(c);
   const key = `${getProfile()}\0${cookie}`;
@@ -8800,7 +8818,8 @@ async function resolveAuthContextUncached(c) {
     passwordSet: Boolean(metadata.passwordSetAt),
     agentConnectedAt: workspace.agentConnectedAt ?? null,
     projectsSetupAt: workspace.projectsSetupAt ?? null,
-    plan: workspace.plan ?? null
+    plan: workspace.plan ?? null,
+    ...workspace.archivedAt ? { archived: true } : {}
   };
 }
 
@@ -9116,11 +9135,19 @@ function loadHostPrivateKey(path = hostPrivateKeyPath()) {
 // ../api/src/dashboard/uploads-routes.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { Hono as Hono7 } from "hono";
+import sharp4 from "sharp";
 import { PutObjectCommand as PutObjectCommand2, GetObjectCommand as GetObjectCommand3 } from "@aws-sdk/client-s3";
 import { getSignedUrl as getSignedUrl3 } from "@aws-sdk/s3-request-presigner";
 var MAX_FILE_BYTES = 10 * 1024 * 1024;
 var PRESIGN_TTL_SECONDS2 = 300;
 var KEY_PREFIX = "chat";
+var RESIZABLE = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp", "image/avif"]);
+var FULL_EDGE = 2560;
+var THUMB_EDGE = 480;
+var WEBP_QUALITY = 80;
+function toWebp(input2, edge) {
+  return sharp4(input2).rotate().resize({ width: edge, height: edge, fit: "inside", withoutEnlargement: true }).webp({ quality: WEBP_QUALITY }).toBuffer();
+}
 var READABLE_PREFIXES = [KEY_PREFIX, SCRATCH_PREFIX];
 function sanitizeFilename(name) {
   const cleaned = name.replace(/[/\\]/g, "_").replace(/\s+/g, "-").replace(/[^\w.-]/g, "").trim();
@@ -9144,22 +9171,33 @@ function createUploadsRouter() {
     if (file.size > MAX_FILE_BYTES) {
       return c.json({ error: `file must be ${MAX_FILE_BYTES / (1024 * 1024)}MB or smaller` }, 400);
     }
-    const key = `${KEY_PREFIX}/${getProfile()}/${randomUUID2()}-${sanitizeFilename(file.name)}`;
-    const buffer = Buffer.from(await file.arrayBuffer());
-    await getR2Client().send(
-      new PutObjectCommand2({
-        Bucket: getR2Bucket(),
-        Key: key,
-        Body: buffer,
-        ContentType: file.type || "application/octet-stream"
-      })
-    );
+    const id = `${KEY_PREFIX}/${getProfile()}/${randomUUID2()}-${sanitizeFilename(file.name)}`;
+    const original = Buffer.from(await file.arrayBuffer());
+    const put = (Key, Body, ContentType) => getR2Client().send(new PutObjectCommand2({ Bucket: getR2Bucket(), Key, Body, ContentType }));
+    let key = id;
+    let size = file.size;
+    let type = file.type;
+    const renditions = RESIZABLE.has(file.type) ? await Promise.all([toWebp(original, FULL_EDGE), toWebp(original, THUMB_EDGE)]).catch(
+      () => null
+    ) : null;
+    if (renditions) {
+      const [full, thumb] = renditions;
+      key = `${id.replace(/\.[^./]*$/, "")}.webp`;
+      size = full.length;
+      type = "image/webp";
+      await Promise.all([
+        put(key, full, type),
+        put(key.replace(/\.webp$/, ".thumb.webp"), thumb, type)
+      ]);
+    } else {
+      await put(key, original, file.type || "application/octet-stream");
+    }
     return c.json(
       {
         url: `/api/attachments/${encodeKeyForUrl(key)}`,
         name: file.name,
-        type: file.type,
-        size: file.size
+        type,
+        size
       },
       201
     );
@@ -9544,12 +9582,94 @@ function createAuthRouter() {
   return auth;
 }
 
+// ../api/src/store/support-store.ts
+var SUPPORT_HANDLE = "flyspace-support";
+async function logSupportAction(entry) {
+  const { error: error2 } = await getSupabaseClient().from("support_access_log").insert({
+    workspace_id: entry.workspaceId,
+    staff_user_id: entry.staffUserId,
+    staff_email: entry.staffEmail,
+    action: entry.action,
+    detail: entry.detail ?? null
+  });
+  if (error2) throw new Error(`logSupportAction(${entry.action}): ${error2.message}`);
+}
+async function listSupportWorkspaceIds(userId) {
+  const { data, error: error2 } = await getSupabaseClient().from("memberships").select("workspace_id").eq("user_id", userId).eq("is_support", true);
+  if (error2) throw new Error(`listSupportWorkspaceIds: ${error2.message}`);
+  return new Set((data ?? []).map((r) => r.workspace_id));
+}
+async function grantSupportMembership(params) {
+  const db = getSupabaseClient();
+  const { data: existing, error: readError } = await db.from("memberships").select("is_support").eq("workspace_id", params.workspaceId).eq("user_id", params.userId).maybeSingle();
+  if (readError) throw new Error(`grantSupportMembership: ${readError.message}`);
+  if (existing) {
+    if (existing.is_support === true) return "existing";
+    throw new Error("already a regular member of this workspace");
+  }
+  const { data: taken } = await db.from("memberships").select("id").eq("workspace_id", params.workspaceId).eq("handle", SUPPORT_HANDLE).maybeSingle();
+  const handle = taken ? `${SUPPORT_HANDLE}-${params.userId.slice(0, 8)}` : SUPPORT_HANDLE;
+  const { error: error2 } = await db.from("memberships").insert({
+    workspace_id: params.workspaceId,
+    user_id: params.userId,
+    email: params.email,
+    handle,
+    role: "admin",
+    status: "active",
+    is_support: true,
+    accepted_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (error2) throw new Error(`grantSupportMembership: ${error2.message}`);
+  return "granted";
+}
+async function revokeSupportMembership(workspaceId, userId) {
+  const { data, error: error2 } = await getSupabaseClient().from("memberships").delete().eq("workspace_id", workspaceId).eq("user_id", userId).eq("is_support", true).select("id");
+  if (error2) throw new Error(`revokeSupportMembership: ${error2.message}`);
+  return (data ?? []).length > 0;
+}
+async function listSupportLog(filter) {
+  let query = getSupabaseClient().from("support_access_log").select("*").order("created_at", { ascending: false }).limit(Math.min(filter.limit ?? 200, 1e3));
+  if (filter.workspaceId) query = query.eq("workspace_id", filter.workspaceId);
+  const { data, error: error2 } = await query;
+  if (error2) throw new Error(`listSupportLog: ${error2.message}`);
+  return (data ?? []).map((r) => ({
+    id: r.id,
+    workspaceId: r.workspace_id,
+    staffUserId: r.staff_user_id,
+    staffEmail: r.staff_email,
+    action: r.action,
+    detail: r.detail ?? null,
+    createdAt: r.created_at
+  }));
+}
+
 // ../api/src/dashboard/auth-middleware.ts
+var ENTER_WINDOW_MS = 8 * 60 * 60 * 1e3;
+var lastEnter = /* @__PURE__ */ new Map();
+function auditSupport(ctx, action, detail) {
+  logSupportAction({
+    workspaceId: ctx.workspaceId,
+    staffUserId: ctx.userId,
+    staffEmail: ctx.email,
+    action,
+    detail
+  }).catch((err) => console.error("[support-audit]", err.message));
+}
 var requireWorkspaceMembership = async (c, next) => {
   const ctx = await resolveAuthContext(c);
   if (!ctx) return c.json({ error: "not signed in" }, 401);
   c.set("auth", ctx);
-  return next();
+  if (!ctx.isSupport) return next();
+  const key = `${ctx.userId}:${ctx.workspaceId}`;
+  const now = Date.now();
+  if ((lastEnter.get(key) ?? 0) + ENTER_WINDOW_MS < now) {
+    lastEnter.set(key, now);
+    auditSupport(ctx, "enter");
+  }
+  await next();
+  if (!["GET", "HEAD", "OPTIONS"].includes(c.req.method)) {
+    auditSupport(ctx, "write", { method: c.req.method, path: c.req.path, status: c.res.status });
+  }
 };
 
 // ../api/src/dashboard/billing-routes.ts
@@ -9654,7 +9774,14 @@ function createAdminRouter() {
   const admin = new Hono11();
   admin.use("*", requirePlatformOperator);
   admin.get("/workspaces", async (c) => {
-    const summaries = await listWorkspaceSummaries();
+    const operator = c.get("platformOperator");
+    const [summaries, supportIds, users] = await Promise.all([
+      listWorkspaceSummaries(),
+      listSupportWorkspaceIds(operator.userId),
+      // One call for every owner's profile metadata instead of one per row.
+      getSupabaseClient().auth.admin.listUsers({ perPage: 1e3 })
+    ]);
+    const usersById = new Map((users.data?.users ?? []).map((u) => [u.id, u]));
     const workspaces = await Promise.all(
       summaries.map(async (w) => {
         const agentModel = cachedProfileConfig(w.slug)?.agentModel;
@@ -9664,11 +9791,23 @@ function createAdminRouter() {
           console.error(`[admin] R2 usage for ${w.slug}:`, err.message);
           return null;
         });
+        const metadata = w.owner ? usersById.get(w.owner.userId)?.user_metadata : void 0;
+        const owner = w.owner && {
+          ...w.owner,
+          role: "admin",
+          avatarUrl: metadata?.avatarKey ? await signAvatarUrl(metadata.avatarKey) : null,
+          name: metadata?.name ?? null,
+          title: metadata?.title ?? null,
+          bio: metadata?.bio ?? null,
+          timeZone: metadata?.timeZone ?? null
+        };
         return {
           ...w,
+          owner,
           agent: agentModel ? { runner: runnerForModel(agentModel), model: agentModel } : null,
           r2Bytes,
-          flyVolumeBytes: null
+          flyVolumeBytes: null,
+          supportAccess: supportIds.has(w.id)
         };
       })
     );
@@ -9756,6 +9895,63 @@ function createAdminRouter() {
     }
     return c.json({ sent: true, inviteLink: inviteUrl.toString() });
   });
+  admin.post("/workspaces/:id/support-access", async (c) => {
+    const operator = c.get("platformOperator");
+    const workspaceId = c.req.param("id");
+    let result;
+    try {
+      result = await grantSupportMembership({
+        workspaceId,
+        userId: operator.userId,
+        email: operator.email
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "grant failed" }, 409);
+    }
+    if (result === "granted") {
+      await logSupportAction({
+        workspaceId,
+        staffUserId: operator.userId,
+        staffEmail: operator.email,
+        action: "grant"
+      });
+    }
+    invalidateAuthContextCache();
+    return c.json({ supportAccess: true });
+  });
+  admin.delete("/workspaces/:id/support-access", async (c) => {
+    const operator = c.get("platformOperator");
+    const workspaceId = c.req.param("id");
+    if (await revokeSupportMembership(workspaceId, operator.userId)) {
+      await logSupportAction({
+        workspaceId,
+        staffUserId: operator.userId,
+        staffEmail: operator.email,
+        action: "leave"
+      });
+    }
+    invalidateAuthContextCache();
+    return c.json({ supportAccess: false });
+  });
+  const archiveRoute = (archived) => async (c) => {
+    try {
+      await setWorkspaceArchived(c.req.param("id"), archived);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "archive failed";
+      return c.json({ error: message }, message === "workspace not found" ? 404 : 500);
+    }
+    invalidateAuthContextCache();
+    return c.json({ archived });
+  };
+  admin.post("/workspaces/:id/archive", archiveRoute(true));
+  admin.delete("/workspaces/:id/archive", archiveRoute(false));
+  admin.get("/support-log", async (c) => {
+    const entries2 = await listSupportLog({
+      workspaceId: c.req.query("workspace") || void 0,
+      limit: Number(c.req.query("limit")) || void 0
+    });
+    return c.json({ entries: entries2 });
+  });
   return admin;
 }
 
@@ -9765,7 +9961,7 @@ var BOT_DM_KEY = "claude";
 
 // ../api/src/dashboard/data-api.ts
 import { existsSync as existsSync20 } from "fs";
-import sharp5 from "sharp";
+import sharp6 from "sharp";
 
 // ../api/src/dashboard/automations-routes.ts
 import { Hono as Hono12 } from "hono";
@@ -10259,6 +10455,25 @@ var BOARD_STATUSES = [
   "cancelled"
 ];
 var NO_STATUS_COLUMN = "none";
+function isBoardStatus(v) {
+  return typeof v === "string" && BOARD_STATUSES.includes(v);
+}
+async function callerMembershipId(c) {
+  const viewer = c.get("auth");
+  if (!viewer) return null;
+  return (await getMembershipByUserId(viewer.workspaceId, viewer.userId))?.id ?? null;
+}
+async function rememberComposerStatus(c, channelId, status) {
+  const membershipId = await callerMembershipId(c);
+  if (!membershipId) return;
+  const { error: error2 } = await getSupabaseClient().from("channel_member_prefs").upsert({
+    channel_id: channelId,
+    membership_id: membershipId,
+    last_board_status: status,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (error2) throw new Error(error2.message);
+}
 function boardColumnParam(status) {
   if (status === NO_STATUS_COLUMN) return NO_STATUS_COLUMN;
   return BOARD_STATUSES.includes(status) ? status : null;
@@ -10324,7 +10539,9 @@ async function withPreviews(supabase, threads) {
   for (const { data } of chunkResults) {
     for (const r of data ?? []) {
       const entry = previewByThread.get(r.thread_id);
+      const images = r.body.includes("![") ? markdownImageUrls(slackMrkdwnToMarkdown(r.body)) : [];
       if (entry) {
+        entry.images.push(...images);
         entry.count += 1;
         entry.lastAuthor = r.author;
         entry.participants.delete(r.author);
@@ -10334,7 +10551,8 @@ async function withPreviews(supabase, threads) {
           count: 1,
           firstBody: r.body,
           lastAuthor: r.author,
-          participants: /* @__PURE__ */ new Map()
+          participants: /* @__PURE__ */ new Map(),
+          images
         });
     }
   }
@@ -10349,10 +10567,19 @@ async function withPreviews(supabase, threads) {
       // read, on this browser or any other (see web/src/lib/thread-unread).
       last_reply_author: entry && entry.count > 1 ? entry.lastAuthor : null,
       // Everyone who replied, most recent first, for the row's avatar stack.
-      participants: [...entry?.participants ?? []].reverse().map(([author, external_user_id]) => ({ author, external_user_id }))
+      participants: [...entry?.participants ?? []].reverse().map(([author, external_user_id]) => ({ author, external_user_id })),
+      // Every image in the thread, in order, so the row can show a thumbnail
+      // strip; only the first few URLs are sent, the rest are just counted.
+      images: (entry?.images ?? []).slice(0, ROW_IMAGE_LIMIT),
+      image_count: entry?.images.length ?? 0
     };
   });
 }
+var ROW_IMAGE_LIMIT = 3;
+var MARKDOWN_IMAGE_RE = /!\[[^\]]*\]\(\s*<?([^\s)>]+)>?(?:\s+"[^"]*")?\s*\)/g;
+function markdownImageUrls(markdown) {
+  return [...markdown.matchAll(MARKDOWN_IMAGE_RE)].map((m) => m[1]);
+}
 async function labelThread(channelId, body, scope) {
   const channel = getProfileChannelRegistry().find(
     (ch) => ch.id === channelId || ch.externalChannelId === channelId
@@ -10762,6 +10989,13 @@ function createChatRouter(agent = {}) {
     const clientKey2 = isNonEmptyString(input2.clientKey) ? input2.clientKey : null;
     const model = requestedModel(c, input2.model);
     const effort = requestedEffort(c, input2.effort);
+    const pickedStatus = input2.board_status;
+    if (pickedStatus != null && !isBoardStatus(pickedStatus)) {
+      return c.json(
+        { error: `board_status must be null or one of: ${BOARD_STATUSES.join(", ")}` },
+        400
+      );
+    }
     const supabase = getSupabaseClient();
     let thread;
     let replayed = false;
@@ -10772,7 +11006,8 @@ function createChatRouter(agent = {}) {
       // opening message at display time (see threadCrumbLabel).
       title: isNonEmptyString(input2.title) ? input2.title.trim() : null,
       author: input2.author,
-      client_key: clientKey2
+      client_key: clientKey2,
+      board_status: pickedStatus ?? null
     }).select().single();
     if (threadError) {
       if (!clientKey2 || threadError.code !== "23505") {
@@ -10813,6 +11048,11 @@ function createChatRouter(agent = {}) {
         effort: effortFromRow(reply["effort"])
       });
     }
+    if (!replayed && pickedStatus !== void 0) {
+      void rememberComposerStatus(c, channelId, pickedStatus).catch(
+        (err) => console.error("Remember composer status failed:", err)
+      );
+    }
     if (!replayed && thread["title"] == null) {
       void generateAutoTitle(thread.id, channelId, input2.body).catch(
         (err) => console.error("Auto title failed:", err)
@@ -10820,6 +11060,15 @@ function createChatRouter(agent = {}) {
     }
     return c.json({ ...thread, replies: [reply] }, replayed ? 200 : 201);
   });
+  app.get("/channels/:channelId/composer-status", async (c) => {
+    const channelId = c.req.param("channelId");
+    if (!ownChannelIds(c).has(channelId)) return c.json({ error: "unknown channel" }, 404);
+    const membershipId = await callerMembershipId(c);
+    if (!membershipId) return c.json({ lastStatus: null });
+    const { data: pref, error: error2 } = await getSupabaseClient().from("channel_member_prefs").select("last_board_status").eq("channel_id", channelId).eq("membership_id", membershipId).maybeSingle();
+    if (error2) return c.json({ error: error2.message }, 500);
+    return c.json({ lastStatus: pref?.last_board_status ?? null });
+  });
   app.post("/replies/:replyId/fork", async (c) => {
     const replyId = c.req.param("replyId");
     const input2 = await c.req.json().catch(() => null);
@@ -11035,7 +11284,7 @@ function generateShareId() {
   return randomBytes6(9).toString("base64url");
 }
 async function publishDocShare(input2, readBundle) {
-  const bundle = await readBundle({ cwd: input2.cwd, sourcePath: input2.sourcePath });
+  const bundle = await readBundle({ channelId: input2.channelId, cwd: input2.cwd, sourcePath: input2.sourcePath });
   if (bundle.status !== "ok") return bundle;
   const existing = await findDocShareBySource(input2.workspaceId, input2.channelId, input2.sourcePath);
   const shareId = existing?.id ?? generateShareId();
@@ -11695,7 +11944,7 @@ function createTranscribeRouter() {
 // ../api/src/dashboard/avatars-routes.ts
 import { createHash as createHash9, randomUUID as randomUUID4 } from "crypto";
 import { Hono as Hono19 } from "hono";
-import sharp4 from "sharp";
+import sharp5 from "sharp";
 import { PutObjectCommand as PutObjectCommand4, DeleteObjectCommand as DeleteObjectCommand3 } from "@aws-sdk/client-s3";
 var AVATAR_SIZE = 192;
 var MAX_AVATAR_BYTES = 2 * 1024 * 1024;
@@ -11731,7 +11980,7 @@ async function storeAvatar(file, owner) {
     return { error: "avatar must be a PNG or JPEG image" };
   if (file.size > MAX_AVATAR_BYTES) return { error: "avatar must be 2MB or smaller" };
   const original = Buffer.from(await file.arrayBuffer());
-  const resized = await sharp4(original).resize({ width: AVATAR_SIZE, height: AVATAR_SIZE, fit: "cover" }).png().toBuffer();
+  const resized = await sharp5(original).resize({ width: AVATAR_SIZE, height: AVATAR_SIZE, fit: "cover" }).png().toBuffer();
   const key = `${avatarKeyPrefix()}${owner}-${randomUUID4()}.png`;
   await getR2Client().send(
     new PutObjectCommand4({
@@ -11909,10 +12158,6 @@ function createMembersRouter() {
     if (avatarKey && !avatarKey.startsWith(`${avatarKeyPrefix()}invite-${ctx.userId}-`)) {
       return c.json({ error: "unknown avatar" }, 400);
     }
-    const { plan } = await getWorkspaceBilling(ctx.workspaceId);
-    if (plan === "local") {
-      return c.json({ error: "The Solo plan is for one person. Upgrade to invite members." }, 403);
-    }
     const existing = await getMembershipByEmail(ctx.workspaceId, email);
     if (existing) return c.json({ error: "already a member of this workspace" }, 409);
     let membership;
@@ -13425,8 +13670,95 @@ async function buildThreadUsage(threadTs) {
   }
 }
 
-// ../api/src/dashboard/channel-members-routes.ts
+// ../api/src/dashboard/channel-greeting.ts
 import { Hono as Hono25 } from "hono";
+function eligible(ch) {
+  return !!ch && !ch.isDefault && !ch.dmKey && !ch.agentName && !ch.archivedAt;
+}
+function buildIntroPrompt(ch) {
+  const automations = [
+    ...(ch.automations?.schedules ?? []).map((s) => s.name),
+    ...(ch.automations?.triggers ?? []).map((t) => t.name)
+  ].filter(Boolean);
+  return [
+    `[channel intro request] Write the one-time intro message for the #${ch.name} channel, into this thread. It is the first thing a visitor sees here, so it must be grounded in what this folder actually contains.`,
+    "",
+    "Read-only: inspect the folder (file listing, README.md, AGENTS.md / CLAUDE.md, docs/, git status, .claude/skills and any SKILL.md files), but do not create, modify or delete anything, and do not run anything with side effects.",
+    "",
+    "Language: match how this project is usually worked on, in this order of evidence: (1) the user messages in this folder's recent agent sessions (Claude Code: ~/.claude/projects/<encoded cwd>/*.jsonl; Codex: ~/.codex/sessions/**/*.jsonl with a matching cwd): read only enough to judge the language, never quote them; (2) the main language of README.md / AGENTS.md / docs/; (3) English. For Chinese use Traditional Chinese (Taiwan), full-width punctuation.",
+    "",
+    "Shape (pyramid, at most ~80 Chinese characters / ~60 English words in total):",
+    "1. One sentence: what this channel/project is, and what you can best help with here.",
+    `2. Three one-line bullets: what already exists in the folder (repo, docs); 1-2 skills that are really available and how to invoke them; one concrete automation suggestion with frequency and content (e.g. "every Monday 9am, summarise last week's commits here").`,
+    "3. End with exactly one line `[BUTTONS: a | b | c]` whose three buttons correspond to the three bullets and read as directly executable requests.",
+    "",
+    "Rules: never invent skills or automations that are not actually there: skip that bullet instead. " + (automations.length ? `This channel already has automations (${automations.join(", ")}): introduce the existing one(s) instead of suggesting a new one. ` : "") + "Do not explain Flyspace itself. If the folder is empty, instead ask what this channel will be used for and offer `[BUTTONS: Help me set up this channel]`. Output only the message itself, nothing else."
+  ].join("\n");
+}
+var FALLBACK_BODY = "I could not write this channel's intro automatically. Ask me below and I'll take a look at the folder.\n\n[BUTTONS: Introduce this channel]";
+function introOpening(channelName) {
+  return `Welcome to #${channelName}. I'm reading this project's folder, docs, skills and automations to work out how I can help here. Below you'll find a short intro and a few first steps you can click to try.`;
+}
+function createChannelGreetingRouter(agent) {
+  const app = new Hono25();
+  app.get("/:id/greeting", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    const ch = findChannelById(c.req.param("id"));
+    const pending2 = isWorkspaceOwner(ctx) && eligible(ch) && !ch.greetedAt && (agent.isHostOnline?.(ch.profile) ?? false);
+    if (!pending2) return c.json({ pending: false, threadId: null });
+    const threadId = await ensureIntroThread(ch);
+    return c.json({ pending: !!threadId, threadId });
+  });
+  app.post("/:id/greeting", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    if (!isWorkspaceOwner(ctx)) return c.json({ error: "workspace owner access required" }, 403);
+    const ch = findChannelById(c.req.param("id"));
+    if (!eligible(ch)) return c.json({ error: "channel has no intro" }, 404);
+    const threadId = await ensureIntroThread(ch);
+    if (!threadId) return c.json({ error: "could not create the intro thread" }, 500);
+    if (!await markChannelGreeted(ch.id)) return c.json({ threadId, error: "already greeted" }, 409);
+    try {
+      if (!(agent.isHostOnline?.(ch.profile) ?? false)) throw new Error("host offline");
+      await agent.onChatMessage?.({
+        threadId,
+        // Synthetic: no thread_replies row has this id, so the prompt is
+        // never shown and never counted as thread context.
+        replyId: crypto.randomUUID(),
+        author: ctx.handle,
+        body: buildIntroPrompt(ch)
+      });
+    } catch (err) {
+      console.error(`[channel-greeting] dispatch failed for #${ch.name}:`, err);
+      await getSupabaseClient().from("thread_replies").insert({ thread_id: threadId, author: AGENT_AUTHOR, body: FALLBACK_BODY });
+    }
+    return c.json({ threadId }, 201);
+  });
+  return app;
+}
+async function ensureIntroThread(ch) {
+  const supabase = getSupabaseClient();
+  const existing = () => supabase.from("threads").select("id").eq("client_key", ch.id).maybeSingle();
+  const found = await existing();
+  if (found.data) return found.data.id;
+  const { data, error: error2 } = await supabase.from("threads").insert({
+    channel_id: ch.id,
+    title: `Getting started in #${ch.name}`,
+    author: AGENT_AUTHOR,
+    client_key: ch.id
+  }).select("id").single();
+  if (data) {
+    await supabase.from("thread_replies").insert({
+      thread_id: data.id,
+      author: AGENT_AUTHOR,
+      body: introOpening(ch.name)
+    });
+    return data.id;
+  }
+  return error2?.code === "23505" ? (await existing()).data?.id ?? null : null;
+}
+
+// ../api/src/dashboard/channel-members-routes.ts
+import { Hono as Hono26 } from "hono";
 async function isChannelAdmin(ctx, channelId) {
   if (ctx.role === "admin") return true;
   const membership = await getMembershipByUserId(ctx.workspaceId, ctx.userId);
@@ -13435,7 +13767,7 @@ async function isChannelAdmin(ctx, channelId) {
   return members.some((m) => m.membershipId === membership.id && m.role === "channel_admin");
 }
 function createChannelMembersRouter() {
-  const router = new Hono25();
+  const router = new Hono26();
   router.get("/:id/members", async (c) => {
     const ctx = await resolveAuthContext(c);
     if (!ctx) return c.json({ error: "workspace access required" }, 403);
@@ -13505,7 +13837,7 @@ function createChannelMembersRouter() {
 }
 
 // ../api/src/dashboard/memories-routes.ts
-import { Hono as Hono26 } from "hono";
+import { Hono as Hono27 } from "hono";
 async function readPatch(c) {
   const body = await c.req.json().catch(() => ({}));
   const patch = {};
@@ -13533,7 +13865,7 @@ var requireAgentMemory = async (c, next) => {
   await next();
 };
 function createMemoriesRouter() {
-  const router = new Hono26();
+  const router = new Hono27();
   for (const path of [
     "/:id/memories",
     "/:id/memories/*",
@@ -13606,7 +13938,7 @@ function createMemoriesRouter() {
   return router;
 }
 function createScopedMemoriesRouter() {
-  const router = new Hono26();
+  const router = new Hono27();
   router.use("*", requireAgentMemory);
   const workspace = (c) => ({
     scope: "workspace",
@@ -13665,14 +13997,244 @@ function createScopedMemoriesRouter() {
   return router;
 }
 
+// ../api/src/dashboard/session-import-routes.ts
+import { Hono as Hono28 } from "hono";
+var MAX_FOLDERS2 = 20;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var IMPORT_RANGES = ["all", "7d", "latest5"];
+async function ask(agent, req) {
+  const res = await agent.sessionImportRequest?.(req);
+  return res && res.op === req.op ? res : null;
+}
+function hostUnavailable2(c, agent) {
+  return c.json(
+    {
+      error: "host offline",
+      reason: agent.getHostCallFailure?.("sessionImportRequest") ?? "offline"
+    },
+    503
+  );
+}
+function pickSessions(sessions2, range, now = Date.now()) {
+  if (range === "latest5") return sessions2.slice(0, 5);
+  if (range === "7d") return sessions2.filter((s) => s.lastUsed >= now - 7 * DAY_MS);
+  return sessions2;
+}
+function channelForFolder(folder, channels) {
+  return folder.linkedAs ? channels.find((ch) => ch.name === folder.linkedAs && !ch.archivedAt) : void 0;
+}
+async function importRows(channelIds) {
+  if (!channelIds.length) return [];
+  const { data, error: error2 } = await getSupabaseClient().from("session_imports").select("channel_id, agent, session_id, thread_id, last_message_uuid, message_count").in("channel_id", channelIds);
+  if (error2) throw new Error(error2.message);
+  return data ?? [];
+}
+async function importableFolders(folders, channels) {
+  const mapped = folders.map((f) => ({ folder: f, channel: channelForFolder(f, channels) }));
+  const rows = await importRows(mapped.flatMap((m) => m.channel ? [m.channel.id] : []));
+  const byKey = new Map(rows.map((r) => [rowKey(r.channel_id, r.agent, r.session_id), r]));
+  return mapped.map(({ folder, channel }) => {
+    const sessions2 = folder.sessions.flatMap((s) => {
+      const row = channel ? byKey.get(rowKey(channel.id, s.agent, s.sessionId)) : void 0;
+      return s.bound && !row ? [] : [{ ...s, row }];
+    });
+    return { folder: { ...folder, sessions: sessions2 }, channel };
+  }).filter((m) => m.folder.sessions.length);
+}
+var rowKey = (channelId, agent, sessionId) => `${channelId}:${agent}:${sessionId}`;
+function replyRows(threadId, messages, author, fallbackAt) {
+  return messages.map((m, i) => ({
+    thread_id: threadId,
+    author: m.role === "user" ? author : AGENT_AUTHOR,
+    body: m.text,
+    created_at: m.at ?? new Date(fallbackAt + i).toISOString()
+  }));
+}
+async function syncSession(agent, channelId, session, author, existing) {
+  const supabase = getSupabaseClient();
+  const read = await ask(agent, {
+    op: "read",
+    agent: session.agent,
+    sessionId: session.sessionId,
+    ...existing?.last_message_uuid ? { afterUuid: existing.last_message_uuid } : {}
+  });
+  if (!read) return null;
+  const messages = read.messages ?? [];
+  if (!messages.length) return 0;
+  const last = messages[messages.length - 1];
+  if (existing) {
+    const { error: error3 } = await supabase.from("thread_replies").insert(replyRows(existing.thread_id, messages, author, Date.now()));
+    if (error3) throw new Error(error3.message);
+    await supabase.from("session_imports").update({
+      last_message_uuid: last.uuid,
+      message_count: existing.message_count + messages.length,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("channel_id", channelId).eq("agent", session.agent).eq("session_id", session.sessionId);
+    return messages.length;
+  }
+  const startedAt = messages[0].at ?? (/* @__PURE__ */ new Date()).toISOString();
+  const { data: thread, error: threadError } = await supabase.from("threads").insert({
+    channel_id: channelId,
+    title: null,
+    author,
+    imported_agent: session.agent,
+    created_at: startedAt
+  }).select("id").single();
+  if (threadError || !thread) throw new Error(threadError?.message ?? "could not create thread");
+  const threadId = thread.id;
+  const { error: claimError } = await supabase.from("session_imports").insert({
+    channel_id: channelId,
+    agent: session.agent,
+    session_id: session.sessionId,
+    thread_id: threadId,
+    last_message_uuid: last.uuid,
+    message_count: messages.length
+  });
+  if (claimError) {
+    await supabase.from("threads").delete().eq("id", threadId);
+    if (claimError.code === "23505") return 0;
+    throw new Error(claimError.message);
+  }
+  const { error: error2 } = await supabase.from("thread_replies").insert(replyRows(threadId, messages, author, Date.parse(startedAt)));
+  if (error2) throw new Error(error2.message);
+  await ask(agent, {
+    op: "bind",
+    items: [{ channelId, threadId, agent: session.agent, sessionId: session.sessionId }]
+  });
+  return messages.length;
+}
+function createSessionImportRouter(agent) {
+  const app = new Hono28();
+  const scanFolders = async () => {
+    const scan = await ask(agent, { op: "scan", slug: getProfile() });
+    return scan && importableFolders(scan.folders, getProfileChannelRegistry());
+  };
+  const channelParam = (c) => getProfileChannelRegistry().find((ch) => ch.id === c.req.param("channelId"));
+  app.get("/scan", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    if (ctx?.role !== "admin") return c.json({ error: "admin access required" }, 403);
+    const folders = await scanFolders();
+    if (!folders) return hostUnavailable2(c, agent);
+    return c.json({
+      folders: folders.map(({ folder, channel }) => ({
+        ...folder,
+        channel: channel ? { id: channel.id, name: channel.name } : null,
+        sessions: folder.sessions.map(({ row, bound: _bound, ...s }) => ({
+          ...s,
+          imported: !!row
+        }))
+      }))
+    });
+  });
+  app.post("/import", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    if (ctx?.role !== "admin") return c.json({ error: "admin access required" }, 403);
+    const body = await c.req.json().catch(() => ({}));
+    const picks = (Array.isArray(body.folders) ? body.folders : []).filter((f) => typeof f?.path === "string").map((f) => ({
+      path: f.path,
+      range: IMPORT_RANGES.includes(f.range ?? "") ? f.range : "all"
+    }));
+    if (!picks.length) return c.json({ error: "no folders chosen" }, 400);
+    if (picks.length > MAX_FOLDERS2) return c.json({ error: `at most ${MAX_FOLDERS2} folders` }, 400);
+    const folders = await scanFolders();
+    if (!folders) return hostUnavailable2(c, agent);
+    const offered = new Map(folders.map((m) => [m.folder.path, m]));
+    if (picks.some((p) => !offered.has(p.path)))
+      return c.json({ error: "folder was not offered by the scan" }, 400);
+    const needLink = picks.filter((p) => !offered.get(p.path).channel);
+    if (needLink.length && !isWorkspaceOwner(ctx)) {
+      return c.json({ error: "workspace owner access required to add new folders" }, 403);
+    }
+    const taken = new Set(getProfileChannelRegistry().map((ch) => ch.name));
+    const items = needLink.map((p) => ({
+      name: uniqueChannelName(offered.get(p.path).folder.name, taken),
+      path: p.path
+    }));
+    const linked = items.length ? await agent.linkProjectFolders?.(getProfile(), items) : [];
+    if (!linked) return hostUnavailable2(c, agent);
+    const created = /* @__PURE__ */ new Map();
+    for (const [i, l] of linked.entries())
+      created.set(items[i].path, await createChannel({ name: l.name, cwd: l.cwd }));
+    const results = [];
+    for (const p of picks) {
+      const { folder, channel: existing } = offered.get(p.path);
+      const channel = existing ?? created.get(p.path);
+      let threads = 0;
+      let messages = 0;
+      for (const s of pickSessions(folder.sessions, p.range)) {
+        if (s.row) continue;
+        const n = await syncSession(agent, channel.id, s, ctx.handle, void 0);
+        if (n === null) return hostUnavailable2(c, agent);
+        if (n > 0) threads += 1;
+        messages += n;
+      }
+      results.push({
+        path: p.path,
+        channel: { id: channel.id, name: channel.name },
+        created: !existing,
+        threads,
+        messages
+      });
+    }
+    return c.json({ results }, 201);
+  });
+  app.get("/channels/:channelId", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    if (ctx?.role !== "admin") return c.json({ error: "admin access required" }, 403);
+    const channel = channelParam(c);
+    if (!channel) return c.json({ error: "channel not found" }, 404);
+    const folders = await scanFolders();
+    if (!folders) return hostUnavailable2(c, agent);
+    const folder = folders.find((m) => m.channel?.id === channel.id)?.folder;
+    const sessions2 = [];
+    for (const { row, bound: _bound, ...s } of folder?.sessions ?? []) {
+      let newMessages = 0;
+      if (row) {
+        const read = await ask(agent, {
+          op: "read",
+          agent: s.agent,
+          sessionId: s.sessionId,
+          ...row.last_message_uuid ? { afterUuid: row.last_message_uuid } : {}
+        });
+        newMessages = read?.messages?.length ?? 0;
+      }
+      const status = !row ? "not-imported" : newMessages ? "new" : "synced";
+      sessions2.push({ ...s, threadId: row?.thread_id ?? null, status, newMessages });
+    }
+    return c.json({ folder: folder?.path ?? null, sessions: sessions2 });
+  });
+  app.post("/channels/:channelId/sync", async (c) => {
+    const ctx = await resolveAuthContext(c);
+    if (ctx?.role !== "admin") return c.json({ error: "admin access required" }, 403);
+    const channel = channelParam(c);
+    if (!channel) return c.json({ error: "channel not found" }, 404);
+    const body = await c.req.json().catch(() => ({}));
+    const only = Array.isArray(body.sessionIds) ? new Set(body.sessionIds.filter((s) => typeof s === "string")) : null;
+    const folders = await scanFolders();
+    if (!folders) return hostUnavailable2(c, agent);
+    const folder = folders.find((m) => m.channel?.id === channel.id)?.folder;
+    let threads = 0;
+    let messages = 0;
+    for (const s of folder?.sessions ?? []) {
+      if (only && !only.has(s.sessionId)) continue;
+      const n = await syncSession(agent, channel.id, s, ctx.handle, s.row);
+      if (n === null) return hostUnavailable2(c, agent);
+      if (!s.row && n > 0) threads += 1;
+      messages += n;
+    }
+    return c.json({ threads, messages });
+  });
+  return app;
+}
+
 // ../api/src/dashboard/host-status-signal.ts
 var HOST_STATUS_CHANNEL = "host-status";
 var channelReady = null;
 function getHostStatusChannel() {
-  channelReady ??= new Promise((resolve7) => {
+  channelReady ??= new Promise((resolve8) => {
     const channel = getSupabaseClient().channel(HOST_STATUS_CHANNEL);
     channel.subscribe((state) => {
-      if (state === "SUBSCRIBED") resolve7(channel);
+      if (state === "SUBSCRIBED") resolve8(channel);
     });
   });
   return channelReady;
@@ -13837,6 +14399,8 @@ function registerDataRoutes(api, agent = {}) {
   });
   api.route("/channels", createDocShareWriteRouter(agent));
   api.route("/onboarding", createOnboardingRouter(agent));
+  api.route("/session-import", createSessionImportRouter(agent));
+  api.route("/channels", createChannelGreetingRouter(agent));
   api.route("/channels", createChannelMembersRouter());
   api.route("/channels", createMemoriesRouter());
   api.route("/memories", createScopedMemoriesRouter());
@@ -14080,7 +14644,7 @@ function registerDataRoutes(api, agent = {}) {
       return c.json({ error: "logo must be 2MB or smaller" }, 400);
     }
     const original = Buffer.from(await file.arrayBuffer());
-    const resized = await sharp5(original).resize({ width: LOGO_SIZE, height: LOGO_SIZE, fit: "cover" }).png().toBuffer();
+    const resized = await sharp6(original).resize({ width: LOGO_SIZE, height: LOGO_SIZE, fit: "cover" }).png().toBuffer();
     const logo = `data:image/png;base64,${resized.toString("base64")}`;
     return c.json(await saveWorkspaceBranding({ logo }));
   });
@@ -14090,7 +14654,7 @@ function registerDataRoutes(api, agent = {}) {
 // ../api/src/dashboard/device-auth-routes.ts
 import { verify } from "crypto";
 import { getConnInfo } from "@hono/node-server/conninfo";
-import { Hono as Hono27 } from "hono";
+import { Hono as Hono29 } from "hono";
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function cleanText(value, max) {
   if (typeof value !== "string") return null;
@@ -14138,7 +14702,7 @@ async function boundWorkspaceIds(publicKey, userId) {
   return new Set(existing ? (await listDeviceWorkspaces(existing)).map((w) => w.id) : []);
 }
 function createDeviceAuthRouter() {
-  const app = new Hono27();
+  const app = new Hono29();
   app.post("/code", async (c) => {
     const body = await readBody(c);
     const publicKey = typeof body["public_key"] === "string" ? body["public_key"] : "";
@@ -14457,7 +15021,7 @@ var workspaceRef = () => ({ kind: "workspace" });
 var channelRef = (c) => ({ kind: "channel", channelId: c.req.param("id") });
 
 // ../api/src/dashboard/output-styles-routes.ts
-import { Hono as Hono28 } from "hono";
+import { Hono as Hono30 } from "hono";
 function requireAdmin3(auth) {
   return auth?.role === "admin" ? null : "admin access required";
 }
@@ -14477,7 +15041,7 @@ function failure(c, err) {
   return c.json({ error: message }, err instanceof OutputStyleConflictError ? 409 : 500);
 }
 function createOutputStylesRouter() {
-  const app = new Hono28();
+  const app = new Hono30();
   app.get("/", (c) => {
     const auth = c.get("auth");
     const denied = requireAdmin3(auth);
@@ -14569,7 +15133,7 @@ function createOutputStylesRouter() {
   return app;
 }
 async function handleOutputStylesRequest(req) {
-  const app = new Hono28();
+  const app = new Hono30();
   app.use("*", async (c, next) => {
     c.set("auth", { role: "admin" });
     await next();
@@ -14590,7 +15154,7 @@ import { streamSSE } from "hono/streaming";
 
 // ../api/src/dashboard/api.ts
 function createGatedRouter(agent, register) {
-  const api = new Hono29();
+  const api = new Hono31();
   api.use("*", async (c, next) => {
     const known = await listKnownWorkspaces();
     const fromHost = profileFromHost(trustedHost(c), known);
@@ -14639,11 +15203,11 @@ function createGatedRouter(agent, register) {
 
 // src/dashboard/host-api.ts
 import { existsSync as existsSync30, readFileSync as readFileSync24, statSync as statSync8 } from "fs";
-import sharp6 from "sharp";
+import sharp7 from "sharp";
 
 // src/dashboard/channels-routes.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync10 } from "fs";
-import { Hono as Hono30 } from "hono";
+import { Hono as Hono32 } from "hono";
 function coerceAccess(raw) {
   if (raw === "open" || raw === "*" || raw === "all") return raw;
   if (Array.isArray(raw) && raw.every((v) => typeof v === "string")) return raw;
@@ -14706,7 +15270,7 @@ function toResponse3(channel) {
   };
 }
 function createChannelWriteRouter() {
-  const app = new Hono30();
+  const app = new Hono32();
   app.post("/", async (c) => {
     const body = await c.req.json().catch(() => ({}));
     const name = typeof body["name"] === "string" ? body["name"].trim() : "";
@@ -14846,7 +15410,7 @@ import {
 } from "fs";
 import { Readable } from "stream";
 import { basename as basename8, dirname as dirname8, extname, join as join23, relative, resolve as resolve5, sep } from "path";
-import { Hono as Hono31 } from "hono";
+import { Hono as Hono33 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 
 // src/dashboard/docs-watcher.ts
@@ -15148,7 +15712,7 @@ function needsRefresh(expiresAt, now = Date.now()) {
   if (!expiresAt) return false;
   return new Date(expiresAt).getTime() - now < REFRESH_SKEW_MS;
 }
-var sleep3 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep3 = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 async function refreshConnection(params) {
   const { workspaceId, connection, provider } = params;
   const deps = params.deps ?? {};
@@ -15482,7 +16046,7 @@ ${req.user}`,
   };
 }
 function run3(inv, cwd) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn4(inv.command, inv.args, {
       cwd,
       env: inv.env,
@@ -15496,14 +16060,14 @@ function run3(inv, cwd) {
     child.on("error", (err) => {
       clearTimeout(timer2);
       console.error(`[memory-extraction] ${inv.command} failed to start:`, err.message);
-      resolve7({ ok: false });
+      resolve8({ ok: false });
     });
     child.on("close", (code) => {
       clearTimeout(timer2);
       if (code !== 0) {
         const detail = (stderr || stdout).trim().split("\n").at(-1) ?? "";
         console.error(`[memory-extraction] ${inv.command} exited ${code}: ${detail.slice(0, 200)}`);
-        resolve7({ ok: false });
+        resolve8({ ok: false });
         return;
       }
       let raw = stdout;
@@ -15514,7 +16078,7 @@ function run3(inv, cwd) {
           raw = "";
         }
       }
-      resolve7({ ok: true, raw });
+      resolve8({ ok: true, raw });
     });
     child.stdin.end(inv.stdin);
   });
@@ -15576,7 +16140,7 @@ Rules:
 - No preamble like "Summary:" \u2014 start directly with the summary text.`;
 var HAIKU_TIMEOUT_MS = 6e4;
 function runHaikuPrint(input2, claudeConfigDir, claudeCodeOauthToken) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const args = [
       "--print",
       "--model",
@@ -15627,7 +16191,7 @@ function runHaikuPrint(input2, claudeConfigDir, claudeCodeOauthToken) {
         reject(new Error("claude -p --model haiku returned empty output"));
         return;
       }
-      resolve7(text);
+      resolve8(text);
     });
   });
 }
@@ -16023,6 +16587,15 @@ var ChatAgent = class {
    * restart picks up edits. */
   workspaceRoots = null;
   /** Fire-and-forget entry point, called by chat-routes after every write. */
+  /** The CLI of the session already bound to this thread, if any. */
+  boundRunner(channelId, threadId) {
+    const store = this.openSessionStore();
+    try {
+      return store.getSession(`chat:${channelId}`, threadId)?.runner;
+    } finally {
+      store.close();
+    }
+  }
   handleMessage(msg) {
     if (msg.author === AGENT_AUTHOR) return;
     this.seenReplies.add(msg.replyId);
@@ -16403,7 +16976,7 @@ var ChatAgent = class {
     );
     ensureLogicalCwdDir(baseConfig.cwd);
     const pickedModel = msg.model?.trim();
-    let activeRunner = pickedModel ? runnerForModel(pickedModel) : defaultRunner;
+    let activeRunner = pickedModel ? runnerForModel(pickedModel) : this.boundRunner(thread.channel_id, msg.threadId) ?? defaultRunner;
     let channelConfig = pickedModel ? {
       ...baseConfig,
       ...activeRunner === "codex" ? { model: pickedModel, codexModel: pickedModel } : { model: pickedModel }
@@ -16709,22 +17282,22 @@ ${msg.body}` : msg.body;
     let ready;
     try {
       channel = this.supabase().channel(`agent-thinking:${threadId}`);
-      ready = new Promise((resolve7) => {
+      ready = new Promise((resolve8) => {
         const timeout = setTimeout(() => {
           console.error(`[chat-agent] thinking-channel ${threadId}: subscribe timed out after 10s`);
-          resolve7(false);
+          resolve8(false);
         }, 1e4);
         channel.subscribe((status, err) => {
           if (status === "SUBSCRIBED") {
             clearTimeout(timeout);
-            resolve7(true);
+            resolve8(true);
           } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
             console.error(
               `[chat-agent] thinking-channel ${threadId}: ${status}`,
               err?.message ?? ""
             );
             clearTimeout(timeout);
-            resolve7(false);
+            resolve8(false);
           }
         });
       });
@@ -16771,19 +17344,19 @@ ${msg.body}` : msg.body;
     let ready;
     try {
       channel = this.supabase().channel("channel-activity");
-      ready = new Promise((resolve7) => {
+      ready = new Promise((resolve8) => {
         const timeout = setTimeout(() => {
           console.error("[chat-agent] channel-activity: subscribe timed out after 10s");
-          resolve7(false);
+          resolve8(false);
         }, 1e4);
         channel.subscribe((status, err) => {
           if (status === "SUBSCRIBED") {
             clearTimeout(timeout);
-            resolve7(true);
+            resolve8(true);
           } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
             console.error(`[chat-agent] channel-activity: ${status}`, err?.message ?? "");
             clearTimeout(timeout);
-            resolve7(false);
+            resolve8(false);
           }
         });
       });
@@ -17727,7 +18300,7 @@ function deleteDocEntry(root, path) {
   };
 }
 function createDocsRouter({ gate = requireDocsAccess } = {}) {
-  const app = new Hono31();
+  const app = new Hono33();
   app.use("/:id/docs", gate);
   app.use("/:id/docs/*", gate);
   app.get("/:id/docs", (c) => {
@@ -18065,7 +18638,7 @@ function withDocLinkBridge(html) {
 // src/dashboard/skills-routes-host.ts
 import { existsSync as existsSync27, statSync as statSync7 } from "fs";
 import { dirname as dirname9 } from "path";
-import { Hono as Hono32 } from "hono";
+import { Hono as Hono34 } from "hono";
 function workspaceScope() {
   const claudeConfigDir = profileClaudeConfigDir();
   const cwd = defaultClaudeCwd();
@@ -18171,12 +18744,12 @@ var diskBackend = {
   write: writeSkillAndSync
 };
 function createWorkspaceSkillsRouter() {
-  const app = new Hono32();
+  const app = new Hono34();
   mountSkillRoutes(app, "/skills", workspaceRef, diskBackend);
   return app;
 }
 function createChannelSkillsRouter() {
-  const app = new Hono32();
+  const app = new Hono34();
   mountSkillRoutes(app, "/:id/skill-files", channelRef, diskBackend);
   return app;
 }
@@ -18311,7 +18884,7 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { chmodSync, existsSync as existsSync29, mkdirSync as mkdirSync12, readFileSync as readFileSync23, writeFileSync as writeFileSync12 } from "fs";
 import { createRequire } from "module";
 import { dirname as dirname10, join as join25 } from "path";
-import { Hono as Hono33 } from "hono";
+import { Hono as Hono35 } from "hono";
 var SESSION_TTL_MS = 10 * 6e4;
 var URL_WAIT_MS = 3e4;
 var TOKEN_WAIT_MS = 6e4;
@@ -18360,13 +18933,13 @@ function track(session) {
   return [id, s];
 }
 function waitFor(s, parse, ms) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const started = Date.now();
     const tick = setInterval(() => {
       const v = parse();
       if (v !== void 0 || s.status !== "pending" || Date.now() - started > ms) {
         clearInterval(tick);
-        resolve7(v);
+        resolve8(v);
       }
     }, 200);
   });
@@ -18468,7 +19041,7 @@ function failure2(c, err) {
   return c.json({ error: err.message }, 500);
 }
 function createProviderLoginRouter() {
-  const app = new Hono33();
+  const app = new Hono35();
   app.use("*", async (c, next) => {
     const denied = requireAdmin4(c.get("auth"));
     if (denied) return c.json({ error: denied }, 403);
@@ -18512,7 +19085,7 @@ function createProviderLoginRouter() {
   return app;
 }
 async function handleProviderLoginRequest(req) {
-  const app = new Hono33();
+  const app = new Hono35();
   app.use("*", async (c, next) => {
     c.set("auth", { role: "admin" });
     await next();
@@ -18620,7 +19193,7 @@ function registerHostRoutes(api) {
       return c.json({ error: "avatar must be 2MB or smaller" }, 400);
     }
     const original = Buffer.from(await file.arrayBuffer());
-    const resized = await sharp6(original).resize({ width: LOGO_SIZE, height: LOGO_SIZE, fit: "cover" }).png().toBuffer();
+    const resized = await sharp7(original).resize({ width: LOGO_SIZE, height: LOGO_SIZE, fit: "cover" }).png().toBuffer();
     const avatar = `data:image/png;base64,${resized.toString("base64")}`;
     const name = c.req.param("name");
     if (name === BOT_PROFILE_KEY) return c.json(await saveBotIdentity({ avatar }));
@@ -18664,18 +19237,253 @@ function createHostApiRouter(agent = {}) {
 
 // src/dashboard/agent-bridge-host.ts
 import { sign as signRaw, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
 import dotenv2 from "dotenv";
 import { WebSocket as WebSocket2 } from "ws";
 
+// src/dashboard/session-import-host.ts
+import {
+  closeSync as closeSync3,
+  existsSync as existsSync31,
+  openSync as openSync3,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync25,
+  readSync as readSync3,
+  realpathSync as realpathSync5
+} from "fs";
+import { basename as basename9, join as join26, resolve as resolve7 } from "path";
+var MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var HEAD_BYTES = 64 * 1024;
+var TITLE_MAX = 80;
+function readHead2(file) {
+  let fd;
+  try {
+    fd = openSync3(file, "r");
+    const buf = Buffer.alloc(HEAD_BYTES);
+    return buf.toString("utf-8", 0, readSync3(fd, buf, 0, buf.length, 0));
+  } catch {
+    return "";
+  } finally {
+    if (fd !== void 0) closeSync3(fd);
+  }
+}
+function parseLines(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function cleanText2(text) {
+  const t = text.trim();
+  if (!t || t.startsWith("<")) return null;
+  return t;
+}
+function blocksText(content, kinds) {
+  if (typeof content === "string") return cleanText2(content);
+  if (!Array.isArray(content)) return null;
+  const parts = content.filter(
+    (b) => kinds.includes(b?.type) && typeof b.text === "string"
+  ).map((b) => b.text);
+  return parts.length ? cleanText2(parts.join("\n\n")) : null;
+}
+function boundSessionIds() {
+  if (!existsSync31(paths.DB_FILE)) return /* @__PURE__ */ new Set();
+  const store = new SessionStore(paths.DB_FILE);
+  try {
+    return new Set(store.listSessions().map((s) => s.sessionId));
+  } finally {
+    store.close();
+  }
+}
+function claudeMessages(lines) {
+  const out = [];
+  for (const o of lines) {
+    if (o["type"] !== "user" && o["type"] !== "assistant" || o["isMeta"] || o["isSidechain"])
+      continue;
+    if (o["entrypoint"] === "sdk-cli") continue;
+    const role = o["type"];
+    const text = blocksText(o["message"]?.content, ["text"]);
+    if (!text || typeof o["uuid"] !== "string") continue;
+    const at = typeof o["timestamp"] === "string" ? o["timestamp"] : null;
+    const last = out[out.length - 1];
+    if (role === "assistant" && last?.role === "assistant") {
+      last.text += `
+
+${text}`;
+      last.uuid = o["uuid"];
+    } else {
+      out.push({ uuid: o["uuid"], role, text, at });
+    }
+  }
+  return out;
+}
+function codexMessages(lines) {
+  const out = [];
+  lines.forEach((o, i) => {
+    const p = o["payload"];
+    if (o["type"] !== "response_item" || p?.type !== "message") return;
+    if (p.role !== "user" && p.role !== "assistant") return;
+    const text = blocksText(p.content, ["input_text", "output_text"]);
+    if (!text) return;
+    out.push({
+      uuid: `line:${i}`,
+      role: p.role,
+      text,
+      at: typeof o["timestamp"] === "string" ? o["timestamp"] : null
+    });
+  });
+  return out;
+}
+function claudeSummary(file, mtime) {
+  const head = parseLines(readHead2(file));
+  if (head.some((o) => o["entrypoint"] === "sdk-cli")) return null;
+  const first = claudeMessages(head).find((m) => m.role === "user");
+  if (!first) return null;
+  return {
+    agent: "claude",
+    sessionId: basename9(file, ".jsonl"),
+    title: first.text.slice(0, TITLE_MAX),
+    lastUsed: mtime
+  };
+}
+function codexSummary(file, mtime) {
+  const head = parseLines(readHead2(file));
+  const meta = head.find((o) => o["type"] === "session_meta")?.["payload"];
+  if (!meta?.id || !meta.cwd || meta.originator === "codex_exec") return null;
+  const first = codexMessages(head).find((m) => m.role === "user");
+  if (!first) return null;
+  return {
+    cwd: meta.cwd,
+    session: {
+      agent: "codex",
+      sessionId: meta.id,
+      title: first.text.slice(0, TITLE_MAX),
+      lastUsed: mtime
+    }
+  };
+}
+function enabledAgents() {
+  return new Set(
+    detectRunners().filter((r) => r.installed && r.loggedIn).map((r) => r.id)
+  );
+}
+function scanSessionFolders(slug) {
+  const agents = enabledAgents();
+  const bound = boundSessionIds();
+  const since2 = Date.now() - MAX_AGE_MS;
+  const byPath = /* @__PURE__ */ new Map();
+  const add = (cwd, s) => {
+    const path = resolve7(cwd);
+    if (isExcluded(path)) return;
+    byPath.set(path, [
+      ...byPath.get(path) ?? [],
+      bound.has(s.sessionId) ? { ...s, bound: true } : s
+    ]);
+  };
+  if (agents.has("claude")) {
+    const root = join26(claudeDir(), "projects");
+    let dirs = [];
+    try {
+      dirs = readdirSync6(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+    }
+    for (const dir of dirs) {
+      const files = jsonlFiles(join26(root, dir), 0).filter((f) => f.mtime >= since2);
+      let cwd = null;
+      for (const f of files) {
+        cwd ??= cwdFromTranscript(f.file);
+        if (cwd) break;
+      }
+      if (!cwd) continue;
+      for (const f of files) {
+        const s = claudeSummary(f.file, f.mtime);
+        if (s) add(cwd, s);
+      }
+    }
+  }
+  if (agents.has("codex")) {
+    for (const f of jsonlFiles(join26(codexDir(), "sessions"), 4)) {
+      if (f.mtime < since2) continue;
+      const s = codexSummary(f.file, f.mtime);
+      if (s) add(s.cwd, s.session);
+    }
+  }
+  const linked = linkedTargets(slug);
+  const folders = [...byPath].map(([path, sessions2]) => {
+    let real = path;
+    try {
+      real = realpathSync5(path);
+    } catch {
+    }
+    sessions2.sort((a, b) => b.lastUsed - a.lastUsed);
+    return {
+      path,
+      name: basename9(path),
+      lastUsed: sessions2[0].lastUsed,
+      sessions: sessions2,
+      ...linked.has(real) ? { linkedAs: linked.get(real) } : {}
+    };
+  });
+  return folders.sort((a, b) => b.lastUsed - a.lastUsed);
+}
+function findTranscript(agent, sessionId) {
+  if (!/^[A-Za-z0-9-]+$/.test(sessionId)) return null;
+  if (agent === "claude") {
+    const root = join26(claudeDir(), "projects");
+    try {
+      for (const e of readdirSync6(root, { withFileTypes: true })) {
+        const file = join26(root, e.name, `${sessionId}.jsonl`);
+        if (e.isDirectory() && existsSync31(file)) return file;
+      }
+    } catch {
+    }
+    return null;
+  }
+  return jsonlFiles(join26(codexDir(), "sessions"), 4).find((f) => f.file.endsWith(`${sessionId}.jsonl`))?.file ?? null;
+}
+function readSessionMessages(agent, sessionId, afterUuid) {
+  const file = findTranscript(agent, sessionId);
+  if (!file) return null;
+  const lines = parseLines(readFileSync25(file, "utf-8"));
+  const messages = agent === "claude" ? claudeMessages(lines) : codexMessages(lines);
+  if (!afterUuid) return messages;
+  const idx = messages.findIndex((m) => m.uuid === afterUuid);
+  return idx === -1 ? [] : messages.slice(idx + 1);
+}
+function bindSessions(items) {
+  const store = new SessionStore(paths.DB_FILE);
+  try {
+    for (const i of items)
+      store.saveSession(`chat:${i.channelId}`, i.threadId, i.sessionId, i.agent);
+  } finally {
+    store.close();
+  }
+  return items.length;
+}
+function handleSessionImportRequest(req) {
+  switch (req.op) {
+    case "scan":
+      return { op: "scan", folders: scanSessionFolders(req.slug) };
+    case "read":
+      return { op: "read", messages: readSessionMessages(req.agent, req.sessionId, req.afterUuid) };
+    case "bind":
+      return { op: "bind", bound: bindSessions(req.items) };
+  }
+}
+
 // src/dashboard/docs-relay-host.ts
-import { Hono as Hono34 } from "hono";
+import { Hono as Hono36 } from "hono";
 var RETURNED_HEADERS = ["content-type", "content-disposition", "content-security-policy", "cache-control"];
 async function handleDocsRequest(req) {
   return runRelayed(req, (app) => app.route("/channels", createDocsRouter({ gate: async (_c, next) => next() })));
 }
 async function runRelayed(req, register) {
-  const app = new Hono34();
+  const app = new Hono36();
   app.use("*", async (c, next) => {
     c.set("auth", req.auth);
     await next();
@@ -18698,7 +19506,7 @@ async function handleHostRequest(req) {
 }
 
 // src/dashboard/doc-share-publisher.ts
-import { readFileSync as readFileSync25, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync26, statSync as statSync9 } from "fs";
 import { extname as extname2, posix } from "path";
 var MAX_ASSET_BYTES = 20 * 1024 * 1024;
 var MAX_CONTENT_BYTES2 = 2 * 1024 * 1024;
@@ -18813,7 +19621,7 @@ function readDocShareBundle({ cwd, sourcePath }) {
   }
   if (!stat.isFile()) return { status: "not-found" };
   if (stat.size > MAX_CONTENT_BYTES2) return { status: "too-large" };
-  const source = readFileSync25(abs, "utf8");
+  const source = readFileSync26(abs, "utf8");
   const title = extractTitle(abs, kind === "markdown" ? "md" : kind);
   if (kind === "excalidraw") {
     try {
@@ -18884,7 +19692,7 @@ function readDocShareBundle({ cwd, sourcePath }) {
       let text = null;
       try {
         const size = statSync9(docAbs).size;
-        if (size <= budget) text = readFileSync25(docAbs, "utf8");
+        if (size <= budget) text = readFileSync26(docAbs, "utf8");
       } catch {
         continue;
       }
@@ -18901,7 +19709,7 @@ function readDocShareBundle({ cwd, sourcePath }) {
     let body;
     try {
       if (statSync9(resolved2.abs).size > MAX_ASSET_BYTES) continue;
-      body = readFileSync25(resolved2.abs);
+      body = readFileSync26(resolved2.abs);
     } catch {
       continue;
     }
@@ -18929,13 +19737,13 @@ function readDocShareBundle({ cwd, sourcePath }) {
 
 // src/dashboard/host-upgrade.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync13, openSync as openSync3 } from "fs";
-import { join as join26 } from "path";
+import { mkdirSync as mkdirSync13, openSync as openSync4 } from "fs";
+import { join as join27 } from "path";
 var running = false;
 function startHostUpgrade() {
   if (running) return { started: false };
   mkdirSync13(paths.LOG_DIR, { recursive: true });
-  const log5 = openSync3(join26(paths.LOG_DIR, "host-upgrade.log"), "a");
+  const log5 = openSync4(join27(paths.LOG_DIR, "host-upgrade.log"), "a");
   const child = spawn7(process.execPath, [process.argv[1] ?? "", "upgrade"], {
     detached: true,
     stdio: ["ignore", log5, log5]
@@ -18956,7 +19764,7 @@ function dataSocketUrl() {
   return `ws://127.0.0.1:${process.env["FLYSPACE_DATA_API_PORT"] ?? DEFAULT_DATA_API_PORT}${HOST_SOCKET_PATH}`;
 }
 function listLocalSessions() {
-  if (!existsSync31(paths.DB_FILE)) return [];
+  if (!existsSync32(paths.DB_FILE)) return [];
   const store = new SessionStore(paths.DB_FILE);
   try {
     return store.listSessions();
@@ -18976,9 +19784,12 @@ function localAgentCallbacks(chatAgent) {
     listMissingCwds: () => auditChannelCwds().map((ch) => ch.id),
     listRunningProfiles: () => listProfiles().filter(isServiceRunning2),
     getAgentIdentities: () => resolveAgentIdentities(),
-    readDocShareBundle: (req) => readDocShareBundle(req),
-    listChannelSkills: (args) => listSkills(args.claudeConfigDir, args.cwd),
-    listFlatDocs: (args) => flatDocs(args.cwd, { query: args.query, sort: args.sort, showHidden: args.showHidden }),
+    readDocShareBundle: (req) => readDocShareBundle(req.channelId ? { ...req, cwd: resolveChannelConfig(req.channelId).cwd } : req),
+    listChannelSkills: (args) => {
+      const { cwd, claudeConfigDir } = args.channelId ? resolveChannelConfig(args.channelId) : args;
+      return listSkills(claudeConfigDir, cwd);
+    },
+    listFlatDocs: (args) => flatDocs(args.channelId ? resolveChannelConfig(args.channelId).cwd : args.cwd, { query: args.query, sort: args.sort, showHidden: args.showHidden }),
     getLocalDashboardSettings: () => loadDashboardSettings(),
     saveLocalDashboardSettings: (patch) => saveDashboardSettings(patch),
     writeSkill: (ref, write) => writeSkillAndSync(ref, write),
@@ -18990,6 +19801,7 @@ function localAgentCallbacks(chatAgent) {
     upgradeHost: () => startHostUpgrade(),
     scanOnboarding: (slug) => scanOnboarding(slug),
     linkProjectFolders: (slug, items) => linkProjectFolders(slug, items),
+    sessionImportRequest: (req) => handleSessionImportRequest(req),
     isHostOnline: () => true
   };
 }
@@ -18998,7 +19810,7 @@ function buildHostConfigSnapshot() {
   const snapshot2 = {};
   for (const profile of listProfiles()) {
     snapshot2[profile] = runWithProfile(profile, () => ({
-      env: existsSync31(paths.CONFIG_FILE) ? dotenv2.parse(readFileSync26(paths.CONFIG_FILE, "utf-8")) : {},
+      env: existsSync32(paths.CONFIG_FILE) ? dotenv2.parse(readFileSync27(paths.CONFIG_FILE, "utf-8")) : {},
       agentModel: loadDashboardSettings().agent
     }));
   }
@@ -19248,12 +20060,12 @@ function startPushWatcher() {
 }
 
 // src/dashboard/machine-server.ts
-import { existsSync as existsSync32 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { join as join28 } from "path";
 import { serveStatic } from "@hono/node-server/serve-static";
 
 // src/dashboard/app-icon-routes.ts
-import { Hono as Hono35 } from "hono";
+import { Hono as Hono37 } from "hono";
 var NEUTRAL_MANIFEST = {
   id: "/",
   name: "Flyspace",
@@ -19291,7 +20103,7 @@ async function withResolvedProfile2(c, next) {
   return profile ? runWithProfile(profile, () => next()) : next();
 }
 function createAppIconRouter() {
-  const app = new Hono35();
+  const app = new Hono37();
   app.get("/manifest.json", withResolvedProfile2, async (c) => {
     if (!await resolvedProfileHost(c)) return c.json(NEUTRAL_MANIFEST);
     const profile = getProfile();
@@ -19331,7 +20143,7 @@ function pngResponse(c, png) {
 }
 
 // src/dashboard/machine-server.ts
-var WEB_DIST = join27(paths.WEB_ROOT, "dist");
+var WEB_DIST = join28(paths.WEB_ROOT, "dist");
 async function bootMachine() {
   await reconcileAll().catch(
     (err) => console.error("[dashboard] reconcileAll failed:", err.message)
@@ -19351,14 +20163,14 @@ async function bootMachine() {
 function mountSpa(app) {
   app.route("/share", createPublicShareAssetRouter(WEB_DIST));
   app.route("/", createAppIconRouter());
-  if (existsSync32(WEB_DIST) || existsSync32(join27(paths.WEB_ROOT, "package.json"))) {
+  if (existsSync33(WEB_DIST) || existsSync33(join28(paths.WEB_ROOT, "package.json"))) {
     app.use("/*", serveStatic({ root: WEB_DIST }));
   }
   app.get("/assets/*", (c) => c.text("stale asset \u2014 reload for the current build", 404));
-  const spaFallback = serveStatic({ path: join27(WEB_DIST, "index.html") });
+  const spaFallback = serveStatic({ path: join28(WEB_DIST, "index.html") });
   app.get("*", async (c, next) => {
-    if (!existsSync32(join27(WEB_DIST, "index.html"))) {
-      const isCheckout = existsSync32(join27(paths.WEB_ROOT, "package.json"));
+    if (!existsSync33(join28(WEB_DIST, "index.html"))) {
+      const isCheckout = existsSync33(join28(paths.WEB_ROOT, "package.json"));
       return c.text(
         isCheckout ? `Workspace UI build missing (${WEB_DIST}).
 Run \`pnpm build:web\` from the repo root.
@@ -19492,8 +20304,8 @@ function openBrowser2(url) {
   }
 }
 function ensureWebBuild() {
-  if (existsSync33(join28(paths.WEB_ROOT, "dist", "index.html"))) return;
-  if (!existsSync33(join28(paths.WEB_ROOT, "package.json"))) return;
+  if (existsSync34(join29(paths.WEB_ROOT, "dist", "index.html"))) return;
+  if (!existsSync34(join29(paths.WEB_ROOT, "package.json"))) return;
   console.log("  packages/ui/dist missing, building the dashboard UI...");
   const result = spawnSync("pnpm", ["build"], {
     cwd: paths.WEB_ROOT,
@@ -19543,7 +20355,7 @@ async function runDashboard(args) {
 }
 
 // src/commands/workspace.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
 var USAGE7 = `
   Usage: flyspace workspace <subcommand> [options]
 
@@ -19629,7 +20441,7 @@ function provisionLocal(botName) {
   ensureDirs();
   console.log(`  config dir ready (${paths.CONFIG_DIR})`);
   console.log(`  data dir ready (${paths.DATA_DIR})`);
-  if (existsSync34(paths.CONFIG_FILE)) {
+  if (existsSync35(paths.CONFIG_FILE)) {
     console.log("  config.env exists");
   } else {
     writeFileSync13(paths.CONFIG_FILE, `BOT_NAME=${botName}
@@ -19646,7 +20458,7 @@ async function provisionChannels(specs) {
       continue;
     }
     const cwd = expandPath(spec.cwd);
-    if (!existsSync34(cwd)) {
+    if (!existsSync35(cwd)) {
       mkdirSync14(cwd, { recursive: true });
       console.log(`  created cwd ${cwd}`);
     }
@@ -19724,10 +20536,10 @@ async function runReconcileCmd(args) {
 }
 
 // src/cli.ts
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var home = flyspaceHome();
 if (home) {
-  const bin = join29(home, "bin");
+  const bin = join30(home, "bin");
   const path = process.env.PATH ?? "";
   if (!path.split(":").includes(bin)) process.env.PATH = path ? `${bin}:${path}` : bin;
 }
@@ -19865,7 +20677,7 @@ async function main() {
       break;
     case "-v":
     case "--version":
-      printRaw("0.1.32");
+      printRaw("0.1.34");
       break;
     case "-h":
     case "--help":