@linzumi/cli 0.0.77-beta → 0.0.78-beta

package/dist/index.js

@@ -9772,7 +9772,8 @@ function linzumiMcpServerConfig(options) {
       ...options.cwd === void 0 ? [] : ["--cwd", options.cwd],
       ...options.threadId === void 0 ? [] : ["--thread-id", options.threadId],
       "--mode",
-      options.operatingMode ?? "text"
+      options.operatingMode ?? "text",
+      ...options.toolScope === void 0 || options.toolScope === "all" ? [] : ["--tool-scope", options.toolScope]
     ],
     env: {
       ...options.accessToken === void 0 ? {} : { LINZUMI_MCP_ACCESS_TOKEN: options.accessToken }
@@ -10725,6 +10726,9 @@ async function validateLocalRunnerToken(args) {
   if (args.channelSlug !== void 0) {
     url.searchParams.set("channel", args.channelSlug);
   }
+  for (const scope of args.requiredScopes ?? []) {
+    url.searchParams.append("required_scope", scope);
+  }
   const response = await fetch(url, {
     method: "GET",
     headers: { authorization: `Bearer ${args.accessToken}` }
@@ -13577,7 +13581,7 @@ async function resolveEditorRuntime(options) {
     fetchImpl: options.fetchImpl ?? fetch
   });
   if (!manifest.ok) {
-    return unavailable("manifest_unavailable");
+    return unavailable(manifest.reason);
   }
   const cacheRoot = options.cacheRoot ?? defaultEditorRuntimeCacheRoot();
   const installed = installedRuntime(cacheRoot, manifest.manifest);
@@ -13669,17 +13673,24 @@ async function fetchApprovedManifest(args) {
     headers: { authorization: `Bearer ${args.token}` }
   }).catch(() => void 0);
   if (response === void 0) {
-    return { ok: false };
+    return { ok: false, reason: "manifest_unavailable" };
   }
   if (response.status !== 200) {
-    return { ok: false };
+    return {
+      ok: false,
+      reason: response.status === 401 ? await unauthorizedManifestReason(response) : "manifest_unavailable"
+    };
   }
   const body = await response.json();
   if (!isJsonObject(body) || body.ok !== true || !isJsonObject(body.runtime)) {
-    return { ok: false };
+    return { ok: false, reason: "manifest_unavailable" };
   }
   return normalizeManifest(body.runtime);
 }
+async function unauthorizedManifestReason(response) {
+  const body = await response.json().catch(() => void 0);
+  return isJsonObject(body) && body.error === "token_expired" ? "auth_expired" : "auth_unauthorized";
+}
 function normalizeManifest(value) {
   const version = nonEmptyString(value.version);
   const platform = nonEmptyString(value.platform);
@@ -13690,7 +13701,7 @@ function normalizeManifest(value) {
   const manifestPath = nonEmptyString(value.manifestPath) ?? "linzumi-editor-runtime.json";
   const assets = normalizeRuntimeAssets(value.assets);
   if (version === void 0 || platform === void 0 || archiveUrl === void 0 || archiveSha256 === void 0 || codeServerVersion === void 0 || assets === void 0) {
-    return { ok: false };
+    return { ok: false, reason: "manifest_unavailable" };
   }
   return {
     ok: true,
@@ -14264,6 +14275,20 @@ function assertRunnerConnectionDependencies(status) {
     );
   }
   if (status.editorRuntime?.status === "unavailable" || status.codeServer?.available === false && status.codeServer.reason !== "not_configured") {
+    if (status.editorRuntime?.status === "unavailable") {
+      switch (status.editorRuntime.reason) {
+        case "auth_expired":
+          throw new Error(
+            "Linzumi authentication expired. Sign in again, then reconnect the local runner."
+          );
+        case "auth_unauthorized":
+          throw new Error(
+            "Linzumi authentication was rejected. Sign in again, then reconnect the local runner."
+          );
+        default:
+          break;
+      }
+    }
     throw new Error(
       "The Linzumi editor runtime is not available. Reconnect when the runtime update finishes or pass --code-server-bin <path> for a custom development runtime."
     );
@@ -14632,7 +14657,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.77-beta";
+    linzumiCliVersion = "0.0.78-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -14938,6 +14963,39 @@ function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
   state.lastUpdateAtMs = nowMs;
   const previousJobKey = latestDashboardJob(state)?.key;
   switch (event) {
+    case "onboarding.discovery_agents_started":
+      state.browserUrl = stringValue4(payload.kandanUrl);
+      state.workspace = stringValue4(payload.workspace);
+      state.runnerId = stringValue4(payload.runnerId);
+      break;
+    case "onboarding.discovery_status": {
+      const phase = stringValue4(payload.phase);
+      const status = stringValue4(payload.status);
+      const metadata = objectValue5(payload.metadata);
+      const workerId = stringValue4(metadata?.worker_id);
+      if (phase !== void 0 && status !== void 0) {
+        const isConversationPhase = phase === "conversations";
+        const key = isConversationPhase ? phase : workerId ?? phase;
+        const previous = state.discovery.get(key);
+        const mergedMetadata = isConversationPhase ? mergeConversationImportMetadata(previous?.metadata, metadata) : metadata;
+        state.discovery.set(key, {
+          key,
+          phase,
+          status: isConversationPhase ? conversationDiscoveryMergedStatus(previous, status, metadata) : status,
+          placesSearched: Math.max(
+            previous?.placesSearched ?? 0,
+            numberValue(payload.places_searched) ?? 0
+          ),
+          message: stringValue4(payload.message) ?? (isConversationPhase ? previous?.message : void 0),
+          currentPlace: stringValue4(payload.current_place) ?? (isConversationPhase ? previous?.currentPlace : void 0),
+          currentSource: stringValue4(payload.current_source) ?? (isConversationPhase ? previous?.currentSource : void 0),
+          lastError: stringValue4(payload.last_error),
+          metadata: mergedMetadata,
+          updatedAtMs: nowMs
+        });
+      }
+      break;
+    }
     case "kandan.message_queued":
     case "codex.turn_starting": {
       const job = dashboardJobForPayload(state, payload, nowMs);
@@ -15006,12 +15064,15 @@ function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
   rememberRawLine(state, event, payload, previousJobKey);
 }
 function renderRunnerConsoleDashboard(state, nowMs) {
-  if (state.jobs.size === 0 && state.tokenUsage === void 0 && state.rateLimit === void 0 && state.creditExhaustion === void 0) {
+  if (state.jobs.size === 0 && state.discovery.size === 0 && state.tokenUsage === void 0 && state.rateLimit === void 0 && state.creditExhaustion === void 0) {
     return void 0;
   }
   const jobs = dashboardJobs(state);
   switch (state.mode.type) {
     case "table":
+      if (state.jobs.size === 0 && state.discovery.size > 0) {
+        return renderSignupDiscoveryWelcome(state, nowMs);
+      }
       return renderDashboardTable(state, jobs, nowMs);
     case "raw_all":
       return renderRawDashboard(
@@ -15037,9 +15098,195 @@ function renderRunnerConsoleDashboard(state, nowMs) {
     }
   }
 }
+function renderSignupDiscoveryWelcome(state, nowMs) {
+  const statuses = Array.from(state.discovery.values()).sort(
+    (left, right) => discoveryPhaseSortKey(left.phase).localeCompare(
+      discoveryPhaseSortKey(right.phase)
+    )
+  );
+  const placesSearched = statuses.reduce(
+    (total, status) => total + status.placesSearched,
+    0
+  );
+  const stillSearching = statuses.some(
+    (status) => ["starting", "running"].includes(status.status)
+  );
+  const statusRows = statuses.length === 0 ? ["Discovery      starting   0 places  Waiting for discovery agents"] : statuses.map(
+    (status) => [
+      discoveryPhaseLabel(status.phase).padEnd(14),
+      discoveryStatusLabel(status.status).padEnd(10),
+      `${String(status.placesSearched)} places`.padEnd(10),
+      discoveryStatusDetail(status)
+    ].join("  ")
+  );
+  return [
+    runnerWelcomeHeader(),
+    "",
+    "Linzumi setup",
+    "New computer connected",
+    "",
+    `Continue in the browser: ${state.browserUrl ?? "open the Linzumi setup page"}`,
+    "",
+    discoverySummaryText(statuses),
+    `Workspace: ${state.workspace ?? "?"}`,
+    `Runner: ${state.runnerId ?? "?"}`,
+    `Status: ${stillSearching ? "searching" : "finished"}  Places searched: ${placesSearched}`,
+    `Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    "",
+    "Phase          Status      Places     Detail",
+    "-------------  ----------  ---------  ------------------------------",
+    ...statusRows,
+    ""
+  ].join("\n");
+}
+function discoveryPhaseSortKey(phase) {
+  switch (phase) {
+    case "projects":
+      return "1-projects";
+    case "conversations":
+      return "2-conversations";
+    default:
+      return `3-${phase}`;
+  }
+}
+function discoveryPhaseLabel(phase) {
+  switch (phase) {
+    case "projects":
+      return "Projects";
+    case "conversations":
+      return "Conversations";
+    default:
+      return "Discovery";
+  }
+}
+function discoveryStatusLabel(status) {
+  switch (status) {
+    case "starting":
+      return "starting";
+    case "running":
+      return "searching";
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    default:
+      return status;
+  }
+}
+function discoverySummaryText(statuses) {
+  if (statuses.length === 0) {
+    return "I'm waiting for the discovery agents to start.";
+  }
+  const stillSearching = statuses.some(
+    (status) => ["starting", "running"].includes(status.status)
+  );
+  return stillSearching ? "I'm scouting existing projects and coding-agent conversations." : "Discovery is finished and idle. Select a project in the browser or move on.";
+}
+function discoveryStatusDetail(status) {
+  if (status.lastError !== void 0) {
+    return status.lastError;
+  }
+  const importProgress = conversationImportProgressText(status);
+  if (importProgress !== void 0) {
+    return importProgress;
+  }
+  const source = discoverySourceLabel(status.currentSource);
+  if (status.currentPlace !== void 0) {
+    return source === void 0 ? status.currentPlace : `${source}: ${status.currentPlace}`;
+  }
+  return status.message ?? discoveryDefaultMessage(status.phase);
+}
+function conversationImportProgressText(status) {
+  if (status.phase !== "conversations") {
+    return void 0;
+  }
+  if (!conversationImportMetadata(status.metadata)) {
+    return void 0;
+  }
+  const totalCount = numberValue(status.metadata?.total_count) ?? (numberValue(status.metadata?.codex_count) ?? 0) + (numberValue(status.metadata?.claude_code_count) ?? 0);
+  const reportedCount = numberValue(status.metadata?.imported_count) ?? numberValue(status.metadata?.reported_count);
+  if (reportedCount === void 0 || totalCount <= 0) {
+    return void 0;
+  }
+  const label = status.status === "completed" ? "Imported" : "Importing";
+  return `${label} [${conversationImportProgressBar(
+    reportedCount,
+    totalCount
+  )}] ${reportedCount} / ${totalCount} Codex/Claude Code conversations`;
+}
+function conversationImportMetadata(metadata) {
+  return stringValue4(metadata?.worker_id) === "conversations-local-import" || numberValue(metadata?.imported_count) !== void 0 || numberValue(metadata?.failed_import_count) !== void 0 || numberValue(metadata?.total_count) !== void 0;
+}
+function conversationImportProgressBar(reportedCount, totalCount) {
+  const width = 10;
+  const filled = Math.min(
+    width,
+    Math.max(0, Math.floor(reportedCount / totalCount * width))
+  );
+  return `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
+}
+function mergeConversationImportMetadata(previous, next) {
+  if (previous === void 0) {
+    return next;
+  }
+  if (next === void 0) {
+    return previous;
+  }
+  return {
+    ...previous,
+    ...next,
+    ...maxOptionalMetadataNumber(previous, next, "codex_count"),
+    ...maxOptionalMetadataNumber(previous, next, "claude_code_count"),
+    ...maxOptionalMetadataNumber(previous, next, "reported_count"),
+    ...maxOptionalMetadataNumber(previous, next, "imported_count"),
+    ...maxOptionalMetadataNumber(previous, next, "total_count")
+  };
+}
+function maxOptionalMetadataNumber(previous, next, key) {
+  const previousValue = numberValue(previous[key]);
+  const nextValue = numberValue(next[key]);
+  if (previousValue === void 0 && nextValue === void 0) {
+    return {};
+  }
+  return {
+    [key]: Math.max(previousValue ?? 0, nextValue ?? 0)
+  };
+}
+function conversationDiscoveryMergedStatus(previous, nextStatus, nextMetadata) {
+  if (previous?.status === "running" && conversationImportMetadata(previous.metadata) && !conversationImportMetadata(nextMetadata)) {
+    return previous.status;
+  }
+  return nextStatus;
+}
+function discoverySourceLabel(source) {
+  switch (source) {
+    case "git":
+      return "Git";
+    case "codex":
+      return "Codex";
+    case "claude_code":
+      return "Claude Code";
+    case void 0:
+      return void 0;
+    default:
+      return source;
+  }
+}
+function discoveryDefaultMessage(phase) {
+  switch (phase) {
+    case "projects":
+      return "Checking common project folders and Git worktrees.";
+    case "conversations":
+      return "Checking Codex and Claude Code sessions.";
+    default:
+      return "Checking local context.";
+  }
+}
 function renderDashboardTable(state, jobs, nowMs) {
   const model = dashboardTableModel(state, jobs, nowMs);
   return [
+    runnerWelcomeHeader(),
+    "",
     "Linzumi Commander",
     "",
     `Jobs: ${jobs.length}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
@@ -15052,6 +15299,9 @@ function renderDashboardTable(state, jobs, nowMs) {
     ""
   ].join("\n");
 }
+function runnerWelcomeHeader() {
+  return runnerWelcomeHeaderLines.join("\n");
+}
 function creditExhaustionBanner(summary) {
   if (summary === void 0) {
     return [];
@@ -15060,7 +15310,12 @@ function creditExhaustionBanner(summary) {
 }
 function dashboardTableModel(state, jobs, nowMs) {
   const selectedJobKey = selectedDashboardJobKey(state, jobs);
-  const rows = jobs.length === 0 ? [dashboardTableHeader(), emptyJobRow()] : [
+  const activeImportRows = activeConversationImportRows(state, nowMs);
+  const rows = jobs.length > 0 && activeImportRows.length > 0 ? [
+    dashboardTableHeader(),
+    ...activeImportRows,
+    ...jobs.map((job) => jobRow(job, selectedJobKey, nowMs))
+  ] : jobs.length === 0 && state.discovery.size > 0 ? discoveryTableRows(state, nowMs) : jobs.length === 0 ? [dashboardTableHeader(), emptyJobRow()] : [
     dashboardTableHeader(),
     ...jobs.map((job) => jobRow(job, selectedJobKey, nowMs))
   ];
@@ -15070,6 +15325,91 @@ function dashboardTableModel(state, jobs, nowMs) {
     rows
   };
 }
+function activeConversationImportRows(state, nowMs) {
+  return Array.from(state.discovery.values()).filter(activeConversationImportStatus).sort((left, right) => right.updatedAtMs - left.updatedAtMs).map((status) => [
+    "",
+    discoveryPhaseLabel(status.phase),
+    discoveryStatusLabel(status.status),
+    discoveryStatusCurrentSearch(status),
+    String(status.placesSearched),
+    discoveryStatusDetail(status),
+    timeAgo(status.updatedAtMs, nowMs),
+    discoveryStatusEventLabel(status),
+    "onboarding.discovery"
+  ]);
+}
+function activeConversationImportStatus(status) {
+  return ["starting", "running"].includes(status.status) && conversationImportProgressText(status) !== void 0;
+}
+function discoveryTableRows(state, nowMs) {
+  const statuses = Array.from(state.discovery.values()).sort(
+    (left, right) => discoveryPhaseSortKey(left.phase).localeCompare(
+      discoveryPhaseSortKey(right.phase)
+    )
+  );
+  return [
+    [
+      "",
+      "Onboarding scout",
+      "Status",
+      "Current search",
+      "Checked",
+      "Detail",
+      "Ago",
+      "Latest event",
+      "Event type"
+    ],
+    ...statuses.length === 0 ? [
+      [
+        "",
+        "Discovery",
+        "starting",
+        "Waiting for agents",
+        "0",
+        "Waiting for Commander discovery agents",
+        "?",
+        "onboarding",
+        "discovery"
+      ]
+    ] : statuses.map((status) => [
+      "",
+      discoveryPhaseLabel(status.phase),
+      discoveryStatusLabel(status.status),
+      discoveryStatusCurrentSearch(status),
+      String(status.placesSearched),
+      discoveryStatusDetail(status),
+      timeAgo(status.updatedAtMs, nowMs),
+      discoveryStatusEventLabel(status),
+      "onboarding.discovery"
+    ])
+  ];
+}
+function discoveryStatusEventLabel(status) {
+  if (["starting", "running"].includes(status.status) && conversationImportProgressText(status) !== void 0) {
+    return "importing";
+  }
+  switch (status.status) {
+    case "completed":
+      return "idle";
+    case "failed":
+      return "stopped";
+    default:
+      return "scouting";
+  }
+}
+function discoveryStatusCurrentSearch(status) {
+  if (status.lastError !== void 0) {
+    return "stopped";
+  }
+  switch (status.status) {
+    case "completed":
+      return "finished";
+    case "failed":
+      return "stopped";
+    default:
+      return status.currentPlace ?? status.message ?? discoveryDefaultMessage(status.phase);
+  }
+}
 function dashboardTableHeader() {
   return [
     "",
@@ -15114,6 +15454,10 @@ function formatRunnerConsoleEvent(event, payload) {
       return ignoredMessage(payload);
     case "kandan.message_queued":
       return `Incoming message from ${sender(payload)}: queued seq=${text(payload.seq)} depth=${text(payload.queue_depth)}`;
+    case "onboarding.discovery_status":
+      return onboardingDiscoveryStatusLine(payload);
+    case "onboarding.discovery_initial_search_completed":
+      return onboardingDiscoveryInitialSearchCompletedLine(payload);
     case "kandan.chat_event_failed":
       return `Incoming message handling failed: seq=${text(payload.seq)} reason=${text(payload.message)}`;
     case "kandan.reconnected":
@@ -15153,6 +15497,20 @@ function formatRunnerConsoleEvent(event, payload) {
       return void 0;
   }
 }
+function onboardingDiscoveryStatusLine(payload) {
+  const phase = discoveryPhaseLabel(stringValue4(payload.phase) ?? "discovery");
+  const status = discoveryStatusLabel(stringValue4(payload.status) ?? "unknown");
+  const placesSearched = numberValue(payload.places_searched) ?? 0;
+  const currentPlace = stringValue4(payload.current_place);
+  const message = stringValue4(payload.message);
+  const detail = stringValue4(payload.last_error) ?? currentPlace ?? message ?? "Checking local context";
+  return `Onboarding discovery: ${phase} ${status} checked=${placesSearched} current=${detail}`;
+}
+function onboardingDiscoveryInitialSearchCompletedLine(payload) {
+  const durationMs = numberValue(payload.duration_ms) ?? 0;
+  const seconds = (durationMs / 1e3).toFixed(1);
+  return `Onboarding discovery initial search completed in ${durationMs}ms (${seconds}s) workspace=${text(payload.workspace)} runner=${text(payload.runnerId)}`;
+}
 function connectedRunnerMessage(payload) {
   return [
     "Connected to Linzumi",
@@ -15440,11 +15798,11 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
     top: 0,
     left: 0,
     width: "100%",
-    height: 6,
+    height: 1,
     tags: false
   });
   const tableElement = blessed.listtable({
-    top: 6,
+    top: 1,
     left: 0,
     width: "100%",
     bottom: 1,
@@ -15566,7 +15924,15 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
       switch (state.mode.type) {
         case "table": {
           const model = dashboardTableModel(state, dashboardJobs(state), nowMs);
-          header.setContent(tuiHeaderContent(state, model.jobs.length, nowMs));
+          const headerLayout = runnerConsoleTuiHeaderLayout(
+            state,
+            model.jobs.length,
+            nowMs,
+            tuiScreenHeight(screen)
+          );
+          header.height = headerLayout.height;
+          tableElement.top = headerLayout.height;
+          header.setContent(headerLayout.content);
           header.show();
           tableElement.setData(model.rows);
           tableElement.show();
@@ -15617,6 +15983,9 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
   }
   return { render, destroy };
 }
+function tuiScreenHeight(screen) {
+  return typeof screen.height === "number" ? screen.height : 24;
+}
 function syncTuiTableSelection(tableElement, model) {
   const selectedIndex = model.jobs.findIndex(
     (job) => job.key === model.selectedJobKey
@@ -15624,8 +15993,46 @@ function syncTuiTableSelection(tableElement, model) {
   const tableIndex = selectedIndex < 0 ? 1 : selectedIndex + 1;
   tableElement.select(tableIndex);
 }
-function tuiHeaderContent(state, jobCount, nowMs) {
+function runnerConsoleTuiHeaderLayout(state, jobCount, nowMs, terminalRows) {
+  const fullContent = tuiHeaderContent(
+    state,
+    jobCount,
+    nowMs,
+    runnerWelcomeHeader()
+  );
+  const fullHeight = tuiHeaderHeight(fullContent);
+  if (terminalRows - fullHeight >= minimumVisibleTuiTableRows) {
+    return { content: fullContent, height: fullHeight };
+  }
+  const compactContent = tuiHeaderContent(
+    state,
+    jobCount,
+    nowMs,
+    runnerWelcomeCompactHeader()
+  );
+  return {
+    content: compactContent,
+    height: tuiHeaderHeight(compactContent)
+  };
+}
+function tuiHeaderHeight(content) {
+  return content.split("\n").length + 1;
+}
+function tuiHeaderContent(state, jobCount, nowMs, welcomeHeader) {
+  if (jobCount === 0 && state.discovery.size > 0) {
+    return [
+      welcomeHeader,
+      "",
+      "Linzumi Commander",
+      discoveryHeaderStatus(state),
+      `Workspace: ${state.workspace ?? "?"}  Runner: ${state.runnerId ?? "?"}`,
+      `Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+      "Controls: r raw stream | esc/back table | mouse wheel scroll"
+    ].join("\n");
+  }
   return [
+    welcomeHeader,
+    "",
     "Linzumi Commander",
     `Jobs: ${jobCount}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
     ...creditExhaustionBanner(state.creditExhaustion),
@@ -15634,6 +16041,20 @@ function tuiHeaderContent(state, jobCount, nowMs) {
     "Controls: click row/enter raw job | r raw stream | esc/back table | mouse wheel scroll"
   ].join("\n");
 }
+function runnerWelcomeCompactHeader() {
+  return runnerWelcomeCompactHeaderLines.join("\n");
+}
+function discoveryHeaderStatus(state) {
+  const statuses = Array.from(state.discovery.values());
+  const placesSearched = statuses.reduce(
+    (total, status) => total + status.placesSearched,
+    0
+  );
+  const stillSearching = statuses.some(
+    (status) => ["starting", "running"].includes(status.status)
+  );
+  return `Onboarding discovery: ${stillSearching ? "searching" : "finished/idle"}  Places searched: ${placesSearched}`;
+}
 function updateRunnerConsoleDashboardMode(state, key) {
   switch (key) {
     case "r":
@@ -15887,12 +16308,13 @@ function stringValue4(value) {
 function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-var dashboardState, maxRawLines, escapeKey, ctrlCKey, enterKey, upKey, downKey, dashboardTableColumns, redrawScreen, keyboardState, tickerState, tuiState;
+var dashboardState, maxRawLines, escapeKey, ctrlCKey, enterKey, upKey, downKey, dashboardTableColumns, runnerWelcomeHeaderLines, runnerWelcomeCompactHeaderLines, minimumVisibleTuiTableRows, redrawScreen, keyboardState, tickerState, tuiState;
 var init_runnerConsoleReporter = __esm({
   "src/runnerConsoleReporter.ts"() {
     "use strict";
     dashboardState = {
       jobs: /* @__PURE__ */ new Map(),
+      discovery: /* @__PURE__ */ new Map(),
       rawLines: [],
       nextJobOrdinal: 0,
       mode: { type: "table" },
@@ -15900,7 +16322,10 @@ var init_runnerConsoleReporter = __esm({
       tokenUsage: void 0,
       rateLimit: void 0,
       creditExhaustion: void 0,
-      lastUpdateAtMs: void 0
+      lastUpdateAtMs: void 0,
+      browserUrl: void 0,
+      workspace: void 0,
+      runnerId: void 0
     };
     maxRawLines = 500;
     escapeKey = "\x1B";
@@ -15919,6 +16344,37 @@ var init_runnerConsoleReporter = __esm({
       { width: 12 },
       { width: 24 }
     ];
+    runnerWelcomeHeaderLines = [
+      "\u2593\u2593\u2557     \u2593\u2593\u2557\u2593\u2593\u2593\u2557   \u2593\u2593\u2557\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2557\u2593\u2593\u2557   \u2593\u2593\u2557\u2593\u2593\u2593\u2557   \u2593\u2593\u2593\u2557\u2593\u2593\u2557",
+      "\u2593\u2593\u2551     \u2593\u2593\u2551\u2593\u2593\u2593\u2593\u2557  \u2593\u2593\u2551\u255A\u2550\u2550\u2593\u2593\u2593\u2554\u255D\u2593\u2593\u2551   \u2593\u2593\u2551\u2593\u2593\u2593\u2593\u2557 \u2593\u2593\u2593\u2593\u2551\u2593\u2593\u2551",
+      "\u2593\u2593\u2551     \u2593\u2593\u2551\u2593\u2593\u2554\u2593\u2593\u2557 \u2593\u2593\u2551  \u2593\u2593\u2593\u2554\u255D \u2593\u2593\u2551   \u2593\u2593\u2551\u2593\u2593\u2554\u2593\u2593\u2593\u2593\u2554\u2593\u2593\u2551\u2593\u2593\u2551",
+      "\u2593\u2593\u2551     \u2593\u2593\u2551\u2593\u2593\u2551\u255A\u2593\u2593\u2557\u2593\u2593\u2551 \u2593\u2593\u2593\u2554\u255D  \u2593\u2593\u2551   \u2593\u2593\u2551\u2593\u2593\u2551\u255A\u2593\u2593\u2554\u255D\u2593\u2593\u2551\u2593\u2593\u2551",
+      "\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u255A\u2593\u2593\u2593\u2593\u2551\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2557\u255A\u2593\u2593\u2593\u2593\u2593\u2593\u2554\u255D\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2593\u2593\u2551\u2593\u2593\u2551",
+      "\u255A\u2550\u2550\u2550\u2592\u2592\u2592@@@@@@@@\u2592\u2592\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2592\u2592\u2592@@@@@@@@\u2592\u2592\u255D\u255A\u2550\u255D",
+      " \u2592@@@@@@@@@@@@@@@@\u2592             \u2592@@@@@@@@@@@@@@@@\u2592",
+      "@@@@@@@@@@@@@@@@@@@@@           @@@@@@@@@@@@@@@@@@@@@",
+      "   @@@@@@@@@@@@@@@                 @@@@@@@@@@@@@@@",
+      "          \u2551\u2551                             \u2551\u2551",
+      "          \u2551\u2551                             \u2551\u2551",
+      "          \u2551\u2551        ()-().----.          \u2551\u2551",
+      "          \u2551\u2551         \"/` ___  ;_________\u2551\u2551_.'",
+      "          \u2551\u2551          ` ^^   ^^          \u2551\u2551",
+      "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2568\u2568\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\xB7\xB7\u2500\u2500\u2500\u2500\xB7\xB7\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2568\u2568\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "Welcome to the Linzumi runner.",
+      "Codex is running on this computer and connected to Linzumi.",
+      "Active Codex jobs appear below as they run.",
+      "You can return to the Linzumi app now."
+    ];
+    runnerWelcomeCompactHeaderLines = [
+      "\u2593\u2593\u2557 LINZUMI RUNNER \u2593\u2593\u2557",
+      "\u2551\u2551  ()-().----.  \u2551\u2551",
+      "\u2568\u2568\u2500\u2500 connected to Codex and Linzumi \u2500\u2500\u2568\u2568",
+      "Welcome to the Linzumi runner.",
+      "Codex is running on this computer and connected to Linzumi.",
+      "Active Codex jobs appear below as they run.",
+      "You can return to the Linzumi app now."
+    ];
+    minimumVisibleTuiTableRows = 6;
     redrawScreen = (screen) => {
       process.stdout.write(`\x1B[2J\x1B[H${screen}`);
     };
@@ -15931,18 +16387,1052 @@ var init_runnerConsoleReporter = __esm({
   }
 });
 
-// src/authCache.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+// src/telemetry.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname8, basename as basename5, join as join12 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+function peekFlagValue(args, flags) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    for (const flag of flags) {
+      if (arg.startsWith(`${flag}=`)) {
+        return arg.slice(flag.length + 1);
+      }
+    }
+    const value = args[index + 1];
+    if (flags.includes(arg) && value !== void 0 && !value.startsWith("--")) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function telemetryDisabled(env = process.env) {
+  const optOut = env.LINZUMI_TELEMETRY?.trim().toLowerCase();
+  if (optOut === "0" || optOut === "false") {
+    return true;
+  }
+  return env.NODE_ENV === "test" || env.VITEST !== void 0;
+}
+function telemetryBaseUrl(apiUrl, env = process.env) {
+  const override = env.LINZUMI_TELEMETRY_BASE_URL?.trim();
+  if (override !== void 0 && override !== "") {
+    return override.replace(/\/+$/, "");
+  }
+  if (apiUrl === void 0 || apiUrl.trim() === "") {
+    return defaultLinzumiHttpUrl;
+  }
+  try {
+    return kandanHttpBaseUrl(apiUrl);
+  } catch {
+    return defaultLinzumiHttpUrl;
+  }
+}
+function telemetryInstallIdPath(env = process.env) {
+  return join12(dirname8(localConfigPath(env)), "install-id");
+}
+function ensureTelemetryInstallId(env = process.env) {
+  const path2 = telemetryInstallIdPath(env);
+  try {
+    const existing = readFileSync9(path2, "utf8").trim();
+    if (existing !== "" && existing.length <= 128) {
+      return existing;
+    }
+  } catch {
+  }
+  const installId = randomUUID3();
+  try {
+    mkdirSync8(dirname8(path2), { recursive: true });
+    writeFileSync6(path2, `${installId}
+`, { mode: 384 });
+  } catch {
+  }
+  return installId;
+}
+function buildLifecyclePayload(event, context) {
+  const severity = event.severity ?? "INFO";
+  return {
+    resourceLogs: [
+      {
+        resource: {
+          attributes: otlpAttributes({
+            "service.name": "linzumi-cli",
+            "service.version": linzumiCliVersion,
+            "linzumi.install_id": context.installId,
+            "os.platform": context.platform ?? process.platform,
+            "host.arch": context.arch ?? process.arch
+          })
+        },
+        scopeLogs: [
+          {
+            scope: { name: "linzumi-cli" },
+            logRecords: [
+              {
+                timeUnixNano: context.timeUnixNano ?? `${BigInt(Date.now()) * 1000000n}`,
+                severityNumber: severity === "ERROR" ? 17 : 9,
+                severityText: severity,
+                body: { stringValue: event.name },
+                attributes: otlpAttributes(event.attributes ?? {})
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}
+function otlpAttributes(attributes) {
+  return Object.entries(attributes).map(([key, value]) => ({
+    key,
+    value: otlpAttributeValue(value)
+  }));
+}
+function otlpAttributeValue(value) {
+  switch (typeof value) {
+    case "string":
+      return { stringValue: value };
+    case "boolean":
+      return { boolValue: value };
+    default:
+      return Number.isSafeInteger(value) ? { intValue: `${value}` } : { doubleValue: value };
+  }
+}
+function lifecycleErrorAttributes(error) {
+  const errorClass = error instanceof Error ? error.constructor.name : typeof error;
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const withoutPaths = rawMessage.replace(
+    /(?:[A-Za-z]:)?(?:[\\/][^\s\\/:"']+){2,}/g,
+    (path2) => basename5(path2)
+  );
+  const message = withoutPaths.length > maxErrorMessageLength ? `${withoutPaths.slice(0, maxErrorMessageLength)}\u2026` : withoutPaths;
+  return { error_class: errorClass, error_message: message };
+}
+function postLifecycleEvent(event, opts = {}) {
+  try {
+    const env = opts.env ?? process.env;
+    if (telemetryDisabled(env)) {
+      return Promise.resolve();
+    }
+    const payload = buildLifecyclePayload(event, {
+      installId: ensureTelemetryInstallId(env)
+    });
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    return Promise.resolve().then(
+      () => fetchImpl(
+        `${telemetryBaseUrl(opts.apiUrl, env)}${telemetryEndpointPath}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(payload),
+          // AbortSignal.timeout timers are unref'd by Node, so a pending
+          // telemetry request never keeps a short-lived process alive past
+          // the bounded window and never delays process exit.
+          signal: AbortSignal.timeout(
+            opts.timeoutMs ?? defaultTelemetryTimeoutMs
+          )
+        }
+      )
+    ).then((response) => {
+      void response.arrayBuffer().catch(() => void 0);
+    }).catch(() => void 0);
+  } catch {
+    return Promise.resolve();
+  }
+}
+var telemetryEndpointPath, defaultTelemetryTimeoutMs, maxErrorMessageLength;
+var init_telemetry = __esm({
+  "src/telemetry.ts"() {
+    "use strict";
+    init_localConfig();
+    init_oauth();
+    init_defaultUrls();
+    init_version();
+    telemetryEndpointPath = "/api/v1/observability/logs";
+    defaultTelemetryTimeoutMs = 2e3;
+    maxErrorMessageLength = 200;
+  }
+});
+
+// src/linzumiApiClient.ts
+function createLinzumiMcpApiClient(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const baseUrl = kandanHttpBaseUrl(options.kandanUrl);
+  const apiPrefix = options.authMode === "personal-agent-delegation" ? "/api/v2/personal-agent-mcp" : "/api/v2/local-runner-mcp";
+  const operatingMode = options.operatingMode ?? "text";
+  const request = async (method, path2, params) => {
+    const url = new URL(path2, baseUrl);
+    const paramsWithMode = {
+      ...params,
+      operating_mode: operatingMode
+    };
+    const requestInit = {
+      method,
+      headers: { authorization: `Bearer ${options.accessToken}` }
+    };
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(paramsWithMode)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    } else {
+      requestInit.headers = {
+        ...requestInit.headers,
+        "content-type": "application/json"
+      };
+      requestInit.body = JSON.stringify(paramsWithMode);
+    }
+    const response = await fetchImpl(url, requestInit);
+    const parsed = await response.json();
+    const body = isJsonObject(parsed) ? parsed : void 0;
+    if (body === void 0) {
+      throw new Error(`Linzumi MCP API returned non-object JSON from ${path2}`);
+    }
+    if (response.ok && body.ok === true) {
+      return body;
+    }
+    const error = typeof body.error === "string" ? body.error : `HTTP ${response.status}`;
+    throw new Error(`Linzumi MCP API ${path2} failed: ${error}`);
+  };
+  return {
+    validateAuth: () => request("GET", `${apiPrefix}/validate`, {}),
+    issueOnboardingDiscoveryToken: (params) => request("POST", `${apiPrefix}/onboarding-discovery-token`, params),
+    getMessage: (params) => request("GET", `${apiPrefix}/message`, params),
+    getThread: (params) => request("GET", `${apiPrefix}/thread`, params),
+    getChannel: (params) => request("GET", `${apiPrefix}/channel`, params),
+    getCodingJobMetadata: (params) => request("GET", `${apiPrefix}/coding-job-metadata`, params),
+    renameCodingJob: (params) => request("POST", `${apiPrefix}/coding-job-title`, params),
+    upsertCodingJobPlan: (params) => request("POST", `${apiPrefix}/coding-job-plan`, params),
+    replaceCodingJobPlanSteps: (params) => request("POST", `${apiPrefix}/coding-job-plan/steps`, params),
+    updateCodingJobPlanStep: (params) => request("POST", `${apiPrefix}/coding-job-plan/step`, params),
+    linkCodingJobPullRequest: (params) => request("POST", `${apiPrefix}/coding-job-primary-pr`, params),
+    listVaultSecrets: (params) => request("GET", `${apiPrefix}/vault-secrets`, params),
+    noteProjectDirectory: (params) => request("POST", `${apiPrefix}/discovered-project`, params),
+    noteAgentConversation: (params) => request("POST", `${apiPrefix}/discovered-conversation`, params),
+    noteOnboardingDiscoveryStatus: (params) => request("POST", `${apiPrefix}/discovery-status`, params),
+    sendChannelMessage: (params) => request("POST", `${apiPrefix}/channel-message`, params),
+    prepareMessageUploads: (params) => request("POST", `${apiPrefix}/message-uploads/prepare`, params),
+    attachMessageFiles: (params) => request("POST", `${apiPrefix}/message-files/attach`, params),
+    prepareCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/prepare`, params),
+    renameCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/rename`, params),
+    sendThreadReply: (params) => request("POST", `${apiPrefix}/thread-reply`, params),
+    sendDm: (params) => request("POST", `${apiPrefix}/dm`, params),
+    dmOwner: (params) => request("POST", `${apiPrefix}/dm-owner`, params),
+    getVaultValues: (params) => request("POST", `${apiPrefix}/vault-values`, params)
+  };
+}
+var init_linzumiApiClient = __esm({
+  "src/linzumiApiClient.ts"() {
+    "use strict";
+    init_oauth();
+    init_protocol();
+  }
+});
+
+// src/onboardingConversationDiscovery.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync8,
+  openSync as openSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync10,
+  readSync,
+  statSync
+} from "node:fs";
+import { basename as basename6, join as join13 } from "node:path";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname8, join as join12 } from "node:path";
+function discoverLocalConversations(options = {}) {
+  const startedAtMs = options.nowMs ?? Date.now();
+  const homeDir = options.homeDir ?? homedir9();
+  const env = options.env ?? process.env;
+  const codexRoot = join13(env.CODEX_HOME ?? join13(homeDir, ".codex"), "sessions");
+  const claudeRoot = join13(
+    env.CLAUDE_CONFIG_DIR ?? join13(homeDir, ".claude"),
+    "projects"
+  );
+  const codexStartedAtMs = Date.now();
+  const codexFiles = listJsonlFiles(codexRoot);
+  const codexDurationMs = Date.now() - codexStartedAtMs;
+  const claudeStartedAtMs = Date.now();
+  const claudeFiles = listJsonlFiles(claudeRoot);
+  const claudeDurationMs = Date.now() - claudeStartedAtMs;
+  const claudeTopLevelFiles = claudeFiles.filter(
+    (filePath) => !filePath.replaceAll("\\", "/").includes("/subagents/")
+  );
+  const candidateLimit = normalizeCandidateLimit(options.candidateLimit);
+  const candidateRecords = [
+    ...conversationFileRecords("codex", codexFiles),
+    ...conversationFileRecords("claude_code", claudeTopLevelFiles)
+  ].sort(compareConversationFileRecords).slice(0, candidateLimit);
+  const candidates = candidateRecords.flatMap((record) => {
+    const candidate = candidateFromRecord(record);
+    return candidate === void 0 ? [] : [candidate];
+  });
+  return {
+    candidates,
+    codexCount: codexFiles.length,
+    claudeCodeCount: claudeTopLevelFiles.length,
+    claudeCodeSubagentCount: claudeFiles.length - claudeTopLevelFiles.length,
+    placesSearched: existingPathCount([codexRoot, claudeRoot]),
+    durationMs: Math.max(0, Date.now() - startedAtMs),
+    searchStats: [
+      {
+        place: codexRoot,
+        source: "codex",
+        duration_ms: codexDurationMs,
+        result_count: codexFiles.length
+      },
+      {
+        place: claudeRoot,
+        source: "claude_code",
+        duration_ms: claudeDurationMs,
+        result_count: claudeTopLevelFiles.length,
+        subagent_result_count: claudeFiles.length - claudeTopLevelFiles.length
+      }
+    ]
+  };
+}
+function readLocalConversationImportMessages(candidate) {
+  const lines = jsonLines(candidate.path);
+  switch (candidate.source) {
+    case "codex":
+      return codexImportMessages(lines);
+    case "claude_code":
+      return claudeImportMessages(lines);
+  }
+}
+function normalizeCandidateLimit(value) {
+  if (value === void 0) {
+    return defaultCandidateLimit;
+  }
+  if (Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return defaultCandidateLimit;
+}
+function conversationFileRecords(source, paths) {
+  return paths.flatMap((path2) => {
+    try {
+      return [
+        {
+          source,
+          path: path2,
+          mtimeMs: statSync(path2).mtimeMs
+        }
+      ];
+    } catch (_error) {
+      return [];
+    }
+  });
+}
+function compareConversationFileRecords(left, right) {
+  return right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path);
+}
+function candidateFromRecord(record) {
+  switch (record.source) {
+    case "codex":
+      return codexCandidateFromPath(
+        record.path,
+        new Date(record.mtimeMs).toISOString()
+      );
+    case "claude_code":
+      return claudeCandidateFromPath(
+        record.path,
+        new Date(record.mtimeMs).toISOString()
+      );
+  }
+}
+function listJsonlFiles(root) {
+  if (!existsSync8(root)) {
+    return [];
+  }
+  const walk = (directory) => {
+    let entries;
+    try {
+      entries = readdirSync2(directory, { withFileTypes: true });
+    } catch (_error) {
+      return [];
+    }
+    return entries.flatMap((entry) => {
+      const filePath = join13(directory, entry.name);
+      if (entry.isDirectory()) {
+        return walk(filePath);
+      }
+      return entry.isFile() && entry.name.endsWith(".jsonl") ? [filePath] : [];
+    });
+  };
+  return walk(root);
+}
+function existingPathCount(paths) {
+  return paths.filter((path2) => existsSync8(path2)).length;
+}
+function codexCandidateFromPath(path2, activityAt) {
+  const lines = boundedJsonLines(path2);
+  const sessionMeta = objectValue(
+    lines.find((line) => line.type === "session_meta")?.payload
+  );
+  const sessionId = stringValue(sessionMeta?.id) ?? sessionIdFromFilename(path2);
+  const cwd = stringValue(sessionMeta?.cwd);
+  const firstUserMessage = firstCodexUserMessage(lines);
+  if (firstUserMessage === void 0 && hasInternalCodexDiscoveryPrompt(lines)) {
+    return void 0;
+  }
+  const displayName = cleanConversationTitle(firstUserMessage);
+  if (displayName === void 0) {
+    return void 0;
+  }
+  return {
+    source: "codex",
+    importKey: sessionId ?? path2,
+    path: path2,
+    displayName,
+    activityAt,
+    metadata: compactJsonObject({
+      session_id: sessionId,
+      project_path: cwd,
+      title: displayName,
+      first_user_message: cleanConversationTitle(firstUserMessage),
+      discovery_method: "local_filesystem"
+    })
+  };
+}
+function claudeCandidateFromPath(path2, activityAt) {
+  const lines = boundedJsonLines(path2);
+  const sessionId = lines.map((line) => stringValue(line.sessionId)).find(Boolean) ?? basename6(path2, ".jsonl");
+  const cwd = lines.map((line) => stringValue(line.cwd)).find(Boolean);
+  const aiTitle = lines.map((line) => stringValue(line.aiTitle)).find(Boolean);
+  const firstUserMessage = firstClaudeUserMessage(lines);
+  const displayName = cleanConversationTitle(aiTitle) ?? cleanConversationTitle(firstUserMessage);
+  if (displayName === void 0) {
+    return void 0;
+  }
+  return {
+    source: "claude_code",
+    importKey: sessionId,
+    path: path2,
+    displayName,
+    activityAt,
+    metadata: compactJsonObject({
+      session_id: sessionId,
+      project_path: cwd,
+      title: displayName,
+      first_user_message: cleanConversationTitle(firstUserMessage),
+      discovery_method: "local_filesystem"
+    })
+  };
+}
+function boundedJsonLines(path2) {
+  return boundedTranscriptText(path2).flatMap((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isJsonObject(parsed) ? [parsed] : [];
+    } catch (_error) {
+      return [];
+    }
+  });
+}
+function jsonLines(path2) {
+  try {
+    return readFileSync10(path2, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return isJsonObject(parsed) ? [parsed] : [];
+      } catch (_error) {
+        return [];
+      }
+    });
+  } catch (_error) {
+    return [];
+  }
+}
+function codexImportMessages(lines) {
+  return lines.flatMap((line, index) => {
+    if (line.type !== "response_item") {
+      return [];
+    }
+    const payload = objectValue(line.payload);
+    const role = importRole(stringValue(payload?.role));
+    const content = payload?.content;
+    const body = importMessageBody(textFromContent(content), role);
+    const attachments = attachmentsFromContent(content);
+    const activityAt = importMessageActivityAt(line, payload);
+    if (body === void 0 && attachments.length === 0) {
+      return [];
+    }
+    return [
+      {
+        itemKey: `codex:${index}`,
+        role,
+        body: body ?? attachmentOnlyBody(role, attachments.length),
+        attachments,
+        activityAt
+      }
+    ];
+  });
+}
+function claudeImportMessages(lines) {
+  return lines.flatMap((line, index) => {
+    const message = objectValue(line.message);
+    const role = importRole(
+      stringValue(message?.role) ?? stringValue(line.type)
+    );
+    const content = message?.content ?? line.content;
+    const body = importMessageBody(textFromContent(content), role);
+    const attachments = attachmentsFromContent(content);
+    const activityAt = importMessageActivityAt(line, message);
+    if (body === void 0 && attachments.length === 0) {
+      return [];
+    }
+    return [
+      {
+        itemKey: `claude:${index}`,
+        role,
+        body: body ?? attachmentOnlyBody(role, attachments.length),
+        attachments,
+        activityAt
+      }
+    ];
+  });
+}
+function importMessageActivityAt(line, payload) {
+  return [
+    stringValue(line.timestamp),
+    stringValue(payload?.timestamp),
+    stringValue(line.created_at),
+    stringValue(payload?.created_at),
+    stringValue(line.createdAt),
+    stringValue(payload?.createdAt),
+    stringValue(line.updated_at),
+    stringValue(payload?.updated_at)
+  ].find(
+    (candidate) => candidate !== void 0 && !Number.isNaN(Date.parse(candidate))
+  );
+}
+function importRole(value) {
+  switch (value) {
+    case "assistant":
+      return "assistant";
+    case "system":
+      return "system";
+    case "tool":
+    case "tool_result":
+    case "function_call_output":
+      return "tool";
+    default:
+      return "user";
+  }
+}
+function importMessageBody(textParts, _role) {
+  const text2 = textParts.map((part) => part.trim()).filter((part) => !isLowSignalTranscriptMarker(part)).filter((part) => part !== "").join("\n\n").trim();
+  if (text2 === "") {
+    return void 0;
+  }
+  return text2;
+}
+function isLowSignalTranscriptMarker(value) {
+  const collapsed = value.replace(/\s+/gu, " ").trim();
+  return collapsed.startsWith("<turn_aborted>") || collapsed.startsWith("<subagent_notification>") || collapsed.startsWith("<environment_context>") || collapsed.startsWith("# AGENTS.md instructions") || collapsed.startsWith("# Context from my IDE setup") || collapsed.startsWith("# Context from my editor");
+}
+function attachmentOnlyBody(role, attachmentCount) {
+  return `${importRoleLabel(role)} sent ${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"}`;
+}
+function importRoleLabel(role) {
+  switch (role) {
+    case "assistant":
+      return "Assistant";
+    case "system":
+      return "System";
+    case "tool":
+      return "Tool";
+    case "user":
+      return "User";
+  }
+}
+function attachmentsFromContent(value) {
+  return arrayValue(value)?.flatMap((entry, index) => {
+    const item = objectValue(entry);
+    if (item === void 0) {
+      return [];
+    }
+    return attachmentFromObject(item, index);
+  }) ?? [];
+}
+function attachmentFromObject(item, index) {
+  const localPath = stringValue(item.path) ?? stringValue(item.file_path) ?? stringValue(item.filePath);
+  const fileName = stringValue(item.name) ?? stringValue(item.file_name) ?? stringValue(item.filename);
+  const contentType = stringValue(item.mime_type) ?? stringValue(item.media_type) ?? stringValue(item.content_type);
+  if (localPath !== void 0) {
+    return [
+      {
+        kind: "path",
+        path: localPath,
+        fileName,
+        contentType
+      }
+    ];
+  }
+  const source = objectValue(item.source);
+  const dataBase64 = stringValue(item.data) ?? stringValue(source?.data) ?? dataUrlBase64(item);
+  const mediaType = stringValue(source?.media_type) ?? stringValue(item.media_type) ?? stringValue(item.mime_type) ?? stringValue(item.content_type);
+  if (dataBase64 !== void 0 && mediaType !== void 0) {
+    return [
+      {
+        kind: "bytes",
+        dataBase64,
+        fileName: fileName ?? `conversation-attachment-${index + 1}${extensionForContentType(mediaType)}`,
+        contentType: mediaType
+      }
+    ];
+  }
+  return [];
+}
+function dataUrlBase64(item) {
+  const imageUrl = stringValue(item.image_url) ?? stringValue(item.url);
+  if (imageUrl === void 0) {
+    return void 0;
+  }
+  const match = imageUrl.match(/^data:[^;,]+;base64,(.+)$/u);
+  return match?.[1];
+}
+function extensionForContentType(contentType) {
+  switch (contentType) {
+    case "image/jpeg":
+      return ".jpg";
+    case "image/png":
+      return ".png";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    default:
+      return "";
+  }
+}
+function boundedTranscriptText(path2) {
+  let fd;
+  try {
+    const stat2 = statSync(path2);
+    fd = openSync3(path2, "r");
+    const firstBuffer = Buffer.alloc(
+      Math.min(boundedTranscriptBytes, stat2.size)
+    );
+    const firstBytes = readSync(fd, firstBuffer, 0, firstBuffer.length, 0);
+    const firstText = firstBuffer.subarray(0, firstBytes).toString("utf8");
+    if (stat2.size <= boundedTranscriptBytes) {
+      return firstText.split("\n").filter((line) => line.trim() !== "");
+    }
+    const lastBuffer = Buffer.alloc(boundedTranscriptBytes);
+    const lastOffset = Math.max(0, stat2.size - boundedTranscriptBytes);
+    const lastBytes = readSync(
+      fd,
+      lastBuffer,
+      0,
+      lastBuffer.length,
+      lastOffset
+    );
+    const lastText = lastBuffer.subarray(0, lastBytes).toString("utf8");
+    return `${firstText}
+${lastText}`.split("\n").filter((line) => line.trim() !== "");
+  } catch (_error) {
+    return [];
+  } finally {
+    if (fd !== void 0) {
+      closeSync2(fd);
+    }
+  }
+}
+function firstCodexUserMessage(lines) {
+  return lines.filter((line) => line.type === "response_item").map((line) => objectValue(line.payload)).filter((payload) => payload !== void 0).filter((payload) => payload.role === "user").flatMap((payload) => textFromContent(payload.content)).filter((text2) => !isInternalOnboardingDiscoveryPrompt(text2)).map(cleanConversationTitle).find((title) => title !== void 0);
+}
+function hasInternalCodexDiscoveryPrompt(lines) {
+  return lines.filter((line) => line.type === "response_item").map((line) => objectValue(line.payload)).filter((payload) => payload !== void 0).filter((payload) => payload.role === "user").flatMap((payload) => textFromContent(payload.content)).some(isInternalOnboardingDiscoveryPrompt);
+}
+function firstClaudeUserMessage(lines) {
+  return lines.filter((line) => line.type === "user").map((line) => objectValue(line.message)).flatMap((message) => textFromContent(message?.content)).map(cleanConversationTitle).find((title) => title !== void 0);
+}
+function textFromContent(value) {
+  const direct = stringValue(value);
+  if (direct !== void 0) {
+    return [direct];
+  }
+  return arrayValue(value)?.flatMap((entry) => {
+    const item = objectValue(entry);
+    const itemText = stringValue(item?.text);
+    return itemText === void 0 ? [] : [itemText];
+  }) ?? [];
+}
+function cleanConversationTitle(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const withoutKandanHeader = value.replace(
+    /^Kandan message seq=\d+ from [^\n]+:\n\n/u,
+    ""
+  );
+  const withoutUploadBoilerplate = withoutKandanHeader.replace(
+    /\n\nWhen you create files that should be attached back to Linzumi,[\s\S]*$/u,
+    ""
+  );
+  const structuredTaskTitle = structuredPromptTaskTitle(
+    withoutUploadBoilerplate
+  );
+  const collapsed = withoutUploadBoilerplate.replace(/\s+/gu, " ").trim();
+  if (collapsed === "") {
+    return void 0;
+  }
+  if (setupPreambleTitle(collapsed)) {
+    return structuredTaskTitle;
+  }
+  return truncateConversationTitle(collapsed);
+}
+function isInternalOnboardingDiscoveryPrompt(value) {
+  const collapsed = value.replace(/\s+/gu, " ").trim();
+  return collapsed.startsWith(
+    "You are Linzumi onboarding discovery running on the user computer."
+  ) || collapsed.startsWith(
+    "You are Linzumi onboarding conversation discovery running on the user computer."
+  );
+}
+function setupPreambleTitle(value) {
+  return value.startsWith("<environment_context>") || value.startsWith("# Context from my IDE setup") || value.startsWith("# Context from my editor") || value.startsWith("# AGENTS.md instructions") || value.includes("<INSTRUCTIONS>") || value.startsWith(
+    "You are Linzumi onboarding discovery running on the user computer."
+  ) || value.startsWith(
+    "You are Linzumi onboarding conversation discovery running on the user computer."
+  ) || value.startsWith("We need answer user?");
+}
+function structuredPromptTaskTitle(value) {
+  const match = value.match(/(?:^|\n)Task:\s*\n+([^\n]+)/u);
+  const taskLine = match?.[1]?.replace(/\s+/gu, " ").trim();
+  return taskLine === void 0 || taskLine === "" ? void 0 : truncateConversationTitle(taskLine);
+}
+function truncateConversationTitle(value) {
+  return value.length > titleMaxLength ? `${value.slice(0, titleMaxLength - 3)}...` : value;
+}
+function sessionIdFromFilename(path2) {
+  const fileName = basename6(path2, ".jsonl");
+  return fileName === "" ? void 0 : fileName;
+}
+function compactJsonObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => {
+      const entryValue = entry[1];
+      return entryValue !== void 0 && entryValue !== "";
+    })
+  );
+}
+var boundedTranscriptBytes, titleMaxLength, defaultCandidateLimit;
+var init_onboardingConversationDiscovery = __esm({
+  "src/onboardingConversationDiscovery.ts"() {
+    "use strict";
+    init_protocol();
+    init_json();
+    boundedTranscriptBytes = 64 * 1024;
+    titleMaxLength = 140;
+    defaultCandidateLimit = 100;
+  }
+});
+
+// src/onboardingProjectDiscovery.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { homedir as homedir10 } from "node:os";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import { basename as basename7, dirname as dirname9, join as join14 } from "node:path";
+function discoverCurrentGitProject(args) {
+  const startedAtMs = args.nowMs ?? Date.now();
+  const candidates = /* @__PURE__ */ new Map();
+  const searchStats = [];
+  const gitStartedAtMs = Date.now();
+  const topLevel = gitOutput(args.cwd, ["rev-parse", "--show-toplevel"]);
+  const gitDurationMs = Date.now() - gitStartedAtMs;
+  if (topLevel !== void 0) {
+    mergeCandidate(
+      candidates,
+      projectCandidateFromWorktree(topLevel, "local_current_git", topLevel)
+    );
+  }
+  searchStats.push({
+    place: args.cwd,
+    source: "git",
+    duration_ms: gitDurationMs,
+    result_count: topLevel === void 0 ? 0 : 1
+  });
+  const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots(args.cwd);
+  let placesSearched = 1;
+  for (const sourceRoot of sourceRoots) {
+    const sourceRootStartedAtMs = Date.now();
+    const foundInRoot = discoverGitWorktreesInSourceRoot(sourceRoot);
+    for (const worktreePath of foundInRoot) {
+      mergeCandidate(
+        candidates,
+        projectCandidateFromWorktree(
+          worktreePath,
+          "local_source_root",
+          topLevel
+        )
+      );
+    }
+    searchStats.push({
+      place: sourceRoot,
+      source: "git",
+      duration_ms: Date.now() - sourceRootStartedAtMs,
+      result_count: foundInRoot.length
+    });
+    placesSearched += 1;
+  }
+  const discoveredCandidates = Array.from(candidates.values()).sort(
+    compareProjectCandidates
+  );
+  const worktreeCount = discoveredCandidates.reduce((total, candidate) => {
+    const count = candidate.metadata.worktree_count;
+    return typeof count === "number" ? total + count : total;
+  }, 0);
+  if (worktreeCount > 0) {
+    searchStats.push({
+      place: "git worktree list --porcelain",
+      source: "git",
+      duration_ms: 0,
+      result_count: worktreeCount
+    });
+    placesSearched += 1;
+  }
+  return {
+    candidates: discoveredCandidates,
+    placesSearched,
+    durationMs: Math.max(0, Date.now() - startedAtMs),
+    searchStats
+  };
+}
+function projectCandidateFromWorktree(worktreePath, discoveryMethod, currentTopLevel) {
+  const topLevel = gitOutput(worktreePath, ["rev-parse", "--show-toplevel"]);
+  if (topLevel === void 0) {
+    return void 0;
+  }
+  const worktrees = gitWorktrees(topLevel);
+  const canonicalPath = worktrees[0] ?? topLevel;
+  const remoteOrigin = gitOutput(topLevel, [
+    "config",
+    "--get",
+    "remote.origin.url"
+  ]);
+  const branch = gitOutput(topLevel, ["branch", "--show-current"]);
+  const headSha = gitOutput(topLevel, ["rev-parse", "HEAD"]);
+  const lastCommitAt = gitOutput(topLevel, ["log", "-1", "--format=%cI"]);
+  const readmeName = readmeProjectName(canonicalPath);
+  const displayName = readmeName ?? basename7(canonicalPath);
+  const importKey = remoteOrigin ?? canonicalPath;
+  const currentWorktreePath = currentTopLevel === void 0 || currentTopLevel === canonicalPath || !worktrees.includes(currentTopLevel) ? void 0 : currentTopLevel;
+  return {
+    importKey,
+    path: canonicalPath,
+    displayName,
+    activityAt: lastCommitAt,
+    metadata: compactJsonObject2({
+      branch,
+      remote_origin: remoteOrigin,
+      head_sha: headSha,
+      discovery_method: discoveryMethod,
+      canonical_path: canonicalPath,
+      current_worktree_path: currentWorktreePath,
+      worktree_count: worktrees.length === 0 ? void 0 : worktrees.length,
+      worktree_paths: worktrees.length === 0 ? void 0 : worktrees.slice(0, worktreePathSampleLimit),
+      worktree_paths_truncated: worktrees.length > worktreePathSampleLimit ? true : void 0,
+      last_commit_at: lastCommitAt,
+      readme_name: readmeName
+    })
+  };
+}
+function mergeCandidate(candidates, candidate) {
+  if (candidate === void 0) {
+    return;
+  }
+  const existing = candidates.get(candidate.importKey);
+  if (existing === void 0 || shouldReplaceCandidate(existing, candidate)) {
+    candidates.set(candidate.importKey, candidate);
+  }
+}
+function shouldReplaceCandidate(existing, candidate) {
+  const existingMethod = existing.metadata.discovery_method;
+  const candidateMethod = candidate.metadata.discovery_method;
+  if (existingMethod === "local_current_git") {
+    return false;
+  }
+  if (candidateMethod === "local_current_git") {
+    return true;
+  }
+  const existingActivity = Date.parse(existing.activityAt ?? "");
+  const candidateActivity = Date.parse(candidate.activityAt ?? "");
+  if (Number.isNaN(existingActivity)) {
+    return !Number.isNaN(candidateActivity);
+  }
+  if (Number.isNaN(candidateActivity)) {
+    return false;
+  }
+  return candidateActivity > existingActivity;
+}
+function compareProjectCandidates(left, right) {
+  const leftActivity = Date.parse(left.activityAt ?? "");
+  const rightActivity = Date.parse(right.activityAt ?? "");
+  if (!Number.isNaN(leftActivity) && !Number.isNaN(rightActivity)) {
+    return rightActivity - leftActivity;
+  }
+  if (!Number.isNaN(leftActivity)) {
+    return -1;
+  }
+  if (!Number.isNaN(rightActivity)) {
+    return 1;
+  }
+  return left.displayName.localeCompare(right.displayName);
+}
+function discoverGitWorktreesInSourceRoot(sourceRoot) {
+  if (!isDirectory(sourceRoot)) {
+    return [];
+  }
+  try {
+    return readdirSync3(sourceRoot, { withFileTypes: true }).flatMap((entry) => {
+      if (!entry.isDirectory()) {
+        return [];
+      }
+      const candidatePath = join14(sourceRoot, entry.name);
+      return isGitWorktreeRoot(candidatePath) ? [candidatePath] : [];
+    }).sort();
+  } catch (_error) {
+    return [];
+  }
+}
+function isGitWorktreeRoot(path2) {
+  return existsSync9(join14(path2, ".git"));
+}
+function defaultLocalProjectSourceRoots(cwd) {
+  return uniqueStrings2([
+    ...ancestorSourceRoots(cwd),
+    ...homeSourceRoots(),
+    ...externalVolumeSourceRoots()
+  ]).filter(isDirectory);
+}
+function ancestorSourceRoots(cwd) {
+  const sourceRootNames = /* @__PURE__ */ new Set([
+    "code",
+    "src",
+    "projects",
+    "Developer",
+    "workspace",
+    "work"
+  ]);
+  const roots = [];
+  let current = cwd;
+  while (current !== dirname9(current)) {
+    if (sourceRootNames.has(basename7(current))) {
+      roots.push(current);
+    }
+    current = dirname9(current);
+  }
+  return roots;
+}
+function homeSourceRoots() {
+  const home = homedir10();
+  return [
+    "code",
+    "src",
+    "projects",
+    "Developer",
+    "workspace",
+    "work",
+    "Documents",
+    "Desktop"
+  ].map((directoryName) => join14(home, directoryName));
+}
+function externalVolumeSourceRoots() {
+  const volumesRoot = "/Volumes";
+  if (!isDirectory(volumesRoot)) {
+    return [];
+  }
+  try {
+    return readdirSync3(volumesRoot, { withFileTypes: true }).flatMap(
+      (entry) => {
+        if (!entry.isDirectory()) {
+          return [];
+        }
+        const volumePath = join14(volumesRoot, entry.name);
+        return ["code", "src", "projects"].map(
+          (directoryName) => join14(volumePath, directoryName)
+        );
+      }
+    );
+  } catch (_error) {
+    return [];
+  }
+}
+function isDirectory(path2) {
+  try {
+    return statSync2(path2).isDirectory();
+  } catch (_error) {
+    return false;
+  }
+}
+function uniqueStrings2(values) {
+  return Array.from(new Set(values));
+}
+function gitOutput(cwd, args) {
+  const result = spawnSync4("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) {
+    return void 0;
+  }
+  const output = result.stdout.trim();
+  return output === "" ? void 0 : output;
+}
+function gitWorktrees(cwd) {
+  const output = gitOutput(cwd, ["worktree", "list", "--porcelain"]);
+  if (output === void 0) {
+    return [];
+  }
+  return output.split("\n").flatMap(
+    (line) => line.startsWith("worktree ") ? [line.slice("worktree ".length)] : []
+  );
+}
+function readmeProjectName(projectPath) {
+  const readmePath = ["README.md", "README.markdown", "readme.md"].map((fileName) => join14(projectPath, fileName)).find((path2) => existsSync9(path2));
+  if (readmePath === void 0) {
+    return void 0;
+  }
+  try {
+    const heading = readFileSync11(readmePath, "utf8").split("\n").map((line) => line.trim()).find((line) => line.startsWith("# "));
+    const title = heading?.replace(/^#+\s+/u, "").trim();
+    return title === void 0 || title === "" ? void 0 : title;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function compactJsonObject2(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => {
+      const entryValue = entry[1];
+      return entryValue !== void 0 && entryValue !== "";
+    })
+  );
+}
+var worktreePathSampleLimit;
+var init_onboardingProjectDiscovery = __esm({
+  "src/onboardingProjectDiscovery.ts"() {
+    "use strict";
+    worktreePathSampleLimit = 25;
+  }
+});
+
+// src/authCache.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname10, join as join15 } from "node:path";
 function defaultAuthFilePath() {
-  return join12(homedir9(), ".linzumi", "auth.json");
+  return join15(homedir11(), ".linzumi", "auth.json");
 }
 function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePath()) {
-  if (!existsSync8(authFilePath)) {
+  if (!existsSync10(authFilePath)) {
     return void 0;
   }
-  const authFile = parseAuthFile(readFileSync9(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync12(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === void 0 || entry.access_token.trim() === "") {
@@ -15959,12 +17449,12 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
   };
 }
 function readPersonalAgentDelegationToken(authFilePath) {
-  if (!existsSync8(authFilePath)) {
+  if (!existsSync10(authFilePath)) {
     throw new Error(
       `missing personal-agent delegation auth file: ${authFilePath}`
     );
   }
-  const authFile = parseAuthFile(readFileSync9(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync12(authFilePath, "utf8"));
   const entry = authFile.personal_agent_delegation;
   if (entry === void 0 || entry.access_token.trim() === "") {
     throw new Error(
@@ -15982,7 +17472,7 @@ function readPersonalAgentDelegationToken(authFilePath) {
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync8(authFilePath) ? parseAuthFile(readFileSync9(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync10(authFilePath) ? parseAuthFile(readFileSync12(authFilePath, "utf8")) : { version: 1 };
   const kandanBaseUrl = kandanHttpBaseUrl(args.kandanUrl);
   const issuedAt = /* @__PURE__ */ new Date();
   const expiresAt = args.expiresInSeconds === void 0 ? void 0 : new Date(
@@ -16000,8 +17490,8 @@ function writeCachedLocalRunnerToken(args) {
       }
     }
   };
-  mkdirSync8(dirname8(authFilePath), { recursive: true });
-  writeFileSync6(authFilePath, `${JSON.stringify(next, null, 2)}
+  mkdirSync9(dirname10(authFilePath), { recursive: true });
+  writeFileSync7(authFilePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return {
     accessToken: args.accessToken,
@@ -16419,9 +17909,9 @@ var init_threadCodexWorkerIpc = __esm({
 
 // src/signupTaskSuggestions.ts
 import { spawn as spawn6 } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync13, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join16 } from "node:path";
 async function suggestSignupTasksWithCodex(args) {
   const attempts = 2;
   let previousResponse;
@@ -16443,11 +17933,11 @@ async function suggestSignupTasksWithCodex(args) {
   );
 }
 async function runCodexTaskSuggestion(args) {
-  const tempRoot = mkdtempSync3(join13(tmpdir2(), "linzumi-signup-codex-tasks-"));
-  const schemaPath = join13(tempRoot, "task-suggestions.schema.json");
-  const outputPath = join13(tempRoot, "task-suggestions.json");
+  const tempRoot = mkdtempSync3(join16(tmpdir2(), "linzumi-signup-codex-tasks-"));
+  const schemaPath = join16(tempRoot, "task-suggestions.schema.json");
+  const outputPath = join16(tempRoot, "task-suggestions.json");
   const prompt = taskSuggestionPrompt(args.previousResponse);
-  writeFileSync7(
+  writeFileSync8(
     schemaPath,
     `${JSON.stringify(taskSuggestionJsonSchema(), null, 2)}
 `,
@@ -16464,7 +17954,7 @@ async function runCodexTaskSuggestion(args) {
         prompt
       })
     );
-    return readFileSync10(outputPath, "utf8");
+    return readFileSync13(outputPath, "utf8");
   } finally {
     rmSync3(tempRoot, { recursive: true, force: true });
   }
@@ -16513,6 +18003,14 @@ function taskSuggestionPrompt(previousResponse) {
     "Task:",
     "Inspect this repository read-only and suggest exactly 5 useful quick starter tasks for Codex agents.",
     "",
+    "GitHub context:",
+    "- First check whether the GitHub CLI is available and authenticated with a cheap command such as `gh auth status`.",
+    "- If `gh` is missing, unauthenticated, or this repository has no GitHub remote, skip GitHub context and rely on local files.",
+    "- When `gh` is authenticated, use bounded reads such as `gh pr list --limit 30 --state all` and `gh issue list --limit 30 --state all` to inspect recent open and closed pull requests and issues.",
+    "- Be mindful of GitHub rate limits, CPU usage, and network usage; prefer one or two small calls and do not paginate or crawl exhaustively.",
+    "- If a GitHub call returns unauthorized, forbidden, or not found for this repository, stop GitHub lookups for this repository.",
+    "- Use pull request and issue titles, states, labels, and recent activity to infer what the repo is about, what the user has been working on, and likely next tasks.",
+    "",
     "Constraints:",
     "- Prefer tasks that are small, concrete, and likely to produce useful first results.",
     "- Do not modify files.",
@@ -16563,7 +18061,9 @@ function parseTaskSuggestionResponse(response) {
     const titles = tasks.map(
       (task) => typeof task === "object" && task !== null && !Array.isArray(task) ? task.title : void 0
     );
-    if (!titles.every((title) => typeof title === "string" && title.trim() !== "")) {
+    if (!titles.every(
+      (title) => typeof title === "string" && title.trim() !== "" && title.trim().length <= 120
+    )) {
       return void 0;
     }
     return titles.map((title, index) => ({
@@ -16626,8 +18126,8 @@ var init_signupTaskSuggestions = __esm({
 
 // src/remoteCodexSandboxRunner.ts
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync9, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute3 } from "node:path";
+import { existsSync as existsSync11, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3 } from "node:path";
 function createConfiguredRemoteCodexSandboxRunner(args) {
   const kind = normalizedSandboxKind(args.env.LINZUMI_REMOTE_CODEX_SANDBOX);
   if (kind === void 0) {
@@ -16646,7 +18146,7 @@ function createConfiguredRemoteCodexSandboxRunner(args) {
       }
       break;
   }
-  if (!existsSync9(sandboxBin)) {
+  if (!existsSync11(sandboxBin)) {
     throw new Error(`remote Codex sandbox binary not found: ${sandboxBin}`);
   }
   return createRemoteCodexSandboxRunner({
@@ -16657,7 +18157,7 @@ function createConfiguredRemoteCodexSandboxRunner(args) {
 function createRemoteCodexSandboxRunner(config, deps = {}) {
   const resolvedDeps = {
     platform: deps.platform ?? process.platform,
-    exists: deps.exists ?? existsSync9,
+    exists: deps.exists ?? existsSync11,
     spawnProcess: deps.spawnProcess ?? spawn7
   };
   return (request) => runSandboxInvocation(
@@ -16740,10 +18240,10 @@ function bubblewrapArgs(sandboxBin, request, exists) {
     key,
     value
   ]);
-  const readOnlyBindArgs = uniqueStrings2([
+  const readOnlyBindArgs = uniqueStrings3([
     ...linuxReadOnlyRoots,
-    ...isAbsolute3(request.command) ? [dirname9(request.command)] : [],
-    dirname9(sandboxBin)
+    ...isAbsolute3(request.command) ? [dirname11(request.command)] : [],
+    dirname11(sandboxBin)
   ]).flatMap((path2) => exists(path2) ? ["--ro-bind", path2, path2] : []);
   const cwdParentDirs = parentDirs(request.cwd).flatMap((path2) => [
     "--dir",
@@ -16774,9 +18274,9 @@ function bubblewrapArgs(sandboxBin, request, exists) {
   ];
 }
 function macosSeatbeltProfile(request, exists) {
-  const readableRoots = uniqueStrings2([
+  const readableRoots = uniqueStrings3([
     ...macosReadOnlyRoots,
-    ...isAbsolute3(request.command) ? [dirname9(request.command)] : []
+    ...isAbsolute3(request.command) ? [dirname11(request.command)] : []
   ]).filter(exists);
   const readableRules = readableRoots.map((path2) => `(allow file-read* (subpath ${sandboxString(path2)}))`).join("\n");
   const writableTempRules = macosWritableTempRoots.filter(exists).flatMap((path2) => [
@@ -16858,11 +18358,11 @@ function parentDirs(path2) {
     (_part, index) => `/${parents.slice(0, index + 1).join("/")}`
   );
 }
-function uniqueStrings2(values) {
+function uniqueStrings3(values) {
   return Array.from(new Set(values));
 }
 function existingPathAliases(path2) {
-  return uniqueStrings2([path2, realpathSync5(path2)]);
+  return uniqueStrings3([path2, realpathSync5(path2)]);
 }
 function sandboxString(value) {
   return JSON.stringify(value);
@@ -16898,21 +18398,29 @@ var init_remoteCodexSandboxRunner = __esm({
 });
 
 // src/runner.ts
-import { spawn as spawn8, spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { spawn as spawn8, spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   lstatSync,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync4,
-  readdirSync as readdirSync2,
+  readdirSync as readdirSync4,
   realpathSync as realpathSync6,
   rmSync as rmSync4,
-  statSync
+  statSync as statSync3
 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
 import { createServer as createServer3 } from "node:http";
 import { hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname10, isAbsolute as isAbsolute4, join as join14, resolve as resolve7 } from "node:path";
+import {
+  basename as basename8,
+  dirname as dirname12,
+  extname as extname2,
+  isAbsolute as isAbsolute4,
+  join as join17,
+  resolve as resolve7
+} from "node:path";
 async function runLocalCodexRunner(options) {
   const log = makeRunnerLogger(options);
   const cleanup = {
@@ -17172,7 +18680,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
     }
   }
-  const instanceId = `codex-${randomUUID3()}`;
+  const instanceId = `codex-${randomUUID4()}`;
   const publishLocalEditorStatus = (payload) => {
     void kandan.push(topic, "local_editor_status", payload).catch((error) => {
       log("kandan.local_editor_status_push_failed", {
@@ -17247,7 +18755,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   };
   const approveEditorPortForwardCandidate = (candidate) => {
     const request = pendingRequestFromCandidate({
-      requestId: `editor-port-forward-auto-${randomUUID3()}`,
+      requestId: `editor-port-forward-auto-${randomUUID4()}`,
       sourceSeq: 0,
       candidate
     });
@@ -17475,7 +18983,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       return;
     }
     const request = pendingRequestFromCandidate({
-      requestId: `claude-port-forward-auto-${randomUUID3()}`,
+      requestId: `claude-port-forward-auto-${randomUUID4()}`,
       sourceSeq,
       candidate
     });
@@ -17888,6 +19396,21 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     codexUrl: codexUrl ?? null,
     replacedRunners
   });
+  const lifecycleWorkspaceSlug = runnerWorkspaceSlug(options);
+  const lifecycleTelemetryAttributes = {
+    ...lifecycleWorkspaceSlug === void 0 ? {} : { workspace: lifecycleWorkspaceSlug },
+    launch_source: options.launchSource ?? "cli"
+  };
+  void postLifecycleEvent(
+    { name: "commander.connected", attributes: lifecycleTelemetryAttributes },
+    { apiUrl: options.kandanUrl }
+  );
+  cleanup.actions.push(
+    () => postLifecycleEvent(
+      { name: "commander.exited", attributes: lifecycleTelemetryAttributes },
+      { apiUrl: options.kandanUrl }
+    )
+  );
   const channelSession = options.channelSession === void 0 ? void 0 : await attachChannelSession({
     kandan,
     codex,
@@ -18517,6 +20040,17 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       void pushHeartbeat();
       return;
     }
+    if (control.type === "import_onboarding_conversations") {
+      void runLocalOnboardingConversationImport(options, log, control).catch(
+        (error) => {
+          log("onboarding.conversation_import_failed", {
+            runnerId: options.runnerId,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      );
+      return;
+    }
     void resolveSessionControl(channelSession, dynamicChannelSessions, control).then((handled) => {
       if (handled !== void 0) {
         return handled;
@@ -18553,9 +20087,19 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       });
     });
   };
+  finishRunnerStartup(
+    options,
+    log,
+    pendingControls,
+    controlDispatcher,
+    handleControl
+  );
+  return { instanceId, codexUrl, close };
+}
+function finishRunnerStartup(options, log, pendingControls, controlDispatcher, handleControl) {
   controlDispatcher.value = handleControl;
   pendingControls.splice(0).forEach(handleControl);
-  return { instanceId, codexUrl, close };
+  startOnboardingDiscoveryAgents(options, log);
 }
 function controlTargetsInstance(control, instanceId) {
   switch (control.type) {
@@ -19697,22 +21241,6 @@ ${args.developerPrompt}
 `;
   const linzumiContext = args.linzumiContext === void 0 ? "" : `
 ${formatLinzumiConversationContextForPrompt(args.linzumiContext)}
-`;
-  const reviewGuidance = `
-<linzumi_pr_review_guidance>
-For frontend or other user-visible changes, ask whether the user wants
-screenshot or screen-recording proof, ideally before/after when that helps
-review the change. Screen recordings should be WebM or MP4. When the user asks
-you to open or update a PR, attach or link that proof in the PR when feasible,
-and state the exact blocker when it is not feasible.
-</linzumi_pr_review_guidance>
-
-<linzumi_user_visible_writing_guide>
-When you write user-visible UI, status, error, or PR-review copy, keep it short,
-direct, and focused on the user's outcome. Avoid implementation-heavy sentences,
-stacked clauses, and internal mechanics unless the user explicitly needs that
-detail.
-</linzumi_user_visible_writing_guide>
 `;
   return `<context>
 You are a Linzumi ${agentLabel} session launched by the Linzumi Commander.
@@ -19731,6 +21259,15 @@ Linzumi.
 Linzumi ${agentLabel} session: You, the inner ${agentLabel} process that performs the actual
 work in the approved project folder.
 Approved project folder: ${args.cwd}
+Coding-job metadata: User-visible goal, plan steps, step statuses, completion
+notes, primary pull request link, and worktree state shown in Linzumi's coding
+job overview.
+Plan step: A discrete chunk of work with a short title, one-line description,
+status, and completion note. It should describe an actual goal, not just a
+process verb.
+Primary pull request: The GitHub PR the job is currently driving or reviewing;
+Linzumi uses this link to hydrate PR comments, files, commits, checks, and
+deployments in the metadata overview.
 </term_definitions>
 
 <linzumi_mcp>
@@ -19740,24 +21277,53 @@ read a message by ID/URL, read a thread by ID, read the scoped channel, or send
 a concise DM to the Commander owner when the task genuinely requires it.
 </linzumi_mcp>
 
-<coding_job_metadata>
-When you are working inside a coding-job thread, keep the job metadata current through the Linzumi MCP tools.
-At the beginning of a job, call linzumi_upsert_coding_job_plan with your current understanding of the goal, then call linzumi_replace_coding_job_plan_steps with an ordered list of steps to accomplish that goal.
-The plan is allowed to change. Rework it when the old plan is no longer a useful description of the work, but do not churn it for minor tactical adjustments.
-As you make progress, call linzumi_update_coding_job_plan_step to mark the active step and completed steps. Read the metadata first when you need current step ids or lock versions.
-When you open, discover, or choose the primary GitHub pull request for the job, call linzumi_link_coding_job_pull_request with the PR URL, repo owner/name, PR number, title, head/base branches, head/base SHAs, local worktree path, remote URL, and current dirty status. This link is what lets GitHub PR comments, files, commits, checks, deployments, and reviews appear automatically in the metadata overview.
-The plan and goal are user-visible, so keep titles short, descriptions concrete, and completion notes focused on what was verified.
-</coding_job_metadata>
-
 <task_instructions>
 Work only in the approved project folder unless the human explicitly asks for
 something else in the Linzumi thread. Start, inspect, and modify the local app
 from that folder. Report concise progress and exact blockers in the thread.
+Use the Linzumi MCP server named "linzumi" when you need authenticated
+workspace context or coding-job metadata tools.
+For coding-job threads, start by setting the current goal with
+linzumi_upsert_coding_job_plan, then replace the plan steps with
+linzumi_replace_coding_job_plan_steps.
+When the coding-job scope changes materially, call linzumi_rename_coding_job
+with a concise title so the Linzumi thread title and workflow-facing title
+match the work.
+As work proceeds, update each step with linzumi_update_coding_job_plan_step.
+When you open, discover, or choose the primary pull request, link it with
+linzumi_link_coding_job_pull_request.
+Before stopping, confirm the metadata overview tells the truth for a user who
+only sees that overview: completed work is completed, active work is really
+active, blocked work says why, and no stale in-progress step is left behind.
+For frontend or other user-visible changes, ask whether the user wants
+screenshot or screen-recording proof, ideally before/after when that helps
+review the change. Screen recordings should be WebM or MP4.
+When the user asks you to open or update a PR, attach or link feasible proof in
+the PR and state the exact blocker when proof is not feasible.
 </task_instructions>
 
 <rules>
 You MUST treat the Linzumi thread as the source of truth for user-facing
 progress.
+For coding-job threads, you MUST keep coding-job metadata current throughout
+the job.
+Plan steps MUST be fairly granular, discrete chunks of real work that a human
+can track.
+Plan step descriptions MUST stay short, usually one line and less than one full
+sentence.
+Plan steps MUST NOT be vague process-only labels such as "sync PR",
+"update PR", "verify PR", or "commit and merge" when those labels hide the
+concrete goal.
+You MUST update steps in sequence as work is completed. Do not mark a later
+step active while earlier applicable steps are still pending.
+Before you stop work, you MUST reconcile the plan so the job is not left with a
+stale active step. You may delegate metadata upkeep to a sub-agent when useful,
+but the visible job state must remain truthful.
+If the coding-job thread title is missing, undefined, or "Untitled", you MUST
+choose a concise, specific title for the job.
+User-visible UI, status, error, and PR-review copy MUST keep it short, direct,
+and focused on the user's outcome unless the user explicitly asks for
+implementation detail.
 You MUST keep user-visible preview servers bound to 0.0.0.0, not 127.0.0.1 or
 localhost, so the Linzumi secure tunnel can reach them.
 You MUST keep any preview or dev server as your descendant process so the
@@ -19774,16 +21340,51 @@ revert another session's work.
 
 <examples>
 GOOD preview command: npm run dev -- --host 0.0.0.0 --port 8787
+Why good: The preview is reachable through the Linzumi secure tunnel.
+
 BAD preview command: npm run dev -- --host 127.0.0.1
+Why bad: Binding to localhost prevents the Linzumi secure tunnel from reaching
+the preview.
+
+GOOD coding-job plan:
+- Inspect prompt sources: Locate the prompt builder, prompt guide, and tests.
+- Add metadata guidance: Patch the prompt with plan, title, and stop-state rules.
+- Verify compiled prompt: Run focused tests and inspect the generated text.
+- Push PR update: Commit owned files, push the branch, and refresh PR metadata.
+Why good: Each step is a concrete chunk of work, the list is short enough to
+scan, and the titles explain what is actually happening.
+
+BAD coding-job plan:
+- Sync PR
+- Update PR
+- Verify PR
+- Commit and merge
+Why bad: These labels describe process mechanics, not the concrete work or
+product goal. A user cannot tell what the agent has learned, changed, or still
+needs to do.
+
+BAD coding-job metadata state:
+- Step 1 complete, Step 2 complete, Step 3 active, Step 4 pending.
+- The agent has stopped working and sent its final response.
+Why bad: The overview still says work is active even though the agent is idle.
+Before stopping, the agent should mark Step 3 completed, blocked, or canceled
+with a truthful note.
 </examples>
 ${linzumiContext}
-${reviewGuidance}
 ${customPrompt}
 <task_reminder>
 You are the Commander-launched Linzumi ${agentLabel} session. Do the implementation
 work in the approved project folder, keep preview servers reachable through the
-secure tunnel, and keep the Linzumi thread truthful.
-</task_reminder>`;
+secure tunnel, and keep the Linzumi thread and coding-job metadata truthful.
+</task_reminder>
+
+<output_format>
+Use normal concise Linzumi thread messages for user-facing progress and final
+answers. When the task requires files, code, commits, pull requests, previews,
+or verification output, report the concrete artifact, command, result, and any
+exact blocker. Do not emit machine-only JSON unless the user or tool explicitly
+requests it.
+</output_format>`;
 }
 function availableRunnerAgentProviders(options) {
   switch (options.claudeCodeRunner !== void 0 || options.claudeCodeAvailable === true) {
@@ -21580,6 +23181,869 @@ function redactedThreadRunnerCliArgs(args) {
 function optionalCliValue(flag, value) {
   return value === void 0 || value === "" ? [] : [flag, value];
 }
+function startOnboardingDiscoveryAgents(options, log) {
+  const workspaceSlug = runnerWorkspaceSlug(options);
+  if (!shouldStartOnboardingDiscoveryAgents(options, workspaceSlug)) {
+    return;
+  }
+  const startKey = onboardingDiscoveryAgentStartKey(options, workspaceSlug);
+  if (onboardingDiscoveryAgentStartKeys.has(startKey)) {
+    log("onboarding.discovery_agents_already_started", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug
+    });
+    return;
+  }
+  onboardingDiscoveryAgentStartKeys.add(startKey);
+  log("onboarding.discovery_agents_started", {
+    runnerId: options.runnerId,
+    workspace: workspaceSlug,
+    kandanUrl: options.kandanUrl
+  });
+  const discoveryStartedAtMs = Date.now();
+  void Promise.allSettled([
+    runLocalOnboardingProjectDiscovery(options, log),
+    runLocalOnboardingConversationDiscovery(options, log)
+  ]).then(async (results) => {
+    const initialSearchDurationMs = Date.now() - discoveryStartedAtMs;
+    let successfulWriteCount = 0;
+    for (const result of results) {
+      if (result.status !== "fulfilled" || result.value === void 0) {
+        continue;
+      }
+      successfulWriteCount += result.value.successfulPostStartWriteCount ?? 0;
+      const initialSearchStatusWritten = await reportOnboardingDiscoveryStatus(
+        options,
+        log,
+        {
+          ...result.value,
+          metadata: {
+            ...result.value.metadata,
+            initial_search_duration_ms: initialSearchDurationMs
+          }
+        }
+      );
+      if (initialSearchStatusWritten) {
+        successfulWriteCount += 1;
+      }
+    }
+    if (successfulWriteCount === 0) {
+      onboardingDiscoveryAgentStartKeys.delete(startKey);
+      log("onboarding.discovery_agents_start_key_cleared", {
+        runnerId: options.runnerId,
+        workspace: workspaceSlug
+      });
+    }
+    log("onboarding.discovery_initial_search_completed", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      duration_ms: initialSearchDurationMs,
+      workers_completed: 2,
+      successful_write_count: successfulWriteCount
+    });
+  });
+}
+function withSuccessfulWriteCount(report, successfulPostStartWriteCount) {
+  return {
+    ...report,
+    successfulPostStartWriteCount
+  };
+}
+async function addStatusWriteResult(successfulWriteCount, statusWrite) {
+  const written = await statusWrite;
+  return written ? successfulWriteCount + 1 : successfulWriteCount;
+}
+function successfulSettledWriteCount(results) {
+  return results.filter((result) => result.status === "fulfilled").length;
+}
+async function runLocalOnboardingConversationImport(options, log, control) {
+  const workspaceSlug = stringValue(control.workspace) ?? runnerWorkspaceSlug(options);
+  if (workspaceSlug === void 0) {
+    throw new Error("workspace_required");
+  }
+  const sources = onboardingConversationImportSources(control.sources);
+  const importKey = onboardingConversationImportRunKey(
+    options.runnerId,
+    workspaceSlug,
+    sources
+  );
+  if (onboardingConversationImportKeys.has(importKey)) {
+    log("onboarding.conversation_import_skipped", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      sources,
+      reason: "already_running"
+    });
+    return;
+  }
+  onboardingConversationImportKeys.add(importKey);
+  try {
+    await runLocalOnboardingConversationImportOnce(
+      options,
+      log,
+      control,
+      workspaceSlug,
+      sources
+    );
+  } finally {
+    onboardingConversationImportKeys.delete(importKey);
+  }
+}
+async function runLocalOnboardingConversationImportOnce(options, log, _control, workspaceSlug, sources) {
+  if (sources.length === 0) {
+    await reportOnboardingDiscoveryStatus(options, log, {
+      phase: "conversations",
+      status: "completed",
+      placesSearched: 0,
+      message: "No local conversation imports selected",
+      currentPlace: "Codex and Claude Code stores",
+      metadata: {
+        worker_id: "conversations-local-import",
+        worker_label: "Local conversation import",
+        imported_count: 0,
+        reported_count: 0
+      }
+    });
+    return;
+  }
+  await reportOnboardingDiscoveryStatus(options, log, {
+    phase: "conversations",
+    status: "running",
+    placesSearched: 0,
+    message: "Importing local conversations",
+    currentPlace: "Codex and Claude Code stores",
+    metadata: {
+      worker_id: "conversations-local-import",
+      worker_label: "Local conversation import",
+      imported_count: 0,
+      reported_count: 0
+    }
+  });
+  const summary = options.localConversationDiscovery?.() ?? discoverLocalConversations({
+    candidateLimit: onboardingConversationImportCandidateLimit
+  });
+  const sourceSet = new Set(sources);
+  const candidates = summary.candidates.filter((candidate) => sourceSet.has(candidate.source)).slice(0, onboardingConversationImportCandidateLimit);
+  const totalCount = candidates.length;
+  const client = createLinzumiMcpApiClient({
+    kandanUrl: options.kandanUrl,
+    accessToken: options.token,
+    fetchImpl: options.fetch,
+    operatingMode: "text"
+  });
+  let importedCount = 0;
+  let failedImportCount = 0;
+  let skippedImportCount = 0;
+  for (const [index, candidate] of candidates.entries()) {
+    try {
+      const messages = readLocalConversationImportMessages(candidate);
+      const response = await client.noteAgentConversation({
+        workspace: workspaceSlug,
+        runner_id: options.runnerId,
+        source: candidate.source,
+        import_key: candidate.importKey,
+        import_to_office_channel: true,
+        path: candidate.path,
+        display_name: candidate.displayName,
+        ...candidate.activityAt === void 0 ? {} : { activity_at: candidate.activityAt },
+        metadata: candidate.metadata,
+        title_messages: onboardingConversationTitleMessages(messages)
+      });
+      const officeImport = onboardingConversationOfficeImport(response);
+      const threadId = stringValue(officeImport?.thread_id);
+      const importStatus = stringValue(officeImport?.status);
+      switch (importStatus) {
+        case "failed":
+          skippedImportCount += 1;
+          log("onboarding.conversation_import_candidate_skipped", {
+            runnerId: options.runnerId,
+            workspace: workspaceSlug,
+            source: candidate.source,
+            import_key: candidate.importKey,
+            message: stringValue(officeImport?.error) ?? "conversation_import_failed"
+          });
+          continue;
+        default:
+          break;
+      }
+      switch (threadId) {
+        case void 0:
+          break;
+        default: {
+          const replayedChunkCount = await replayLocalOnboardingConversation({
+            client,
+            options,
+            workspaceSlug,
+            threadId,
+            candidate,
+            messages
+          });
+          await markLocalOnboardingConversationReplayCompleted({
+            client,
+            workspaceSlug,
+            runnerId: options.runnerId,
+            candidate,
+            threadId,
+            officeImport,
+            replayedMessageCount: messages.length,
+            replayedChunkCount
+          }).catch((error) => {
+            log("onboarding.conversation_import_replay_completion_failed", {
+              runnerId: options.runnerId,
+              workspace: workspaceSlug,
+              source: candidate.source,
+              import_key: candidate.importKey,
+              message: error instanceof Error ? error.message : String(error)
+            });
+          });
+          break;
+        }
+      }
+      importedCount += 1;
+    } catch (error) {
+      failedImportCount += 1;
+      log("onboarding.conversation_import_candidate_failed", {
+        runnerId: options.runnerId,
+        workspace: workspaceSlug,
+        source: candidate.source,
+        import_key: candidate.importKey,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const processedCount = index + 1;
+    if (processedCount === candidates.length || processedCount % onboardingConversationImportProgressInterval === 0) {
+      await reportOnboardingDiscoveryStatus(options, log, {
+        phase: "conversations",
+        status: "running",
+        placesSearched: summary.placesSearched,
+        message: "Importing local conversations",
+        currentPlace: "Codex and Claude Code stores",
+        metadata: {
+          worker_id: "conversations-local-import",
+          worker_label: "Local conversation import",
+          duration_ms: summary.durationMs,
+          codex_count: sources.includes("codex") ? summary.codexCount : 0,
+          claude_code_count: sources.includes("claude_code") ? summary.claudeCodeCount : 0,
+          candidate_limit: onboardingConversationImportCandidateLimit,
+          imported_count: importedCount,
+          failed_import_count: failedImportCount,
+          skipped_import_count: skippedImportCount,
+          reported_count: importedCount,
+          total_count: totalCount
+        }
+      });
+    }
+  }
+  await reportOnboardingDiscoveryStatus(options, log, {
+    phase: "conversations",
+    status: "completed",
+    placesSearched: summary.placesSearched,
+    message: "Local conversation import finished",
+    currentPlace: "Codex and Claude Code stores",
+    metadata: {
+      worker_id: "conversations-local-import",
+      worker_label: "Local conversation import",
+      duration_ms: summary.durationMs,
+      codex_count: sources.includes("codex") ? summary.codexCount : 0,
+      claude_code_count: sources.includes("claude_code") ? summary.claudeCodeCount : 0,
+      candidate_limit: onboardingConversationImportCandidateLimit,
+      imported_count: importedCount,
+      failed_import_count: failedImportCount,
+      skipped_import_count: skippedImportCount,
+      reported_count: importedCount,
+      total_count: totalCount
+    }
+  });
+}
+function onboardingConversationImportRunKey(runnerId, workspaceSlug, sources) {
+  return `${runnerId}:${workspaceSlug}:${[...sources].sort().join(",")}`;
+}
+function onboardingConversationImportSources(value) {
+  return Array.from(
+    new Set(
+      (arrayValue(value) ?? []).flatMap((source) => {
+        switch (stringValue(source)) {
+          case "codex":
+            return ["codex"];
+          case "claude_code":
+            return ["claude_code"];
+          default:
+            return [];
+        }
+      })
+    )
+  ).sort();
+}
+async function replayLocalOnboardingConversation(args) {
+  let replayedChunkCount = 0;
+  for (const message of args.messages) {
+    const chunks = onboardingConversationImportMessageChunks(message);
+    for (const chunk of chunks) {
+      const clientMessageId = onboardingConversationImportClientMessageId(
+        args.candidate.importKey,
+        chunk.itemKey
+      );
+      const writeMetadata = {
+        import_role: message.role,
+        import_source: args.candidate.source,
+        ...chunk.activityAt === void 0 ? {} : { source_activity_at: chunk.activityAt }
+      };
+      const chunkHasAttachments = chunk.attachments.length > 0 && chunk.index === chunks.length - 1;
+      if (!chunkHasAttachments) {
+        await args.client.sendThreadReply({
+          workspace: args.workspaceSlug,
+          thread_id: args.threadId,
+          body: chunk.body,
+          client_message_id: clientMessageId,
+          ...writeMetadata
+        });
+        replayedChunkCount += 1;
+        continue;
+      }
+      const uploadResult = await uploadLocalConversationAttachments({
+        client: args.client,
+        options: args.options,
+        workspaceSlug: args.workspaceSlug,
+        candidatePath: args.candidate.path,
+        body: chunk.body,
+        attachments: chunk.attachments
+      });
+      if (uploadResult.uploadedFileIds.length > 0) {
+        await args.client.attachMessageFiles({
+          workspace: args.workspaceSlug,
+          target: { kind: "new_message", thread_id: args.threadId },
+          body: uploadResult.body,
+          uploaded_file_ids: uploadResult.uploadedFileIds,
+          client_message_id: clientMessageId,
+          ...writeMetadata
+        });
+        replayedChunkCount += 1;
+        continue;
+      }
+      await args.client.sendThreadReply({
+        workspace: args.workspaceSlug,
+        thread_id: args.threadId,
+        body: uploadResult.body,
+        client_message_id: clientMessageId,
+        ...writeMetadata
+      });
+      replayedChunkCount += 1;
+    }
+  }
+  return replayedChunkCount;
+}
+function onboardingConversationImportMessageChunks(message) {
+  const parts = splitOnboardingConversationImportBody(message.body);
+  return parts.map((body, index) => ({
+    itemKey: parts.length === 1 ? message.itemKey : `${message.itemKey}:part-${index + 1}`,
+    body,
+    attachments: index === parts.length - 1 ? message.attachments : [],
+    activityAt: message.activityAt,
+    index
+  }));
+}
+function splitOnboardingConversationImportBody(body) {
+  const trimmed = body.trim();
+  if (trimmed.length <= onboardingConversationImportMessageMaxLength) {
+    return [trimmed];
+  }
+  const parts = [];
+  let remaining = trimmed;
+  while (remaining.length > onboardingConversationImportMessageMaxLength) {
+    const slice = remaining.slice(
+      0,
+      onboardingConversationImportMessageMaxLength
+    );
+    const paragraphBreak = slice.lastIndexOf("\n\n");
+    const lineBreak = slice.lastIndexOf("\n");
+    const splitAt = paragraphBreak > onboardingConversationImportMessageMaxLength / 2 ? paragraphBreak : lineBreak > onboardingConversationImportMessageMaxLength / 2 ? lineBreak : onboardingConversationImportMessageMaxLength;
+    const part = remaining.slice(0, splitAt).trim();
+    if (part !== "") {
+      parts.push(part);
+    }
+    remaining = remaining.slice(splitAt).trim();
+  }
+  if (remaining !== "") {
+    parts.push(remaining);
+  }
+  return parts;
+}
+function onboardingConversationTitleMessages(messages) {
+  const indexedMessages = messages.map((message, index) => ({
+    message,
+    index
+  }));
+  const firstMessages = indexedMessages.slice(0, onboardingConversationTitleFirstMessages).map(
+    ({ message, index }) => onboardingConversationTitleMessage("first", index, message)
+  );
+  const lastStartIndex = Math.max(
+    onboardingConversationTitleFirstMessages,
+    indexedMessages.length - onboardingConversationTitleLastMessages
+  );
+  const lastMessages = indexedMessages.slice(lastStartIndex).map(
+    ({ message, index }) => onboardingConversationTitleMessage("last", index, message)
+  );
+  return [...firstMessages, ...lastMessages].filter(
+    (message) => message !== void 0
+  );
+}
+function onboardingConversationTitleMessage(position, index, message) {
+  const body = message.body.trim();
+  if (body === "") {
+    return void 0;
+  }
+  return {
+    position,
+    index,
+    role: message.role,
+    body: body.length > onboardingConversationTitleBodyMaxLength ? `${body.slice(0, onboardingConversationTitleBodyMaxLength).trim()}...` : body
+  };
+}
+async function markLocalOnboardingConversationReplayCompleted(args) {
+  await args.client.noteAgentConversation({
+    workspace: args.workspaceSlug,
+    runner_id: args.runnerId,
+    source: args.candidate.source,
+    import_key: args.candidate.importKey,
+    import_to_office_channel: true,
+    path: args.candidate.path,
+    display_name: args.candidate.displayName,
+    ...args.candidate.activityAt === void 0 ? {} : { activity_at: args.candidate.activityAt },
+    metadata: {
+      ...args.candidate.metadata,
+      office_channel_import: {
+        ...args.officeImport ?? {},
+        thread_id: args.threadId,
+        replayed_message_count: args.replayedMessageCount,
+        replayed_chunk_count: args.replayedChunkCount,
+        replay_completed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+}
+function onboardingConversationOfficeImport(response) {
+  const discovery = objectValue(response.discovery);
+  const metadata = objectValue(discovery?.metadata);
+  return objectValue(metadata?.office_channel_import);
+}
+function onboardingConversationImportClientMessageId(importKey, itemKey) {
+  const importHash = createHash3("sha256").update(importKey).digest("hex");
+  const itemHash = createHash3("sha256").update(itemKey).digest("hex");
+  return `onboarding-import:${importHash.slice(0, 32)}:${itemHash.slice(0, 24)}`;
+}
+async function uploadLocalConversationAttachments(args) {
+  const files = (await Promise.all(
+    args.attachments.map(
+      (attachment) => localConversationAttachmentFile(args.candidatePath, attachment)
+    )
+  )).filter(
+    (file) => file !== void 0
+  );
+  if (files.length === 0) {
+    return {
+      body: `${args.body}
+
+${args.attachments.length} referenced attachment${args.attachments.length === 1 ? "" : "s"} were not available on disk.`,
+      uploadedFileIds: []
+    };
+  }
+  const prepare = await args.client.prepareMessageUploads({
+    workspace: args.workspaceSlug,
+    files: files.map((file) => ({
+      file_name: file.fileName,
+      content_type: file.contentType,
+      size_bytes: file.bytes.byteLength
+    }))
+  });
+  const uploads = arrayValue(prepare.uploads) ?? [];
+  if (uploads.length !== files.length) {
+    throw new Error("Linzumi upload prepare response count mismatch");
+  }
+  const preparedUploads = files.map((file, index) => {
+    const upload = objectValue(uploads[index]);
+    const uploadUrl = stringValue(upload?.upload_url);
+    const uploadMethod = stringValue(upload?.upload_method) ?? "PUT";
+    const fileId = stringValue(upload?.file_id);
+    if (uploadUrl === void 0) {
+      throw new Error("Linzumi upload prepare response missing upload_url");
+    }
+    if (fileId === void 0) {
+      throw new Error("Linzumi upload prepare response missing file_id");
+    }
+    return {
+      file,
+      fileId,
+      uploadMethod,
+      uploadUrl
+    };
+  });
+  const uploadResults = await Promise.allSettled(
+    preparedUploads.map(async ({ file, uploadMethod, uploadUrl }) => {
+      const uploadBody = file.bytes.buffer.slice(
+        file.bytes.byteOffset,
+        file.bytes.byteOffset + file.bytes.byteLength
+      );
+      const response = await (args.options.fetch ?? globalThis.fetch)(
+        resolveLinzumiUploadUrl(args.options.kandanUrl, uploadUrl),
+        {
+          method: uploadMethod,
+          headers: { "content-type": file.contentType },
+          body: uploadBody
+        }
+      );
+      if (!response.ok) {
+        throw new Error(
+          `Linzumi upload failed for ${file.fileName}: ${response.status} ${response.statusText}`
+        );
+      }
+    })
+  );
+  const uploadedFileIds = preparedUploads.flatMap((upload, index) => {
+    switch (uploadResults[index]?.status) {
+      case "fulfilled":
+        return [upload.fileId];
+      default:
+        return [];
+    }
+  });
+  const failedUploadCount = uploadResults.filter(
+    (result) => result.status === "rejected"
+  ).length;
+  return {
+    body: failedUploadCount === 0 ? args.body : `${args.body}
+
+${failedUploadCount} referenced attachment${failedUploadCount === 1 ? "" : "s"} failed to upload.`,
+    uploadedFileIds
+  };
+}
+async function localConversationAttachmentFile(candidatePath, attachment) {
+  switch (attachment.kind) {
+    case "bytes": {
+      return {
+        fileName: attachment.fileName,
+        contentType: attachment.contentType,
+        bytes: Buffer.from(attachment.dataBase64, "base64")
+      };
+    }
+    case "path": {
+      const path2 = isAbsolute4(attachment.path) ? attachment.path : resolve7(dirname12(candidatePath), attachment.path);
+      try {
+        const bytes = await readFile2(path2);
+        return {
+          fileName: attachment.fileName ?? basename8(path2),
+          contentType: attachment.contentType ?? contentTypeForPath(path2),
+          bytes
+        };
+      } catch (_error) {
+        return void 0;
+      }
+    }
+  }
+}
+function contentTypeForPath(path2) {
+  switch (extname2(path2).toLowerCase()) {
+    case ".gif":
+      return "image/gif";
+    case ".jpeg":
+    case ".jpg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".webp":
+      return "image/webp";
+    case ".json":
+    case ".jsonl":
+      return "application/json";
+    case ".md":
+      return "text/markdown";
+    case ".txt":
+      return "text/plain";
+    default:
+      return "application/octet-stream";
+  }
+}
+function resolveLinzumiUploadUrl(kandanUrl, uploadUrl) {
+  try {
+    return new URL(uploadUrl).toString();
+  } catch (_error) {
+    const httpBase = kandanUrl.replace(/^wss:\/\//, "https://").replace(/^ws:\/\//, "http://");
+    return new URL(uploadUrl, httpBase).toString();
+  }
+}
+async function runLocalOnboardingConversationDiscovery(options, log) {
+  const workspaceSlug = runnerWorkspaceSlug(options);
+  if (workspaceSlug === void 0) {
+    return;
+  }
+  await reportOnboardingDiscoveryStatus(options, log, {
+    phase: "conversations",
+    status: "starting",
+    placesSearched: 0,
+    message: "Counting local conversations",
+    currentPlace: "Codex and Claude Code stores",
+    metadata: {
+      worker_id: "conversations-local-filesystem",
+      worker_label: "Local conversation files"
+    }
+  });
+  let successfulPostStartWriteCount = 0;
+  try {
+    const summary = options.localConversationDiscovery?.() ?? discoverLocalConversations();
+    const reportedCandidates = summary.candidates.slice(
+      0,
+      onboardingConversationDiscoveryReportLimit
+    );
+    const baseMetadata = {
+      worker_id: "conversations-local-filesystem",
+      worker_label: "Local conversation files",
+      duration_ms: summary.durationMs,
+      codex_count: summary.codexCount,
+      claude_code_count: summary.claudeCodeCount,
+      claude_code_subagent_count: summary.claudeCodeSubagentCount,
+      reported_count: reportedCandidates.length,
+      report_limit: onboardingConversationDiscoveryReportLimit,
+      search_stats: summary.searchStats
+    };
+    successfulPostStartWriteCount = await addStatusWriteResult(
+      successfulPostStartWriteCount,
+      reportOnboardingDiscoveryStatus(options, log, {
+        phase: "conversations",
+        status: "running",
+        placesSearched: summary.placesSearched,
+        message: "Reporting local conversations",
+        currentPlace: "Codex and Claude Code stores",
+        metadata: baseMetadata
+      })
+    );
+    const client = createLinzumiMcpApiClient({
+      kandanUrl: options.kandanUrl,
+      accessToken: options.token,
+      fetchImpl: options.fetch,
+      operatingMode: "text"
+    });
+    const reportResults = await Promise.allSettled(
+      reportedCandidates.map(
+        (candidate) => client.noteAgentConversation({
+          workspace: workspaceSlug,
+          runner_id: options.runnerId,
+          source: candidate.source,
+          import_key: candidate.importKey,
+          path: candidate.path,
+          display_name: candidate.displayName,
+          ...candidate.activityAt === void 0 ? {} : { activity_at: candidate.activityAt },
+          metadata: candidate.metadata
+        })
+      )
+    );
+    const failedReportCount = reportResults.filter(
+      (result) => result.status === "rejected"
+    ).length;
+    successfulPostStartWriteCount += successfulSettledWriteCount(reportResults);
+    const completedMetadata = {
+      ...baseMetadata,
+      failed_report_count: failedReportCount
+    };
+    const completedReport = {
+      phase: "conversations",
+      status: "completed",
+      placesSearched: summary.placesSearched,
+      message: "Local conversation scan finished",
+      currentPlace: "Codex and Claude Code stores",
+      metadata: completedMetadata
+    };
+    successfulPostStartWriteCount = await addStatusWriteResult(
+      successfulPostStartWriteCount,
+      reportOnboardingDiscoveryStatus(options, log, completedReport)
+    );
+    log("onboarding.local_conversation_discovery_completed", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      duration_ms: summary.durationMs,
+      codex_count: summary.codexCount,
+      claude_code_count: summary.claudeCodeCount,
+      claude_code_subagent_count: summary.claudeCodeSubagentCount,
+      reported_count: reportedCandidates.length,
+      failed_report_count: failedReportCount
+    });
+    return withSuccessfulWriteCount(
+      completedReport,
+      successfulPostStartWriteCount
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const failedReport = {
+      phase: "conversations",
+      status: "failed",
+      placesSearched: 0,
+      message: "Local conversation scan failed",
+      currentPlace: "Codex and Claude Code stores",
+      lastError: message,
+      metadata: {
+        worker_id: "conversations-local-filesystem",
+        worker_label: "Local conversation files"
+      }
+    };
+    successfulPostStartWriteCount = await addStatusWriteResult(
+      successfulPostStartWriteCount,
+      reportOnboardingDiscoveryStatus(options, log, failedReport)
+    );
+    log("onboarding.local_conversation_discovery_failed", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      message
+    });
+    return withSuccessfulWriteCount(
+      failedReport,
+      successfulPostStartWriteCount
+    );
+  }
+}
+async function runLocalOnboardingProjectDiscovery(options, log) {
+  const workspaceSlug = runnerWorkspaceSlug(options);
+  if (workspaceSlug === void 0) {
+    return;
+  }
+  await reportOnboardingDiscoveryStatus(options, log, {
+    phase: "projects",
+    status: "starting",
+    placesSearched: 0,
+    message: "Checking current Git project",
+    currentPlace: options.cwd,
+    currentSource: "git",
+    metadata: {
+      worker_id: "projects-local-current",
+      worker_label: "Current Git project"
+    }
+  });
+  let successfulPostStartWriteCount = 0;
+  try {
+    const summary = options.localProjectDiscovery?.() ?? discoverCurrentGitProject({ cwd: options.cwd });
+    const client = createLinzumiMcpApiClient({
+      kandanUrl: options.kandanUrl,
+      accessToken: options.token,
+      fetchImpl: options.fetch,
+      operatingMode: "text"
+    });
+    const reportResults = await Promise.allSettled(
+      summary.candidates.map(
+        (candidate) => client.noteProjectDirectory({
+          workspace: workspaceSlug,
+          runner_id: options.runnerId,
+          import_key: candidate.importKey,
+          path: candidate.path,
+          display_name: candidate.displayName,
+          ...candidate.activityAt === void 0 ? {} : { activity_at: candidate.activityAt },
+          metadata: candidate.metadata
+        })
+      )
+    );
+    const failedReportCount = reportResults.filter(
+      (result) => result.status === "rejected"
+    ).length;
+    successfulPostStartWriteCount += successfulSettledWriteCount(reportResults);
+    const completedReport = {
+      phase: "projects",
+      status: "completed",
+      placesSearched: summary.placesSearched,
+      message: summary.candidates.length === 0 ? "Current folder is not a Git project" : "Current Git project found",
+      currentPlace: options.cwd,
+      currentSource: "git",
+      metadata: {
+        worker_id: "projects-local-current",
+        worker_label: "Current Git project",
+        duration_ms: summary.durationMs,
+        reported_count: summary.candidates.length,
+        failed_report_count: failedReportCount,
+        search_stats: summary.searchStats
+      }
+    };
+    successfulPostStartWriteCount = await addStatusWriteResult(
+      successfulPostStartWriteCount,
+      reportOnboardingDiscoveryStatus(options, log, completedReport)
+    );
+    log("onboarding.local_project_discovery_completed", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      duration_ms: summary.durationMs,
+      reported_count: summary.candidates.length,
+      failed_report_count: failedReportCount
+    });
+    return withSuccessfulWriteCount(
+      completedReport,
+      successfulPostStartWriteCount
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const failedReport = {
+      phase: "projects",
+      status: "failed",
+      placesSearched: 0,
+      message: "Current Git project scan failed",
+      currentPlace: options.cwd,
+      currentSource: "git",
+      lastError: message,
+      metadata: {
+        worker_id: "projects-local-current",
+        worker_label: "Current Git project"
+      }
+    };
+    successfulPostStartWriteCount = await addStatusWriteResult(
+      successfulPostStartWriteCount,
+      reportOnboardingDiscoveryStatus(options, log, failedReport)
+    );
+    log("onboarding.local_project_discovery_failed", {
+      runnerId: options.runnerId,
+      workspace: workspaceSlug,
+      message
+    });
+    return withSuccessfulWriteCount(
+      failedReport,
+      successfulPostStartWriteCount
+    );
+  }
+}
+function shouldStartOnboardingDiscoveryAgents(options, workspaceSlug = runnerWorkspaceSlug(options)) {
+  return workspaceSlug !== void 0 && options.threadProcess === void 0 && options.onboardingDiscovery === "start";
+}
+async function reportOnboardingDiscoveryStatus(options, log, args) {
+  const workspaceSlug = runnerWorkspaceSlug(options);
+  if (workspaceSlug === void 0) {
+    return false;
+  }
+  const client = createLinzumiMcpApiClient({
+    kandanUrl: options.kandanUrl,
+    accessToken: options.token,
+    fetchImpl: options.fetch,
+    operatingMode: "text"
+  });
+  const payload = {
+    workspace: workspaceSlug,
+    runner_id: options.runnerId,
+    phase: args.phase,
+    status: args.status,
+    places_searched: args.placesSearched,
+    message: args.message,
+    ...args.currentPlace === void 0 || args.currentPlace === "" ? {} : { current_place: args.currentPlace },
+    ...args.currentSource === void 0 || args.currentSource === "" ? {} : { current_source: args.currentSource },
+    ...args.lastError === void 0 || args.lastError === "" ? {} : { last_error: args.lastError },
+    ...args.metadata === void 0 ? {} : { metadata: args.metadata }
+  };
+  log("onboarding.discovery_status", payload);
+  try {
+    await client.noteOnboardingDiscoveryStatus(payload);
+    return true;
+  } catch (error) {
+    log("onboarding.discovery_status_failed", {
+      phase: args.phase,
+      status: args.status,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+function onboardingDiscoveryAgentStartKey(options, workspaceSlug) {
+  return `${options.kandanUrl}\0${workspaceSlug}\0${options.runnerId}`;
+}
 async function startOwnedCodexAppServer(options, args = { linzumiMcp: true }) {
   ensureCodexProjectTrusted(options.cwd);
   const defaults = runnerRuntimeDefaults(options);
@@ -21636,9 +24100,9 @@ function mcpOwnerUsername(options) {
   return options.channelSession?.listenUser ?? identityFromAccessToken(options.token).actorUsername;
 }
 function writeEphemeralMcpAuthFile(options) {
-  const directory = mkdtempSync4(join14(tmpdir3(), "linzumi-mcp-auth-"));
+  const directory = mkdtempSync4(join17(tmpdir3(), "linzumi-mcp-auth-"));
   chmodSync2(directory, 448);
-  const path2 = join14(directory, "auth.json");
+  const path2 = join17(directory, "auth.json");
   writeCachedLocalRunnerToken({
     kandanUrl: options.kandanUrl,
     accessToken: options.token,
@@ -21714,7 +24178,7 @@ function configuredAllowedCwds(values, options = {}) {
     const absolutePath = resolve7(expandUserPath(value));
     try {
       if (options.createMissing === true) {
-        mkdirSync9(absolutePath, { recursive: true });
+        mkdirSync10(absolutePath, { recursive: true });
       }
       const realPath = realpathSync6(absolutePath);
       allowedCwds.push(
@@ -21751,9 +24215,9 @@ function allowedCwdProjects(allowedCwds) {
   });
 }
 function isGitProjectDirectory(cwd) {
-  const gitPath = join14(cwd, ".git");
+  const gitPath = join17(cwd, ".git");
   try {
-    const gitPathStats = statSync(gitPath);
+    const gitPathStats = statSync3(gitPath);
     return gitPathStats.isDirectory() || gitPathStats.isFile();
   } catch {
     return false;
@@ -21764,7 +24228,7 @@ function browseRunnerDirectory(control, options) {
   const requestedPath = stringValue(control.path) ?? currentHomeDirectory();
   try {
     const currentPath = realpathSync6(resolve7(expandUserPath(requestedPath)));
-    const stats = statSync(currentPath);
+    const stats = statSync3(currentPath);
     if (!stats.isDirectory()) {
       return {
         instanceId: options.runnerId,
@@ -21774,9 +24238,9 @@ function browseRunnerDirectory(control, options) {
         error: "not_directory"
       };
     }
-    const parent = dirname10(currentPath);
-    const entries = readdirSync2(currentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => visibleRunnerDirectoryEntryName(entry.name)).map((entry) => {
-      const path2 = join14(currentPath, entry.name);
+    const parent = dirname12(currentPath);
+    const entries = readdirSync4(currentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => visibleRunnerDirectoryEntryName(entry.name)).map((entry) => {
+      const path2 = join17(currentPath, entry.name);
       return {
         name: entry.name,
         path: path2,
@@ -21817,7 +24281,7 @@ function projectDirectoryName(name) {
 function availableProjectDirectoryName(projectsRoot, baseName, suffix = 0) {
   for (let nextSuffix = suffix; ; nextSuffix += 1) {
     const candidate = nextSuffix === 0 ? baseName : `${baseName}-${nextSuffix}`;
-    if (!projectPathExists(join14(projectsRoot, candidate))) {
+    if (!projectPathExists(join17(projectsRoot, candidate))) {
       return candidate;
     }
   }
@@ -21845,9 +24309,9 @@ function createRunnerProject(control, options, allowedCwds) {
       error: "invalid_project_template"
     };
   }
-  const projectsRoot = join14(currentHomeDirectory(), "linzumi");
+  const projectsRoot = join17(currentHomeDirectory(), "linzumi");
   const resolvedProjectDirName = template === "hello_linzumi_demo" ? availableProjectDirectoryName(projectsRoot, projectDirName) : projectDirName;
-  const projectPath = join14(projectsRoot, resolvedProjectDirName);
+  const projectPath = join17(projectsRoot, resolvedProjectDirName);
   let createdProjectPath = false;
   try {
     if (template !== "hello_linzumi_demo" && projectPathExists(projectPath)) {
@@ -21859,7 +24323,7 @@ function createRunnerProject(control, options, allowedCwds) {
         error: "project_directory_exists"
       };
     }
-    mkdirSync9(projectsRoot, { recursive: true });
+    mkdirSync10(projectsRoot, { recursive: true });
     if (template === "hello_linzumi_demo") {
       createdProjectPath = true;
       createHelloLinzumiProject({
@@ -21867,10 +24331,10 @@ function createRunnerProject(control, options, allowedCwds) {
         name: resolvedProjectDirName
       });
     } else {
-      mkdirSync9(projectPath, { recursive: false });
+      mkdirSync10(projectPath, { recursive: false });
       createdProjectPath = true;
     }
-    const git = spawnSync4("git", ["init"], {
+    const git = spawnSync5("git", ["init"], {
       cwd: projectPath,
       encoding: "utf8",
       env: process.env
@@ -21978,7 +24442,7 @@ async function suggestRunnerTasks(control, options, allowedCwds) {
     };
   }
 }
-var THREAD_RUNNER_READY_TIMEOUT_MS, claudeSessionStoreSequenceHighWater, ClaudeCodeOutputPostError;
+var THREAD_RUNNER_READY_TIMEOUT_MS, onboardingDiscoveryAgentStartKeys, onboardingConversationImportKeys, onboardingConversationDiscoveryReportLimit, claudeSessionStoreSequenceHighWater, ClaudeCodeOutputPostError, onboardingConversationTitleFirstMessages, onboardingConversationTitleLastMessages, onboardingConversationTitleBodyMaxLength, onboardingConversationImportMessageMaxLength, onboardingConversationImportCandidateLimit, onboardingConversationImportProgressInterval;
 var init_runner = __esm({
   "src/runner.ts"() {
     "use strict";
@@ -22009,13 +24473,20 @@ var init_runner = __esm({
     init_runnerConsoleReporter();
     init_streamDeltaQueue();
     init_version();
+    init_telemetry();
     init_mcpConfig();
+    init_linzumiApiClient();
+    init_onboardingConversationDiscovery();
+    init_onboardingProjectDiscovery();
     init_authCache();
     init_threadCodexWorkerIpc();
     init_signupTaskSuggestions();
     init_userFacingErrors();
     init_remoteCodexSandboxRunner();
     THREAD_RUNNER_READY_TIMEOUT_MS = 3e4;
+    onboardingDiscoveryAgentStartKeys = /* @__PURE__ */ new Set();
+    onboardingConversationImportKeys = /* @__PURE__ */ new Set();
+    onboardingConversationDiscoveryReportLimit = 100;
     claudeSessionStoreSequenceHighWater = /* @__PURE__ */ new Map();
     ClaudeCodeOutputPostError = class extends Error {
       constructor(cause) {
@@ -22024,11 +24495,17 @@ var init_runner = __esm({
         this.name = "ClaudeCodeOutputPostError";
       }
     };
+    onboardingConversationTitleFirstMessages = 4;
+    onboardingConversationTitleLastMessages = 4;
+    onboardingConversationTitleBodyMaxLength = 1200;
+    onboardingConversationImportMessageMaxLength = 15500;
+    onboardingConversationImportCandidateLimit = 500;
+    onboardingConversationImportProgressInterval = 25;
   }
 });
 
 // src/kandanTls.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
 import { Agent } from "undici";
 import WsWebSocket from "ws";
 function kandanTlsTrustFromEnv() {
@@ -22039,10 +24516,10 @@ function kandanTlsTrustFromCaFile(caFile) {
     return void 0;
   }
   const trimmed = caFile.trim();
-  if (!existsSync10(trimmed)) {
+  if (!existsSync12(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync11(trimmed, "utf8");
+  const ca = readFileSync14(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -40825,11 +43302,11 @@ var init_RemoveFileError = __esm({
 });
 
 // ../../node_modules/@inquirer/external-editor/dist/esm/index.js
-import { spawn as spawn10, spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync14, unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "fs";
+import { spawn as spawn10, spawnSync as spawnSync6 } from "child_process";
+import { readFileSync as readFileSync17, unlinkSync as unlinkSync3, writeFileSync as writeFileSync11 } from "fs";
 import path from "node:path";
 import os from "node:os";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function editAsync(text2 = "", callback, fileOptions) {
   const editor = new ExternalEditor(text2, fileOptions);
   editor.runAsync((err, result) => {
@@ -40929,7 +43406,7 @@ var init_esm5 = __esm({
       createTemporaryFile() {
         try {
           const baseDir = this.fileOptions.dir ?? os.tmpdir();
-          const id = randomUUID4();
+          const id = randomUUID5();
           const prefix = sanitizeAffix(this.fileOptions.prefix);
           const postfix = sanitizeAffix(this.fileOptions.postfix);
           const filename = `${prefix}${id}${postfix}`;
@@ -40943,14 +43420,14 @@ var init_esm5 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          writeFileSync10(this.tempFile, this.text, opt);
+          writeFileSync11(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = readFileSync14(this.tempFile);
+          const tempFileBuffer = readFileSync17(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -40973,7 +43450,7 @@ var init_esm5 = __esm({
       }
       launchEditor() {
         try {
-          const editorProcess = spawnSync5(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = spawnSync6(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           this.lastExitStatus = editorProcess.status ?? 0;
         } catch (launchError) {
           throw new LaunchEditorError(launchError);
@@ -42315,21 +44792,21 @@ __export(signupFlow_exports, {
   signupTaskSuggestionWaitMessageForTest: () => signupTaskSuggestionWaitMessageForTest,
   toggleProjectPickerSelectionForTest: () => toggleProjectPickerSelectionForTest
 });
-import { spawn as spawn11, spawnSync as spawnSync6 } from "node:child_process";
+import { spawn as spawn11, spawnSync as spawnSync7 } from "node:child_process";
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync15,
   constants as fsConstants,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync15,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync5,
   rmSync as rmSync5,
-  statSync as statSync2,
-  writeFileSync as writeFileSync11
+  statSync as statSync4,
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { access } from "node:fs/promises";
-import { homedir as homedir12, tmpdir as tmpdir4 } from "node:os";
-import { delimiter as delimiter3, dirname as dirname13, join as join17, resolve as resolve9 } from "node:path";
+import { homedir as homedir14, tmpdir as tmpdir4 } from "node:os";
+import { delimiter as delimiter3, dirname as dirname15, join as join20, resolve as resolve9 } from "node:path";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 import { emitKeypressEvents } from "node:readline";
 function signupHelpText() {
@@ -42445,12 +44922,12 @@ function defaultSignupDraftStore(serviceUrl) {
   const path2 = defaultSignupDraftPath(serviceUrl);
   return {
     read: () => {
-      if (!existsSync13(path2)) {
+      if (!existsSync15(path2)) {
         return void 0;
       }
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync15(path2, "utf8"));
+        parsed = JSON.parse(readFileSync18(path2, "utf8"));
       } catch (_error) {
         return void 0;
       }
@@ -42460,8 +44937,8 @@ function defaultSignupDraftStore(serviceUrl) {
       return comparableServiceUrl(parsed.serviceUrl) === comparableServiceUrl(serviceUrl) ? parsed : void 0;
     },
     write: (draft) => {
-      mkdirSync12(dirname13(path2), { recursive: true });
-      writeFileSync11(path2, `${JSON.stringify(draft, null, 2)}
+      mkdirSync13(dirname15(path2), { recursive: true });
+      writeFileSync12(path2, `${JSON.stringify(draft, null, 2)}
 `, {
         encoding: "utf8",
         mode: 384
@@ -42473,8 +44950,8 @@ function defaultSignupDraftStore(serviceUrl) {
   };
 }
 function defaultSignupDraftPath(serviceUrl) {
-  return join17(
-    dirname13(localConfigPath()),
+  return join20(
+    dirname15(localConfigPath()),
     `signup-draft.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
@@ -42508,8 +44985,8 @@ function defaultSignupTaskCacheStore(serviceUrl) {
           }
         }
       };
-      mkdirSync12(dirname13(path2), { recursive: true });
-      writeFileSync11(path2, `${JSON.stringify(next, null, 2)}
+      mkdirSync13(dirname15(path2), { recursive: true });
+      writeFileSync12(path2, `${JSON.stringify(next, null, 2)}
 `, {
         encoding: "utf8",
         mode: 384
@@ -42518,18 +44995,18 @@ function defaultSignupTaskCacheStore(serviceUrl) {
   };
 }
 function defaultSignupTaskCachePath(serviceUrl) {
-  return join17(
-    dirname13(localConfigPath()),
+  return join20(
+    dirname15(localConfigPath()),
     `signup-task-cache.${localConfigScopeFileStem(serviceUrl)}.json`
   );
 }
 function readSignupTaskCache(path2) {
-  if (!existsSync13(path2)) {
+  if (!existsSync15(path2)) {
     return { version: 1, entries: {} };
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path2, "utf8"));
+    parsed = JSON.parse(readFileSync18(path2, "utf8"));
   } catch (_error) {
     return { version: 1, entries: {} };
   }
@@ -43715,6 +46192,7 @@ async function signupCommanderRunnerOptions(args, runnerId) {
     editorRuntime: editorRuntime.runtime,
     socketFactory: trustedWebSocketFactory(trust),
     dependencyStatus,
+    onboardingDiscovery: "start",
     runtimeDefaults: {
       model: void 0,
       reasoningEffort: void 0,
@@ -44413,7 +46891,7 @@ function autocompletePathSuggestions(pathInput) {
   try {
     const showHidden = prefix.startsWith(".");
     const currentPath = directoryExists(normalizedInput) ? [normalizedInput.replace(/\/$/, "") || "/"] : [];
-    const childPaths = readdirSync3(directoryPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => showHidden || !entry.name.startsWith(".")).map((entry) => join17(directoryPath, entry.name)).map((path2) => ({
+    const childPaths = readdirSync5(directoryPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => showHidden || !entry.name.startsWith(".")).map((entry) => join20(directoryPath, entry.name)).map((path2) => ({
       path: path2,
       score: fuzzyPathSegmentScore(path2.split("/").at(-1) ?? path2, prefix)
     })).filter((candidate) => candidate.score !== void 0).sort((left, right) => {
@@ -44659,7 +47137,7 @@ async function runSignupPreflights(runtime) {
 function defaultPreflightRuntime() {
   return {
     cwd: process.cwd(),
-    homeDir: homedir12(),
+    homeDir: homedir14(),
     probeTool,
     readGitEmail,
     discoverCodeRoots,
@@ -44804,13 +47282,13 @@ async function suggestTasksWithCodex(projectPath, retryPolicy) {
   );
 }
 async function runCodexTaskSuggestion2(projectPath, previousResponse, retryPolicy) {
-  const tempRoot = mkdtempSync5(join17(tmpdir4(), "linzumi-signup-codex-tasks-"));
-  const schemaPath = join17(tempRoot, "task-suggestions.schema.json");
-  const outputPath = join17(tempRoot, "task-suggestions.json");
+  const tempRoot = mkdtempSync5(join20(tmpdir4(), "linzumi-signup-codex-tasks-"));
+  const schemaPath = join20(tempRoot, "task-suggestions.schema.json");
+  const outputPath = join20(tempRoot, "task-suggestions.json");
   const model = process.env.LINZUMI_SIGNUP_TASK_MODEL ?? "gpt-5.4-mini";
   const prompt = taskSuggestionPrompt2(previousResponse);
   const codexCommand = await resolveSignupCodexCommand();
-  writeFileSync11(
+  writeFileSync12(
     schemaPath,
     `${JSON.stringify(taskSuggestionJsonSchema2(), null, 2)}
 `,
@@ -44831,7 +47309,7 @@ async function runCodexTaskSuggestion2(projectPath, previousResponse, retryPolic
       ),
       retryPolicy
     );
-    return readFileSync15(outputPath, "utf8");
+    return readFileSync18(outputPath, "utf8");
   } finally {
     rmSync5(tempRoot, { recursive: true, force: true });
   }
@@ -44868,7 +47346,7 @@ function codexTaskSuggestionProcess2(args) {
 function signupCodexTaskSuggestionProcessForTest(args) {
   return codexTaskSuggestionProcess2(args);
 }
-async function resolveSignupCodexCommand(env = process.env, homeDir = homedir12(), executableExists = fileIsExecutable) {
+async function resolveSignupCodexCommand(env = process.env, homeDir = homedir14(), executableExists = fileIsExecutable) {
   const override = firstConfiguredValue([
     env.LINZUMI_SIGNUP_CODEX_BIN,
     env.LINZUMI_CODEX_BIN
@@ -44923,7 +47401,7 @@ function resolveHomePath(path2, homeDir) {
     return homeDir;
   }
   if (path2.startsWith("~/")) {
-    return join17(homeDir, path2.slice(2));
+    return join20(homeDir, path2.slice(2));
   }
   return resolve9(path2);
 }
@@ -44936,9 +47414,9 @@ function commandLooksPathLike(command) {
 }
 function homeManagedCodexCandidates(homeDir) {
   return [
-    join17(homeDir, ".volta", "bin", "codex"),
-    join17(homeDir, ".local", "bin", "codex"),
-    join17(homeDir, "bin", "codex")
+    join20(homeDir, ".volta", "bin", "codex"),
+    join20(homeDir, ".local", "bin", "codex"),
+    join20(homeDir, "bin", "codex")
   ];
 }
 async function firstExecutablePath(paths, executableExists) {
@@ -44953,7 +47431,7 @@ function commandPathCandidates(path2) {
   if (path2 === void 0 || path2.trim() === "") {
     return [];
   }
-  return path2.split(delimiter3).filter((entry) => entry.trim() !== "").map((entry) => join17(entry, "codex"));
+  return path2.split(delimiter3).filter((entry) => entry.trim() !== "").map((entry) => join20(entry, "codex"));
 }
 async function fileIsExecutable(path2) {
   try {
@@ -44978,6 +47456,14 @@ function taskSuggestionPrompt2(previousResponse) {
     "Task:",
     "Inspect this repository read-only and suggest exactly 5 useful quick starter tasks for Codex agents.",
     "",
+    "GitHub context:",
+    "- First check whether the GitHub CLI is available and authenticated with a cheap command such as `gh auth status`.",
+    "- If `gh` is missing, unauthenticated, or this repository has no GitHub remote, skip GitHub context and rely on local files.",
+    "- When `gh` is authenticated, use bounded reads such as `gh pr list --limit 30 --state all` and `gh issue list --limit 30 --state all` to inspect recent open and closed pull requests and issues.",
+    "- Be mindful of GitHub rate limits, CPU usage, and network usage; prefer one or two small calls and do not paginate or crawl exhaustively.",
+    "- If a GitHub call returns unauthorized, forbidden, or not found for this repository, stop GitHub lookups for this repository.",
+    "- Use pull request and issue titles, states, labels, and recent activity to infer what the repo is about, what the user has been working on, and likely next tasks.",
+    "",
     "Constraints:",
     "- Prefer tasks that are small, concrete, and likely to produce useful first results.",
     "- Do not modify files.",
@@ -45178,11 +47664,11 @@ function codexPreflightLocation(command, homeDir) {
   switch (command) {
     case "codex":
       return "on PATH";
-    case join17(homeDir, ".volta", "bin", "codex"):
+    case join20(homeDir, ".volta", "bin", "codex"):
       return "via Volta";
-    case join17(homeDir, ".local", "bin", "codex"):
+    case join20(homeDir, ".local", "bin", "codex"):
       return "via ~/.local/bin";
-    case join17(homeDir, "bin", "codex"):
+    case join20(homeDir, "bin", "codex"):
       return "via ~/bin";
     default:
       return "from configured path";
@@ -45287,7 +47773,7 @@ function spawnSyncGit(args, cwd) {
 }
 function spawnSyncGitOutput(args, cwd) {
   try {
-    const result = spawnSync6("git", [...args], {
+    const result = spawnSync7("git", [...args], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -45337,13 +47823,13 @@ function probeToolWithArgs(command, args, cwd) {
 }
 async function discoverCodeRoots(homeDir) {
   const candidates = ["src", "code", "projects"].map(
-    (name) => join17(homeDir, name)
+    (name) => join20(homeDir, name)
   );
-  return candidates.filter((path2) => existsSync13(path2)).flatMap((path2) => discoveredProjectNames(path2));
+  return candidates.filter((path2) => existsSync15(path2)).flatMap((path2) => discoveredProjectNames(path2));
 }
 function discoveredProjectNames(root) {
   try {
-    return readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, 3).map((entry) => `~/${root.split("/").at(-1)}/${entry.name}`);
+    return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, 3).map((entry) => `~/${root.split("/").at(-1)}/${entry.name}`);
   } catch {
     return [];
   }
@@ -45391,7 +47877,7 @@ function discoverProjectsFromCurrentDirectory(cwd) {
 }
 function discoverProjectsFromGuessedRoots(homeDir) {
   const guessedRoots = ["src", "code", "projects"].map(
-    (name) => join17(homeDir, name)
+    (name) => join20(homeDir, name)
   );
   const projects = guessedRoots.flatMap(
     (root) => discoverProjectsUnderRoot(root)
@@ -45443,25 +47929,25 @@ function looksLikeProject(path2) {
     "pnpm-lock.yaml",
     "yarn.lock",
     "package-lock.json"
-  ].some((name) => existsSync13(join17(path2, name)));
+  ].some((name) => existsSync15(join20(path2, name)));
 }
 function detectProjectLanguage(path2) {
-  if (existsSync13(join17(path2, "pyproject.toml")) || existsSync13(join17(path2, "requirements.txt"))) {
+  if (existsSync15(join20(path2, "pyproject.toml")) || existsSync15(join20(path2, "requirements.txt"))) {
     return "Python";
   }
-  if (existsSync13(join17(path2, "Cargo.toml"))) {
+  if (existsSync15(join20(path2, "Cargo.toml"))) {
     return "Rust";
   }
-  if (existsSync13(join17(path2, "go.mod"))) {
+  if (existsSync15(join20(path2, "go.mod"))) {
     return "Go";
   }
-  if (existsSync13(join17(path2, "mix.exs"))) {
+  if (existsSync15(join20(path2, "mix.exs"))) {
     return "Elixir";
   }
-  if (existsSync13(join17(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
+  if (existsSync15(join20(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
     return "TypeScript";
   }
-  if (existsSync13(join17(path2, "package.json"))) {
+  if (existsSync15(join20(path2, "package.json"))) {
     return "JavaScript";
   }
   return "Project";
@@ -45469,7 +47955,7 @@ function detectProjectLanguage(path2) {
 function packageJsonMentionsTypeScript(path2) {
   try {
     const packageJson2 = JSON.parse(
-      readFileSync15(join17(path2, "package.json"), "utf8")
+      readFileSync18(join20(path2, "package.json"), "utf8")
     );
     return packageJson2.dependencies?.typescript !== void 0 || packageJson2.devDependencies?.typescript !== void 0;
   } catch {
@@ -45477,11 +47963,11 @@ function packageJsonMentionsTypeScript(path2) {
   }
 }
 function hasGitMetadata(path2) {
-  return existsSync13(join17(path2, ".git"));
+  return existsSync15(join20(path2, ".git"));
 }
 function childDirectories(root) {
   try {
-    return readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join17(root, entry.name));
+    return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join20(root, entry.name));
   } catch {
     return [];
   }
@@ -45500,17 +47986,17 @@ function ignoredProjectDirectory(path2) {
 }
 function directoryExists(path2) {
   try {
-    return statSync2(path2).isDirectory();
+    return statSync4(path2).isDirectory();
   } catch {
     return false;
   }
 }
 function expandHomePath(path2) {
   if (path2 === "~") {
-    return homedir12();
+    return homedir14();
   }
   if (path2.startsWith("~/")) {
-    return join17(homedir12(), path2.slice(2));
+    return join20(homedir14(), path2.slice(2));
   }
   return resolve9(path2);
 }
@@ -45599,8 +48085,8 @@ secure mission control for all your agents on your computers
 init_runner();
 init_claudeCodeSession();
 init_authCache();
-import { existsSync as existsSync14, readFileSync as readFileSync16, realpathSync as realpathSync7 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
+import { existsSync as existsSync16, readFileSync as readFileSync19, realpathSync as realpathSync7 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
 import { resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
@@ -45621,7 +48107,8 @@ async function resolveLocalRunnerToken(args, deps = {
       kandanUrl: args.kandanUrl,
       accessToken: cached.accessToken,
       workspaceSlug: args.workspaceSlug,
-      channelSlug: args.channelSlug
+      channelSlug: args.channelSlug,
+      requiredScopes: args.requiredScopes
     });
     if (cachedTokenIsUsable) {
       return cached.accessToken;
@@ -45661,9 +48148,9 @@ init_kandanTls();
 init_protocol();
 init_json();
 init_defaultUrls();
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname11, join as join15 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname13, join as join18 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 async function runAgentCliCommand(args, deps = {
   fetchImpl: fetch,
   stdout: process.stdout,
@@ -46371,7 +48858,7 @@ function agentTokenFile(flags) {
   return flags.get("agent-token-file") ?? defaultAgentTokenFilePath();
 }
 function defaultAgentTokenFilePath() {
-  return join15(homedir10(), ".linzumi", "agent-token.json");
+  return join18(homedir12(), ".linzumi", "agent-token.json");
 }
 function normalizedApiUrl(apiUrl) {
   return apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`;
@@ -46380,11 +48867,11 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path2) {
-  return existsSync11(path2) ? readFileSync12(path2, "utf8") : void 0;
+  return existsSync13(path2) ? readFileSync15(path2, "utf8") : void 0;
 }
 function writeTextFile(path2, content) {
-  mkdirSync10(dirname11(path2), { recursive: true });
-  writeFileSync8(path2, content);
+  mkdirSync11(dirname13(path2), { recursive: true });
+  writeFileSync9(path2, content);
 }
 function readStoredAgentTokenFile(path2, readTextFile = readOptionalTextFile) {
   const content = readTextFile(path2);
@@ -46471,27 +48958,27 @@ init_helloLinzumiProject();
 // src/commanderDaemon.ts
 init_runnerLogger();
 import {
-  existsSync as existsSync12,
-  closeSync as closeSync2,
-  mkdirSync as mkdirSync11,
-  openSync as openSync3,
-  readFileSync as readFileSync13,
+  existsSync as existsSync14,
+  closeSync as closeSync3,
+  mkdirSync as mkdirSync12,
+  openSync as openSync4,
+  readFileSync as readFileSync16,
   watch,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname12, join as join16, resolve as resolve8 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname14, join as join19, resolve as resolve8 } from "node:path";
 import { execFileSync, spawn as spawn9 } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var connectedMarkers = ["Connected to Linzumi", "Runner connected:"];
 function commanderStatusDir() {
-  return join16(homedir11(), ".linzumi", "commanders");
+  return join19(homedir13(), ".linzumi", "commanders");
 }
 function commanderStatusFile(runnerId, statusDir = commanderStatusDir()) {
-  return join16(statusDir, `${safeRunnerId(runnerId)}.json`);
+  return join19(statusDir, `${safeRunnerId(runnerId)}.json`);
 }
 function defaultCommanderLogFile(runnerId) {
-  return join16(homedir11(), ".linzumi", "logs", `${safeRunnerId(runnerId)}.log`);
+  return join19(homedir13(), ".linzumi", "logs", `${safeRunnerId(runnerId)}.log`);
 }
 function commanderLogIsConnected(log) {
   return connectedMarkers.some((marker) => log.includes(marker));
@@ -46512,10 +48999,10 @@ function startCommanderDaemon(options) {
     "--log-file",
     logFile
   ];
-  mkdirSync11(statusDir, { recursive: true });
-  mkdirSync11(dirname12(logFile), { recursive: true });
-  const out = openSync3(logFile, "a");
-  const err = openSync3(logFile, "a");
+  mkdirSync12(statusDir, { recursive: true });
+  mkdirSync12(dirname14(logFile), { recursive: true });
+  const out = openSync4(logFile, "a");
+  const err = openSync4(logFile, "a");
   writeCliAuditEvent(
     "process.spawn",
     {
@@ -46542,8 +49029,8 @@ function startCommanderDaemon(options) {
     },
     { sessionId: options.runnerId }
   );
-  closeSync2(out);
-  closeSync2(err);
+  closeSync3(out);
+  closeSync3(err);
   child.unref();
   if (child.pid === void 0) {
     throw new Error("commander daemon did not report a pid");
@@ -46559,21 +49046,21 @@ function startCommanderDaemon(options) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     command: [nodeBin, ...command]
   };
-  writeFileSync9(statusFile, `${JSON.stringify(record, null, 2)}
+  writeFileSync10(statusFile, `${JSON.stringify(record, null, 2)}
 `);
   return record;
 }
 function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), processIdentityReader = readProcessIdentity) {
   const statusFile = commanderStatusFile(runnerId, statusDir);
-  if (!existsSync12(statusFile)) {
+  if (!existsSync14(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
-  const record = parseRecord(readFileSync13(statusFile, "utf8"));
+  const record = parseRecord(readFileSync16(statusFile, "utf8"));
   return processIsRunning(record.pid) && processMatchesRecord(record, processIdentityReader) ? { status: "running", record } : { status: "stopped", record };
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path2) => existsSync12(path2) ? readFileSync13(path2, "utf8") : void 0);
+  const readTextFile = options.readTextFile ?? ((path2) => existsSync14(path2) ? readFileSync16(path2, "utf8") : void 0);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -46772,6 +49259,7 @@ async function waitForFileChangeOrTimeout(path2, deadline, now, ready2 = () => f
 
 // src/index.ts
 init_version();
+init_telemetry();
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -54437,7 +56925,7 @@ var StdioServerTransport = class {
 };
 
 // src/mcpServer.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 
 // node_modules/zod/v3/external.js
 var external_exports2 = {};
@@ -58484,78 +60972,19 @@ var NEVER2 = INVALID2;
 init_authCache();
 init_commanderAttachments();
 init_json();
-
-// src/linzumiApiClient.ts
-init_oauth();
-init_protocol();
-function createLinzumiMcpApiClient(options) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const baseUrl = kandanHttpBaseUrl(options.kandanUrl);
-  const apiPrefix = options.authMode === "personal-agent-delegation" ? "/api/v2/personal-agent-mcp" : "/api/v2/local-runner-mcp";
-  const operatingMode = options.operatingMode ?? "text";
-  const request = async (method, path2, params) => {
-    const url = new URL(path2, baseUrl);
-    const paramsWithMode = {
-      ...params,
-      operating_mode: operatingMode
-    };
-    const requestInit = {
-      method,
-      headers: { authorization: `Bearer ${options.accessToken}` }
-    };
-    if (method === "GET") {
-      for (const [key, value] of Object.entries(paramsWithMode)) {
-        if (value !== void 0 && value !== null) {
-          url.searchParams.set(key, String(value));
-        }
-      }
-    } else {
-      requestInit.headers = {
-        ...requestInit.headers,
-        "content-type": "application/json"
-      };
-      requestInit.body = JSON.stringify(paramsWithMode);
-    }
-    const response = await fetchImpl(url, requestInit);
-    const parsed = await response.json();
-    const body = isJsonObject(parsed) ? parsed : void 0;
-    if (body === void 0) {
-      throw new Error(`Linzumi MCP API returned non-object JSON from ${path2}`);
-    }
-    if (response.ok && body.ok === true) {
-      return body;
-    }
-    const error = typeof body.error === "string" ? body.error : `HTTP ${response.status}`;
-    throw new Error(`Linzumi MCP API ${path2} failed: ${error}`);
-  };
-  return {
-    validateAuth: () => request("GET", `${apiPrefix}/validate`, {}),
-    getMessage: (params) => request("GET", `${apiPrefix}/message`, params),
-    getThread: (params) => request("GET", `${apiPrefix}/thread`, params),
-    getChannel: (params) => request("GET", `${apiPrefix}/channel`, params),
-    getCodingJobMetadata: (params) => request("GET", `${apiPrefix}/coding-job-metadata`, params),
-    upsertCodingJobPlan: (params) => request("POST", `${apiPrefix}/coding-job-plan`, params),
-    replaceCodingJobPlanSteps: (params) => request("POST", `${apiPrefix}/coding-job-plan/steps`, params),
-    updateCodingJobPlanStep: (params) => request("POST", `${apiPrefix}/coding-job-plan/step`, params),
-    linkCodingJobPullRequest: (params) => request("POST", `${apiPrefix}/coding-job-primary-pr`, params),
-    listVaultSecrets: (params) => request("GET", `${apiPrefix}/vault-secrets`, params),
-    sendChannelMessage: (params) => request("POST", `${apiPrefix}/channel-message`, params),
-    prepareMessageUploads: (params) => request("POST", `${apiPrefix}/message-uploads/prepare`, params),
-    attachMessageFiles: (params) => request("POST", `${apiPrefix}/message-files/attach`, params),
-    prepareCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/prepare`, params),
-    renameCustomEmoji: (params) => request("POST", `${apiPrefix}/custom-emoji/rename`, params),
-    sendThreadReply: (params) => request("POST", `${apiPrefix}/thread-reply`, params),
-    sendDm: (params) => request("POST", `${apiPrefix}/dm`, params),
-    dmOwner: (params) => request("POST", `${apiPrefix}/dm-owner`, params),
-    getVaultValues: (params) => request("POST", `${apiPrefix}/vault-values`, params)
-  };
-}
-
-// src/mcpServer.ts
+init_linzumiApiClient();
 init_mcpConfig();
 init_oauth();
 init_protocol();
 var maxCustomEmojiNameLength = 64;
+function customEmojiMcpToolsEnabledForScope(toolScope) {
+  switch (toolScope) {
+    case "all":
+      return true;
+    case "onboarding-discovery":
+      return false;
+  }
+}
 function normalizeCustomEmojiNameForSchema(value) {
   return value.trim().replace(/^:+/, "").replace(/:+$/, "").toLowerCase();
 }
@@ -58578,6 +61007,7 @@ var mcpFlagDefinitions = /* @__PURE__ */ new Map([
   ["thread-id", { kind: "value" }],
   ["format", { kind: "value" }],
   ["command", { kind: "value" }],
+  ["tool-scope", { kind: "value" }],
   ["include-token", { kind: "boolean" }],
   ["help", { kind: "boolean" }]
 ]);
@@ -58617,6 +61047,8 @@ Tools:
   linzumi_get_channel   Read bounded recent messages and channel metadata.
   linzumi_get_coding_job_metadata
                         Read the current coding job goal, plan, and workflow metadata.
+  linzumi_rename_coding_job
+                        Update the coding job thread and workflow-facing title.
   linzumi_upsert_coding_job_plan
                         Set or update the coding job goal.
   linzumi_replace_coding_job_plan_steps
@@ -58627,6 +61059,12 @@ Tools:
                         Link the coding job to its primary GitHub pull request.
   linzumi_list_vault_secrets
                         List vault secret names, descriptions, and owner scope.
+  linzumi_note_project_directory
+                        Record one discovered local Git project directory.
+  linzumi_note_agent_conversation
+                        Record one discovered Codex or Claude Code conversation.
+  linzumi_note_onboarding_discovery_status
+                        Record onboarding discovery progress or failure.
   linzumi_send_channel_message
                         Send a plain-text message to the scoped channel.
   linzumi_send_thread_reply
@@ -58662,6 +61100,7 @@ async function runMcpServer(args) {
   });
   const ownerUsername = stringValue5(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME;
   const operatingMode = mcpOperatingMode(stringValue5(values, "mode"));
+  const toolScope = mcpToolScope(stringValue5(values, "tool-scope"));
   const cwd = stringValue5(values, "cwd") ?? process.cwd();
   const defaultThreadId = stringValue5(values, "thread-id") ?? process.env.LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID;
   const client = createLinzumiMcpApiClient({
@@ -58675,318 +61114,447 @@ async function runMcpServer(args) {
     version: "0.1.0"
   });
   registerEmptyMcpResources(server);
-  server.tool(
-    "linzumi_get_message",
-    "Read one Linzumi message by scoped message_seq/message_id or a Linzumi message URL, with optional bounded before/after context.",
-    {
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
-      message_id: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Message seq inside the scoped channel."),
-      message_seq: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Alias for message_id."),
-      message_url: external_exports2.string().optional().describe("Full Linzumi message URL with #message-<seq>."),
-      before: external_exports2.number().int().min(0).max(100).optional().describe("Number of visible messages before the target."),
-      after: external_exports2.number().int().min(0).max(100).optional().describe("Number of visible messages after the target.")
-    },
-    async (params) => mcpJsonResult(await client.getMessage(params))
-  );
-  server.tool(
-    "linzumi_get_thread",
-    "Read one Linzumi thread by thread_id in the scoped channel, including the parent message and bounded replies.",
-    {
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
-      thread_id: external_exports2.string().uuid().describe("Linzumi thread UUID."),
-      limit: external_exports2.number().int().min(1).max(100).optional().describe("Maximum replies to return."),
-      before_seq: external_exports2.number().int().positive().optional().describe("Return replies before this channel seq.")
-    },
-    async (params) => mcpJsonResult(await client.getThread(params))
-  );
-  server.tool(
-    "linzumi_get_channel",
-    "Read scoped Linzumi channel metadata and bounded recent channel messages.",
-    {
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
-      limit: external_exports2.number().int().min(1).max(100).optional().describe("Maximum messages to return."),
-      before_seq: external_exports2.number().int().positive().optional().describe("Return messages before this channel seq.")
-    },
-    async (params) => mcpJsonResult(await client.getChannel(params))
-  );
-  server.tool(
-    "linzumi_get_coding_job_metadata",
-    "Read the active coding job workflow metadata for a thread, including the agent-owned goal, ordered plan steps, step lock versions, and workflow status.",
-    {
-      thread_id: external_exports2.string().uuid().optional().describe(
-        "Linzumi thread UUID. Defaults to the active coding job thread."
-      )
-    },
-    async (params) => mcpJsonResult(
-      await client.getCodingJobMetadata(
-        paramsWithDefaultThread(params, defaultThreadId)
+  if (toolScope === "all") {
+    server.tool(
+      "linzumi_get_message",
+      "Read one Linzumi message by scoped message_seq/message_id or a Linzumi message URL, with optional bounded before/after context.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        message_id: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Message seq inside the scoped channel."),
+        message_seq: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Alias for message_id."),
+        message_url: external_exports2.string().optional().describe("Full Linzumi message URL with #message-<seq>."),
+        before: external_exports2.number().int().min(0).max(100).optional().describe("Number of visible messages before the target."),
+        after: external_exports2.number().int().min(0).max(100).optional().describe("Number of visible messages after the target.")
+      },
+      async (params) => mcpJsonResult(await client.getMessage(params))
+    );
+    server.tool(
+      "linzumi_get_thread",
+      "Read one Linzumi thread by thread_id in the scoped channel, including the parent message and bounded replies.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().describe("Linzumi thread UUID."),
+        limit: external_exports2.number().int().min(1).max(100).optional().describe("Maximum replies to return."),
+        before_seq: external_exports2.number().int().positive().optional().describe("Return replies before this channel seq.")
+      },
+      async (params) => mcpJsonResult(await client.getThread(params))
+    );
+    server.tool(
+      "linzumi_get_channel",
+      "Read scoped Linzumi channel metadata and bounded recent channel messages.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        limit: external_exports2.number().int().min(1).max(100).optional().describe("Maximum messages to return."),
+        before_seq: external_exports2.number().int().positive().optional().describe("Return messages before this channel seq.")
+      },
+      async (params) => mcpJsonResult(await client.getChannel(params))
+    );
+    server.tool(
+      "linzumi_get_coding_job_metadata",
+      "Read the active coding job workflow metadata for a thread, including the agent-owned goal, ordered plan steps, step lock versions, and workflow status.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        )
+      },
+      async (params) => mcpJsonResult(
+        await client.getCodingJobMetadata(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    )
-  );
-  server.tool(
-    "linzumi_upsert_coding_job_plan",
-    "Set or update the current coding job goal. Use this at job start and whenever the goal changes materially.",
-    {
-      thread_id: external_exports2.string().uuid().optional().describe(
-        "Linzumi thread UUID. Defaults to the active coding job thread."
-      ),
-      goal: external_exports2.string().min(1).max(1e4).describe("Concrete user-visible goal for this coding job.")
-    },
-    async (params) => mcpJsonResult(
-      await client.upsertCodingJobPlan(
-        paramsWithDefaultThread(params, defaultThreadId)
+    );
+    server.tool(
+      "linzumi_rename_coding_job",
+      "Update the current coding job thread title and workflow-facing title. Use this when the job scope changes materially so the Linzumi thread list and metadata overview stay accurate.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        ),
+        title: external_exports2.string().min(1).max(100).describe("Concise user-visible title for this coding job.")
+      },
+      async (params) => mcpJsonResult(
+        await client.renameCodingJob(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    )
-  );
-  server.tool(
-    "linzumi_replace_coding_job_plan_steps",
-    "Replace the ordered coding job plan steps. Use this for the initial plan and for substantial rewrites when the old plan no longer fits the work.",
-    {
-      thread_id: external_exports2.string().uuid().optional().describe(
-        "Linzumi thread UUID. Defaults to the active coding job thread."
-      ),
-      goal: external_exports2.string().min(1).max(1e4).optional().describe(
-        "Required when no plan exists yet; updates the current coding job goal."
-      ),
-      steps: external_exports2.array(
-        external_exports2.object({
-          title: external_exports2.string().min(1).max(255),
-          description: external_exports2.string().min(1).max(1e4),
-          status: external_exports2.enum([
-            "pending",
-            "active",
-            "completed",
-            "blocked",
-            "canceled"
-          ]),
-          status_note: external_exports2.string().min(1).max(4e3).optional(),
-          completed_debrief: external_exports2.string().min(1).max(2e4).optional()
-        })
-      ).min(1).max(50).describe(
-        "Ordered user-visible plan steps. Completed steps must include completed_debrief."
+    );
+    server.tool(
+      "linzumi_upsert_coding_job_plan",
+      "Set or update the current coding job goal. Use this at job start and whenever the goal changes materially.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        ),
+        goal: external_exports2.string().min(1).max(1e4).describe("Concrete user-visible goal for this coding job.")
+      },
+      async (params) => mcpJsonResult(
+        await client.upsertCodingJobPlan(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    },
-    async (params) => mcpJsonResult(
-      await client.replaceCodingJobPlanSteps(
-        paramsWithDefaultThread(params, defaultThreadId)
+    );
+    server.tool(
+      "linzumi_replace_coding_job_plan_steps",
+      "Replace the ordered coding job plan steps. Use this for the initial plan and for substantial rewrites when the old plan no longer fits the work.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        ),
+        goal: external_exports2.string().min(1).max(1e4).optional().describe(
+          "Required when no plan exists yet; updates the current coding job goal."
+        ),
+        steps: external_exports2.array(
+          external_exports2.object({
+            title: external_exports2.string().min(1).max(255),
+            description: external_exports2.string().min(1).max(1e4),
+            status: external_exports2.enum([
+              "pending",
+              "active",
+              "completed",
+              "blocked",
+              "canceled"
+            ]),
+            status_note: external_exports2.string().min(1).max(4e3).optional(),
+            completed_debrief: external_exports2.string().min(1).max(2e4).optional()
+          })
+        ).min(1).max(50).describe(
+          "Ordered user-visible plan steps. Completed steps must include completed_debrief."
+        )
+      },
+      async (params) => mcpJsonResult(
+        await client.replaceCodingJobPlanSteps(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    )
-  );
-  server.tool(
-    "linzumi_update_coding_job_plan_step",
-    "Update one coding job plan step status or note. Read metadata first and pass the current step lock_version.",
-    {
-      thread_id: external_exports2.string().uuid().optional().describe(
-        "Linzumi thread UUID. Defaults to the active coding job thread."
-      ),
-      step_id: external_exports2.string().uuid().describe("Step id returned by linzumi_get_coding_job_metadata."),
-      lock_version: external_exports2.number().int().positive().describe("Current step lock_version from metadata."),
-      status: external_exports2.enum(["pending", "active", "completed", "blocked", "canceled"]),
-      status_note: external_exports2.string().min(1).max(4e3).optional(),
-      completed_debrief: external_exports2.string().min(1).max(2e4).optional().describe("Required when marking a step completed.")
-    },
-    async (params) => mcpJsonResult(
-      await client.updateCodingJobPlanStep(
-        paramsWithDefaultThread(params, defaultThreadId)
+    );
+    server.tool(
+      "linzumi_update_coding_job_plan_step",
+      "Update one coding job plan step status or note. Read metadata first and pass the current step lock_version.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        ),
+        step_id: external_exports2.string().uuid().describe("Step id returned by linzumi_get_coding_job_metadata."),
+        lock_version: external_exports2.number().int().positive().describe("Current step lock_version from metadata."),
+        status: external_exports2.enum([
+          "pending",
+          "active",
+          "completed",
+          "blocked",
+          "canceled"
+        ]),
+        status_note: external_exports2.string().min(1).max(4e3).optional(),
+        completed_debrief: external_exports2.string().min(1).max(2e4).optional().describe("Required when marking a step completed.")
+      },
+      async (params) => mcpJsonResult(
+        await client.updateCodingJobPlanStep(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    )
-  );
-  server.tool(
-    "linzumi_link_coding_job_pull_request",
-    "Link the active coding job to its primary GitHub pull request so PR comments, files, commits, checks, deployments, and reviews can flow into the metadata view.",
-    {
-      thread_id: external_exports2.string().uuid().optional().describe(
-        "Linzumi thread UUID. Defaults to the active coding job thread."
-      ),
-      github_repo_owner: external_exports2.string().min(1).max(255),
-      github_repo_name: external_exports2.string().min(1).max(255),
-      github_pr_number: external_exports2.number().int().positive(),
-      github_pr_url: external_exports2.string().url(),
-      title: external_exports2.string().min(1).max(255),
-      body: external_exports2.string().min(1).max(1e5).optional(),
-      head_branch: external_exports2.string().min(1).max(255),
-      head_sha: external_exports2.string().min(7).max(64),
-      base_branch: external_exports2.string().min(1).max(255),
-      base_sha: external_exports2.string().min(7).max(64),
-      state: external_exports2.enum(["draft", "open", "closed", "merged"]).optional(),
-      is_draft: external_exports2.boolean().optional(),
-      review_status: external_exports2.enum(["unknown", "review_required", "approved", "changes_requested"]).optional(),
-      source_remote_url: external_exports2.string().min(1).max(1e3).describe(
-        "Git remote URL for the local job worktree; required when this job has no repo workspace yet."
-      ),
-      runtime_worktree_root: external_exports2.string().min(1).max(1e3).describe(
-        "Absolute local worktree path for the coding job; required when this job has no repo workspace yet."
-      ),
-      dirty_status: external_exports2.enum(["unknown", "clean", "dirty"]).optional(),
-      dirty_summary: external_exports2.string().min(1).max(2e3).optional()
-    },
-    async (params) => mcpJsonResult(
-      await client.linkCodingJobPullRequest(
-        paramsWithDefaultThread(params, defaultThreadId)
+    );
+    server.tool(
+      "linzumi_link_coding_job_pull_request",
+      "Link the active coding job to its primary GitHub pull request so PR comments, files, commits, checks, deployments, and reviews can flow into the metadata view.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().optional().describe(
+          "Linzumi thread UUID. Defaults to the active coding job thread."
+        ),
+        github_repo_owner: external_exports2.string().min(1).max(255),
+        github_repo_name: external_exports2.string().min(1).max(255),
+        github_pr_number: external_exports2.number().int().positive(),
+        github_pr_url: external_exports2.string().url(),
+        title: external_exports2.string().min(1).max(255),
+        body: external_exports2.string().min(1).max(1e5).optional(),
+        head_branch: external_exports2.string().min(1).max(255),
+        head_sha: external_exports2.string().min(7).max(64),
+        base_branch: external_exports2.string().min(1).max(255),
+        base_sha: external_exports2.string().min(7).max(64),
+        state: external_exports2.enum(["draft", "open", "closed", "merged"]).optional(),
+        is_draft: external_exports2.boolean().optional(),
+        review_status: external_exports2.enum(["unknown", "review_required", "approved", "changes_requested"]).optional(),
+        source_remote_url: external_exports2.string().min(1).max(1e3).describe(
+          "Git remote URL for the local job worktree; required when this job has no repo workspace yet."
+        ),
+        runtime_worktree_root: external_exports2.string().min(1).max(1e3).describe(
+          "Absolute local worktree path for the coding job; required when this job has no repo workspace yet."
+        ),
+        dirty_status: external_exports2.enum(["unknown", "clean", "dirty"]).optional(),
+        dirty_summary: external_exports2.string().min(1).max(2e3).optional()
+      },
+      async (params) => mcpJsonResult(
+        await client.linkCodingJobPullRequest(
+          paramsWithDefaultThread(params, defaultThreadId)
+        )
       )
-    )
-  );
-  server.tool(
-    "linzumi_upload_files",
-    "Upload local files to Linzumi and attach them to a new, exact, or latest assistant message. Use silently; do not mention this tool in the visible reply.",
-    {
-      target: external_exports2.object({
-        kind: external_exports2.enum(["new_message", "message_seq", "latest_assistant_message"]).describe(
-          "new_message creates a message; message_seq edits an exact message; latest_assistant_message edits the latest assistant message in the scoped thread/channel."
+    );
+    server.tool(
+      "linzumi_upload_files",
+      "Upload local files to Linzumi and attach them to a new, exact, or latest assistant message. Use silently; do not mention this tool in the visible reply.",
+      {
+        target: external_exports2.object({
+          kind: external_exports2.enum(["new_message", "message_seq", "latest_assistant_message"]).describe(
+            "new_message creates a message; message_seq edits an exact message; latest_assistant_message edits the latest assistant message in the scoped thread/channel."
+          ),
+          message_seq: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Required when kind is message_seq."),
+          thread_id: external_exports2.string().optional().describe(
+            "Thread UUID. Defaults to the active Linzumi thread when the MCP server was launched with one."
+          )
+        }).describe(
+          "Attachment target. Do not guess; use new_message when there is no previous assistant message."
+        ),
+        files: external_exports2.array(external_exports2.string().min(1)).min(1).max(16).describe(
+          "Local file paths to upload. Paths must be non-hidden supported file types inside the approved workspace or Downloads."
+        ),
+        body: external_exports2.string().min(1).max(2e4).optional().describe(
+          "Required for new_message. Optional replacement body for message_seq/latest_assistant_message; when omitted, the existing message body is preserved."
+        ),
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope.")
+      },
+      async (params) => {
+        const target = targetWithDefaultThread(
+          params.target,
+          defaultThreadId
+        );
+        const result = await uploadFilesWithClient({
+          client,
+          cwd,
+          kandanUrl,
+          target,
+          files: params.files,
+          workspace: params.workspace,
+          channel: params.channel,
+          body: params.body
+        });
+        return mcpJsonResult(result);
+      }
+    );
+    server.tool(
+      "linzumi_list_vault_secrets",
+      "List vault secret names, descriptions, and whether each secret is personal or workspace-owned. Does not return secret values.",
+      {},
+      async (params) => mcpJsonResult(await client.listVaultSecrets(params))
+    );
+  }
+  if (customEmojiMcpToolsEnabledForScope(toolScope)) {
+    server.tool(
+      "linzumi_upload_custom_emoji",
+      "Upload a local image as a workspace custom emoji. For generated emoji art, create a transparent PNG with a simple centered subject, crisp edges, strong contrast, minimal tiny details, and enough outline/highlight separation to read at 16-24px on both dark and light backgrounds. Use lowercase shortcode names without colons unless preserving a user-provided :name:.",
+      {
+        name: customEmojiNameSchema.describe(
+          "Custom emoji shortcode name, with or without surrounding colons."
+        ),
+        file: external_exports2.string().min(1).describe(
+          "Local PNG/WebP/GIF/JPEG file path to upload. Prefer transparent PNG for generated emoji."
         ),
-        message_seq: external_exports2.union([external_exports2.string(), external_exports2.number()]).optional().describe("Required when kind is message_seq."),
-        thread_id: external_exports2.string().optional().describe(
-          "Thread UUID. Defaults to the active Linzumi thread when the MCP server was launched with one."
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
         )
-      }).describe(
-        "Attachment target. Do not guess; use new_message when there is no previous assistant message."
-      ),
-      files: external_exports2.array(external_exports2.string().min(1)).min(1).max(16).describe(
-        "Local file paths to upload. Paths must be non-hidden supported file types inside the approved workspace or Downloads."
-      ),
-      body: external_exports2.string().min(1).max(2e4).optional().describe(
-        "Required for new_message. Optional replacement body for message_seq/latest_assistant_message; when omitted, the existing message body is preserved."
-      ),
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope.")
-    },
-    async (params) => {
-      const target = targetWithDefaultThread(
-        params.target,
-        defaultThreadId
-      );
-      const result = await uploadFilesWithClient({
-        client,
-        cwd,
-        kandanUrl,
-        target,
-        files: params.files,
-        workspace: params.workspace,
-        channel: params.channel,
-        body: params.body
-      });
-      return mcpJsonResult(result);
-    }
-  );
-  server.tool(
-    "linzumi_list_vault_secrets",
-    "List vault secret names, descriptions, and whether each secret is personal or workspace-owned. Does not return secret values.",
-    {},
-    async (params) => mcpJsonResult(await client.listVaultSecrets(params))
-  );
-  server.tool(
-    "linzumi_upload_custom_emoji",
-    "Upload a local image as a workspace custom emoji. For generated emoji art, create a transparent PNG with a simple centered subject, crisp edges, strong contrast, minimal tiny details, and enough outline/highlight separation to read at 16-24px on both dark and light backgrounds. Use lowercase shortcode names without colons unless preserving a user-provided :name:.",
-    {
-      name: customEmojiNameSchema.describe(
-        "Custom emoji shortcode name, with or without surrounding colons."
-      ),
-      file: external_exports2.string().min(1).describe(
-        "Local PNG/WebP/GIF/JPEG file path to upload. Prefer transparent PNG for generated emoji."
-      ),
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope.")
-    },
-    async (params) => mcpJsonResult(
-      await uploadCustomEmojiWithClient({
-        client,
-        cwd,
-        kandanUrl,
-        name: params.name,
-        file: params.file,
-        workspace: params.workspace
-      })
-    )
-  );
-  server.tool(
-    "linzumi_rename_custom_emoji",
-    "Rename an existing workspace custom emoji. The new name may include surrounding colons; Linzumi stores the normalized shortcode without colons.",
-    {
-      emoji_id: external_exports2.union([external_exports2.string(), external_exports2.number().int().positive()]).describe(
-        "Workspace custom emoji id returned by linzumi_upload_custom_emoji or workspace emoji listings."
-      ),
-      name: customEmojiNameSchema.describe(
-        "New shortcode name, with or without surrounding colons."
-      ),
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope.")
-    },
-    async (params) => mcpJsonResult(await client.renameCustomEmoji(params))
-  );
-  server.tool(
-    "linzumi_dm_owner",
-    "Send a plain-text DM to the configured Commander owner. Requires dm.write and a visible owner username.",
-    {
-      owner_username: external_exports2.string().optional().describe(
-        "Owner username. Defaults to LINZUMI_MCP_OWNER_USERNAME or --owner-username."
-      ),
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Source channel slug used to verify owner visibility."),
-      body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to DM.")
-    },
-    async (params) => {
-      const owner = params.owner_username ?? ownerUsername;
-      if (owner === void 0) {
-        throw new Error("owner_username is required for linzumi_dm_owner");
-      }
-      return mcpJsonResult(
-        await client.dmOwner({
-          ...params,
-          owner_username: owner
+      },
+      async (params) => mcpJsonResult(
+        await uploadCustomEmojiWithClient({
+          client,
+          cwd,
+          kandanUrl,
+          name: params.name,
+          file: params.file,
+          workspace: params.workspace
         })
-      );
-    }
-  );
-  server.tool(
-    "linzumi_send_channel_message",
-    "Send a plain-text message as the authenticated local-runner user to the scoped Linzumi channel. Requires channel.write.",
-    {
-      workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
-      body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to post.")
-    },
-    async (params) => mcpJsonResult(await client.sendChannelMessage(params))
-  );
+      )
+    );
+    server.tool(
+      "linzumi_rename_custom_emoji",
+      "Rename an existing workspace custom emoji. The new name may include surrounding colons; Linzumi stores the normalized shortcode without colons.",
+      {
+        emoji_id: external_exports2.union([external_exports2.string(), external_exports2.number().int().positive()]).describe(
+          "Workspace custom emoji id returned by linzumi_upload_custom_emoji or workspace emoji listings."
+        ),
+        name: customEmojiNameSchema.describe(
+          "New shortcode name, with or without surrounding colons."
+        ),
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        )
+      },
+      async (params) => mcpJsonResult(await client.renameCustomEmoji(params))
+    );
+  }
   server.tool(
-    "linzumi_send_thread_reply",
-    "Send a plain-text reply as the authenticated local-runner user to an existing thread in the scoped Linzumi channel. Requires thread.write.",
+    "linzumi_note_project_directory",
+    "Record one discovered local Git repository or worktree for onboarding import. Call once per project as soon as it is found.",
     {
       workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
-      thread_id: external_exports2.string().uuid().describe("Existing Linzumi thread UUID."),
-      body: external_exports2.string().min(1).max(2e4).describe("Plain-text reply body to post.")
+      runner_id: external_exports2.string().min(1).describe("Local runner/computer id provided in the discovery prompt."),
+      path: external_exports2.string().min(1).describe("Absolute local path to the repository worktree root."),
+      display_name: external_exports2.string().optional().describe("Short project label. Defaults to the path basename."),
+      activity_at: external_exports2.string().optional().describe("Best-known recent activity time as an ISO-8601 timestamp."),
+      import_key: external_exports2.string().optional().describe("Stable dedupe key. Defaults to path."),
+      metadata: external_exports2.record(external_exports2.unknown()).optional().describe("Small structured metadata such as branch or remote origin.")
     },
-    async (params) => mcpJsonResult(await client.sendThreadReply(params))
+    async (params) => mcpJsonResult(await client.noteProjectDirectory(params))
   );
   server.tool(
-    "linzumi_send_dm",
-    "Send a plain-text DM as the authenticated local-runner user to a visible user in the scoped workspace/channel. Requires dm.write.",
+    "linzumi_note_agent_conversation",
+    "Record one discovered Codex or Claude Code local conversation for onboarding import. Call once per conversation as soon as it is found.",
     {
       workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe("Source channel slug used to verify target visibility."),
-      username: external_exports2.string().describe("Visible Linzumi username to DM."),
-      body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to DM.")
+      runner_id: external_exports2.string().min(1).describe("Local runner/computer id provided in the discovery prompt."),
+      source: external_exports2.enum(["codex", "claude_code"]).describe("Conversation source."),
+      import_key: external_exports2.string().min(1).describe("Stable dedupe key, such as a session id or file path."),
+      path: external_exports2.string().optional().describe("Absolute local path to the conversation file or directory."),
+      display_name: external_exports2.string().optional().describe("Short label for the discovered conversation."),
+      activity_at: external_exports2.string().optional().describe("Best-known recent activity time as an ISO-8601 timestamp."),
+      metadata: external_exports2.record(external_exports2.unknown()).optional().describe(
+        "Small structured metadata such as session id or project path."
+      )
     },
-    async (params) => mcpJsonResult(await client.sendDm(params))
+    async (params) => mcpJsonResult(await client.noteAgentConversation(params))
   );
   server.tool(
-    "linzumi_get_vault_values",
-    "Request values for explicit vault env var names after a thread-scoped human approval. Requires vault.read; thread_id resolves the approval thread.",
+    "linzumi_note_onboarding_discovery_status",
+    "Record onboarding discovery progress. Call when a search phase starts, checks another place, completes, or fails.",
     {
       workspace: external_exports2.string().optional().describe("Workspace slug. Omit to use the authenticated token scope."),
-      channel: external_exports2.string().optional().describe(
-        "Channel slug used to disambiguate the approval thread when needed."
+      runner_id: external_exports2.string().min(1).describe("Local runner/computer id provided in the discovery prompt."),
+      phase: external_exports2.enum(["projects", "conversations"]).describe("Discovery phase being reported."),
+      status: external_exports2.enum(["starting", "running", "completed", "failed"]).describe("Current phase status."),
+      places_searched: external_exports2.number().int().nonnegative().optional().describe(
+        "Count of concrete folders/files/known locations checked so far."
+      ),
+      message: external_exports2.string().optional().describe("Short user-facing status note."),
+      current_place: external_exports2.string().optional().describe(
+        "Current folder, file, Git command target, or known location being checked."
       ),
-      thread_id: external_exports2.string().uuid().describe("Existing Linzumi thread UUID for the inline approval."),
-      env_var_names: external_exports2.array(external_exports2.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/)).min(1).max(20).describe(
-        "Explicit vault env var names to request. This tool cannot list all vault keys."
+      current_source: external_exports2.string().optional().describe(
+        "Short machine-readable source label such as git, codex, or claude_code."
       ),
-      description: external_exports2.string().min(1).max(500).describe("Human-readable reason shown in the approval request."),
-      justification: external_exports2.string().min(10).max(1e3).describe("Agent justification shown to the approver.")
+      last_error: external_exports2.string().optional().describe("Short failure detail when status is failed."),
+      metadata: external_exports2.record(external_exports2.unknown()).optional().describe("Small structured status metadata.")
     },
-    async (params) => mcpJsonResult(await client.getVaultValues(params))
+    async (params) => mcpJsonResult(
+      await client.noteOnboardingDiscoveryStatus(params)
+    )
   );
+  if (toolScope === "all") {
+    server.tool(
+      "linzumi_dm_owner",
+      "Send a plain-text DM to the configured Commander owner. Requires dm.write and a visible owner username.",
+      {
+        owner_username: external_exports2.string().optional().describe(
+          "Owner username. Defaults to LINZUMI_MCP_OWNER_USERNAME or --owner-username."
+        ),
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Source channel slug used to verify owner visibility."),
+        body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to DM.")
+      },
+      async (params) => {
+        const owner = params.owner_username ?? ownerUsername;
+        if (owner === void 0) {
+          throw new Error("owner_username is required for linzumi_dm_owner");
+        }
+        return mcpJsonResult(
+          await client.dmOwner({
+            ...params,
+            owner_username: owner
+          })
+        );
+      }
+    );
+    server.tool(
+      "linzumi_send_channel_message",
+      "Send a plain-text message as the authenticated local-runner user to the scoped Linzumi channel. Requires channel.write.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to post.")
+      },
+      async (params) => mcpJsonResult(await client.sendChannelMessage(params))
+    );
+    server.tool(
+      "linzumi_send_thread_reply",
+      "Send a plain-text reply as the authenticated local-runner user to an existing thread in the scoped Linzumi channel. Requires thread.write.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Channel slug. Omit to use the authenticated token scope."),
+        thread_id: external_exports2.string().uuid().describe("Existing Linzumi thread UUID."),
+        body: external_exports2.string().min(1).max(2e4).describe("Plain-text reply body to post.")
+      },
+      async (params) => mcpJsonResult(await client.sendThreadReply(params))
+    );
+    server.tool(
+      "linzumi_send_dm",
+      "Send a plain-text DM as the authenticated local-runner user to a visible user in the scoped workspace/channel. Requires dm.write.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe("Source channel slug used to verify target visibility."),
+        username: external_exports2.string().describe("Visible Linzumi username to DM."),
+        body: external_exports2.string().min(1).max(2e4).describe("Plain-text message body to DM.")
+      },
+      async (params) => mcpJsonResult(await client.sendDm(params))
+    );
+    server.tool(
+      "linzumi_get_vault_values",
+      "Request values for explicit vault env var names after a thread-scoped human approval. Requires vault.read; thread_id resolves the approval thread.",
+      {
+        workspace: external_exports2.string().optional().describe(
+          "Workspace slug. Omit to use the authenticated token scope."
+        ),
+        channel: external_exports2.string().optional().describe(
+          "Channel slug used to disambiguate the approval thread when needed."
+        ),
+        thread_id: external_exports2.string().uuid().describe("Existing Linzumi thread UUID for the inline approval."),
+        env_var_names: external_exports2.array(external_exports2.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/)).min(1).max(20).describe(
+          "Explicit vault env var names to request. This tool cannot list all vault keys."
+        ),
+        description: external_exports2.string().min(1).max(500).describe("Human-readable reason shown in the approval request."),
+        justification: external_exports2.string().min(10).max(1e3).describe("Agent justification shown to the approver.")
+      },
+      async (params) => mcpJsonResult(await client.getVaultValues(params))
+    );
+  }
   await server.connect(new StdioServerTransport());
 }
 async function uploadFilesWithClient(args) {
@@ -59014,13 +61582,13 @@ async function uploadFilesWithClient(args) {
       if (uploadUrl === void 0) {
         throw new Error("Linzumi upload prepare response missing upload_url");
       }
-      const bytes = await readFile2(file.path);
+      const bytes = await readFile3(file.path);
       const uploadBody = bytes.buffer.slice(
         bytes.byteOffset,
         bytes.byteOffset + bytes.byteLength
       );
       const response = await fetch(
-        resolveLinzumiUploadUrl(args.kandanUrl, uploadUrl),
+        resolveLinzumiUploadUrl2(args.kandanUrl, uploadUrl),
         {
           method: uploadMethod,
           headers: { "content-type": file.contentType },
@@ -59064,13 +61632,13 @@ async function uploadCustomEmojiWithClient(args) {
   if (uploadUrl === void 0) {
     throw new Error("Linzumi custom emoji prepare response missing upload_url");
   }
-  const bytes = await readFile2(file.path);
+  const bytes = await readFile3(file.path);
   const uploadBody = bytes.buffer.slice(
     bytes.byteOffset,
     bytes.byteOffset + bytes.byteLength
   );
   const response = await fetch(
-    resolveLinzumiUploadUrl(args.kandanUrl, uploadUrl),
+    resolveLinzumiUploadUrl2(args.kandanUrl, uploadUrl),
     {
       method: uploadMethod,
       headers: { "content-type": file.contentType },
@@ -59133,7 +61701,7 @@ function paramsWithDefaultThread(params, defaultThreadId) {
   }
   return { ...params, thread_id: defaultThreadId };
 }
-function resolveLinzumiUploadUrl(kandanUrl, uploadUrl) {
+function resolveLinzumiUploadUrl2(kandanUrl, uploadUrl) {
   try {
     return new URL(uploadUrl).toString();
   } catch (_error) {
@@ -59171,7 +61739,8 @@ async function runMcpConfig(args) {
     accessToken: token,
     delegationAuthFilePath: stringValue5(values, "delegation-auth-file"),
     ownerUsername: stringValue5(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME,
-    operatingMode
+    operatingMode,
+    toolScope: mcpToolScope(stringValue5(values, "tool-scope"))
   });
   switch (format) {
     case "codex":
@@ -59299,6 +61868,17 @@ function mcpOperatingMode(value) {
       throw new Error("--mode must be voice or text");
   }
 }
+function mcpToolScope(value) {
+  switch (value) {
+    case void 0:
+      return "all";
+    case "all":
+    case "onboarding-discovery":
+      return value;
+    default:
+      throw new Error("--tool-scope must be all or onboarding-discovery");
+  }
+}
 function required(values, key) {
   const value = stringValue5(values, key);
   if (value === void 0) {
@@ -59641,6 +62221,7 @@ function optionalObjectField(input, key) {
 
 // src/index.ts
 init_userFacingErrors();
+var onboardingDiscoveryRequiredScopes = ["local_runner.discovery.write"];
 var flagDefinitions = /* @__PURE__ */ new Map([
   ["version", { kind: "boolean" }],
   ["api-url", { kind: "value" }],
@@ -59664,6 +62245,7 @@ var flagDefinitions = /* @__PURE__ */ new Map([
   ["forward-port", { kind: "value" }],
   ["code-server-bin", { kind: "value" }],
   ["fast", { kind: "boolean" }],
+  ["no-onboarding-discovery", { kind: "boolean" }],
   ["log-file", { kind: "value" }],
   ["status-dir", { kind: "value" }],
   ["timeout-ms", { kind: "value" }],
@@ -59786,8 +62368,41 @@ async function main(args) {
         await runThreadCodexWorker(parseThreadCodexWorkerArgs(parsed.args));
         return;
       }
-      const options = await parseRunnerArgs(parsed.args);
-      await runLocalCodexRunner(withLocalMachineId(options));
+      const telemetryApiUrl = peekFlagValue(parsed.args, [
+        "--api-url",
+        "--linzumi-url"
+      ]);
+      if (!isHelpOrVersionInvocation(parsed.args)) {
+        void postLifecycleEvent(
+          {
+            name: "commander.connect.started",
+            attributes: {
+              ...workspaceTelemetryAttribute(
+                peekFlagValue(parsed.args, ["--workspace"])
+              ),
+              launch_source: connectLaunchSourceTelemetryValue()
+            }
+          },
+          { apiUrl: telemetryApiUrl }
+        );
+      }
+      try {
+        const options = await parseRunnerArgs(parsed.args);
+        await runLocalCodexRunner(withLocalMachineId(options));
+      } catch (error) {
+        await postLifecycleEvent(
+          {
+            name: "commander.error",
+            severity: "ERROR",
+            attributes: {
+              ...lifecycleErrorAttributes(error),
+              launch_source: connectLaunchSourceTelemetryValue()
+            }
+          },
+          { apiUrl: telemetryApiUrl }
+        );
+        throw error;
+      }
       return;
     }
   }
@@ -60123,6 +62738,7 @@ async function parseStartRunnerArgs(args, deps = {
   const allowedCwds = Array.from(/* @__PURE__ */ new Set([cwd, ...explicitAllowedCwds]));
   const requestedCodexBin = stringValue7(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue7(values, "code-server-bin");
+  const onboardingDiscovery = values.get("no-onboarding-discovery") === true ? void 0 : "start";
   const initialDependencyStatus = await deps.buildDependencyStatus({
     cwd,
     codexBin: requestedCodexBin,
@@ -60141,9 +62757,10 @@ async function parseStartRunnerArgs(args, deps = {
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
-    onboarding: "start",
+    onboarding: onboardingDiscovery === "start" ? "start" : void 0,
     authFilePath,
     callbackHost,
+    requiredScopes: onboardingDiscovery === "start" ? onboardingDiscoveryRequiredScopes : void 0,
     reportRejectedCachedToken
   });
   const target = await deps.fetchStartTarget({ kandanUrl, accessToken: token });
@@ -60151,7 +62768,8 @@ async function parseStartRunnerArgs(args, deps = {
     kandanUrl,
     accessToken: token,
     workspaceSlug: target.workspaceSlug,
-    channelSlug: target.channelSlug
+    channelSlug: target.channelSlug,
+    requiredScopes: onboardingDiscovery === "start" ? onboardingDiscoveryRequiredScopes : void 0
   });
   const targetToken = tokenMatchesTarget ? token : await resolveStartTargetToken({
     kandanUrl,
@@ -60159,6 +62777,7 @@ async function parseStartRunnerArgs(args, deps = {
     target,
     authFilePath,
     callbackHost,
+    requiredScopes: onboardingDiscovery === "start" ? onboardingDiscoveryRequiredScopes : void 0,
     resolveToken: deps.resolveToken,
     reportRejectedCachedToken
   });
@@ -60200,6 +62819,7 @@ async function parseStartRunnerArgs(args, deps = {
     dependencyStatus,
     claudeCodeAvailable,
     runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
+    onboardingDiscovery,
     channelSession: {
       workspaceSlug: target.workspaceSlug,
       channelSlug: target.channelSlug,
@@ -60309,7 +62929,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path2) {
-  return existsSync14(path2) ? readFileSync16(path2, "utf8") : void 0;
+  return existsSync16(path2) ? readFileSync19(path2, "utf8") : void 0;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -60381,6 +63001,7 @@ async function resolveStartTargetToken(args) {
     channelSlug: args.target.channelSlug,
     authFilePath: args.authFilePath,
     callbackHost: args.callbackHost,
+    requiredScopes: args.requiredScopes,
     reportRejectedCachedToken: args.reportRejectedCachedToken
   });
 }
@@ -60420,6 +63041,7 @@ async function parseRunnerArgs(args, deps = {
   ) : [...localConfiguredAllowedCwds.allowedCwds];
   const requestedCodexBin = stringValue7(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue7(values, "code-server-bin");
+  const onboardingDiscovery = values.get("no-onboarding-discovery") === true ? void 0 : "start";
   const initialDependencyStatus = await deps.buildDependencyStatus({
     cwd,
     codexBin: requestedCodexBin,
@@ -60434,6 +63056,7 @@ async function parseRunnerArgs(args, deps = {
     workspaceSlug,
     authFilePath: stringValue7(values, "auth-file"),
     callbackHost: stringValue7(values, "oauth-callback-host"),
+    requiredScopes: onboardingDiscovery === "start" ? onboardingDiscoveryRequiredScopes : void 0,
     reportRejectedCachedToken: () => {
       process.stderr.write(
         "Cached Linzumi local runner auth was rejected; starting OAuth.\n"
@@ -60481,6 +63104,7 @@ async function parseRunnerArgs(args, deps = {
     claudeCodeAvailable,
     workspaceSlug: workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
     runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
+    onboardingDiscovery,
     channelSession: void 0
   };
 }
@@ -60496,6 +63120,15 @@ function runnerRuntimeDefaultsFromValues(values) {
 function electronAutoConnectLaunchSource() {
   return process.env.LINZUMI_ELECTRON_AUTO_CONNECT_RUNNER === "1" ? "electron_auto_connect" : void 0;
 }
+function connectLaunchSourceTelemetryValue() {
+  return electronAutoConnectLaunchSource() ?? "cli";
+}
+function workspaceTelemetryAttribute(workspace) {
+  return workspace === void 0 ? {} : { workspace };
+}
+function isHelpOrVersionInvocation(args) {
+  return args.some((arg) => ["--help", "-h", "--version"].includes(arg));
+}
 function kandanUrlValue(values) {
   const apiUrl = stringValue7(values, "api-url");
   const linzumiUrl = stringValue7(values, "linzumi-url");
@@ -60607,10 +63240,10 @@ function rejectStartTargetingFlags(values) {
 }
 function resolveUserPath(pathValue) {
   if (pathValue === "~") {
-    return homedir13();
+    return homedir15();
   }
   if (pathValue.startsWith("~/")) {
-    return resolve10(homedir13(), pathValue.slice(2));
+    return resolve10(homedir15(), pathValue.slice(2));
   }
   return resolve10(pathValue);
 }