runwork 0.25.3 → 0.27.0

package/dist/index.js

@@ -62,7 +62,11 @@ import {
   createInflateRaw
 } from "node:zlib";
 function firstEnv(names) {
-  for (const variable of names) {
+  const keys = Object.keys(process.env);
+  for (const candidate of names) {
+    const variable = keys.find((k) => k === candidate) ?? keys.find((k) => k.toLowerCase() === candidate.toLowerCase());
+    if (variable === undefined)
+      continue;
     const value = process.env[variable];
     if (value && value.trim() !== "")
       return { variable, value: value.trim() };
@@ -828,6 +832,10 @@ class ApiClient {
   async reportTelemetry(workspaceId, events) {
     await this.request(`/api/workspaces/${workspaceId}/team/telemetry`, { method: "POST", body: JSON.stringify({ events }) });
   }
+  async createDebugReport(workspaceId, body) {
+    const res = await this.request(`/api/workspaces/${workspaceId}/debug-reports`, { method: "POST", body: JSON.stringify(body) });
+    return res.data;
+  }
   async createSharedConversation(workspaceId, body) {
     const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations`, {
       method: "POST",
@@ -1038,10 +1046,13 @@ var init_workspace_state = __esm(() => {
 // src/utils/subprocess.ts
 import {
   execFileSync as cpExecFileSync,
-  spawn as cpSpawn
+  spawn as cpSpawn,
+  spawnSync as cpSpawnSync
 } from "child_process";
 var execFileSync = (file, args, options) => {
   return cpExecFileSync(file, args, { windowsHide: true, ...options ?? {} });
+}, spawnSync = (file, args, options) => {
+  return cpSpawnSync(file, args, { windowsHide: true, ...options ?? {} });
 }, spawn2 = (command, args, options) => {
   return cpSpawn(command, args ?? [], { windowsHide: true, ...options ?? {} });
 };
@@ -3135,13 +3146,56 @@ function bufToStr2(val) {
     return val.toString("utf-8").trim();
   return "";
 }
+function pushSyncStash(cwd) {
+  execFileSync("git", ["stash", "push", "-m", SYNC_STASH_TAG], { cwd, stdio: "pipe" });
+  return findSyncStashSha(cwd);
+}
+function findSyncStashSha(cwd) {
+  try {
+    const line = execFileSync("git", ["stash", "list", "--format=%H %gs"], { cwd, encoding: "utf-8" }).split(`
+`).find((l) => l.includes(SYNC_STASH_TAG));
+    return line ? line.split(" ")[0] : null;
+  } catch {
+    return null;
+  }
+}
+function stashRefForSha(cwd, sha) {
+  try {
+    const line = execFileSync("git", ["stash", "list", "--format=%H %gd"], { cwd, encoding: "utf-8" }).split(`
+`).find((l) => l.startsWith(`${sha} `));
+    return line ? line.slice(sha.length + 1).trim() : null;
+  } catch {
+    return null;
+  }
+}
+function restoreSyncStash(cwd, sha) {
+  const resolved = sha ?? findSyncStashSha(cwd);
+  if (!resolved)
+    return "missing";
+  const ref = stashRefForSha(cwd, resolved);
+  if (!ref)
+    return "missing";
+  try {
+    execFileSync("git", ["stash", "apply", resolved], { cwd, stdio: "pipe" });
+  } catch {
+    return "conflict";
+  }
+  const dropRef = stashRefForSha(cwd, resolved);
+  if (dropRef) {
+    try {
+      execFileSync("git", ["stash", "drop", dropRef], { cwd, stdio: "pipe" });
+    } catch {}
+  }
+  return "restored";
+}
 function syncWithRemote(cwd) {
   if (!hasCommits(cwd)) {
     return { status: "skipped", pushed: false };
   }
   const dirty = hasTrackedChanges(cwd);
+  let stashSha = null;
   if (dirty) {
-    execFileSync("git", ["stash", "push", "-m", "runwork-dev-sync"], { cwd, stdio: "pipe" });
+    stashSha = pushSyncStash(cwd);
   }
   let status = "synced";
   let syncError;
@@ -3182,9 +3236,8 @@ function syncWithRemote(cwd) {
     syncError = extractGitError(fetchErr);
   }
   if (dirty) {
-    try {
-      execFileSync("git", ["stash", "pop"], { cwd, stdio: "pipe" });
-    } catch {
+    const restored = restoreSyncStash(cwd, stashSha);
+    if (restored !== "restored") {
       return { status, pushed: false, error: "stash-conflict", keptUntracked, remoteOverwrote };
     }
   }
@@ -3201,6 +3254,7 @@ function syncWithRemote(cwd) {
   }
   return { status, pushed, pushError, keptUntracked, remoteOverwrote };
 }
+var SYNC_STASH_TAG = "runwork-dev-sync";
 var init_sync = __esm(() => {
   init_subprocess();
   init_manifest();
@@ -5105,10 +5159,6 @@ export declare class FileStorageClient {
  */
 export declare function createFileStorageClient(env: Env): FileStorageClient;
 import type { Hono } from 'hono';
-/**
- * Mount file storage routes on the Hono app
- * Provides REST API for R2 bucket operations
- */
 export declare function fileStorageRoutes(app: Hono<{
     Bindings: Env;
 }>): void;
@@ -5285,6 +5335,46 @@ export declare function componentRoutes(app: Hono<{
 `,
     "workspace.d.ts": `export { WorkspaceContext, getWorkspaceContext, listWorkspaceEntity, getWorkspaceEntity, createWorkspaceEntity, updateWorkspaceEntity, deleteWorkspaceEntity, callAppEndpoint, initializeWorkspace, } from './core-workspace';
 export type { WorkspaceUser, ListUsersOptions, ListUsersResponse, NotifyUserParams, NotifyUserResult, ListEntityRequest, ListEntityResponse, GetEntityRequest, CreateEntityRequest, UpdateEntityRequest, DeleteEntityRequest, RegisterEntityRequest, RegisterAppRequest, RegisterComponentRequest, RegisterScheduleRequest, RegisterWorkflowRequest, RegisterEndpointRequest, RegisterIntegrationRequest, CallAppEndpointOptions, CallAppEndpointResult, RegisterAgentRequest as WorkspaceRegisterAgentRequest, } from './core-workspace';
+`,
+    "client.d.ts": `/**
+ * Framework client entry: browser-side helpers an app's frontend imports as
+ * \`@runworkai/framework/client\`, so app code never carries this plumbing
+ * itself.
+ *
+ * Analytics: what people do in the app, reported to the workspace.
+ *
+ * Envelope follows the Segment Spec (the de-facto standard Google Analytics,
+ * Mixpanel, PostHog and friends all map to), so nothing here needs to change
+ * if the workspace later forwards events to a real analytics tool.
+ *
+ * The app does not interpret events. \`/api/analytics\` stamps the app's
+ * identity and forwards to the workspace, which decides what each one means.
+ * Today a \`page\` counts as one USE of the app, the multiplier behind a
+ * standalone app's value in the workspace's reports. \`track\` events are kept
+ * for a later analytics surface.
+ *
+ * A page load is reported here because the document is served before the
+ * app's Worker runs, leaving no server-side trace otherwise. Once per
+ * document, not per route change: the workspace counts an opened tool, and a
+ * person navigating inside it is still one use.
+ *
+ * Fire-and-forget. Nothing here may ever affect the person using the app.
+ */
+/** Record a custom event. Use a flat Title Case name ("Report Exported") and put variables in properties. */
+export declare function track(event: string, properties?: Record<string, unknown>): void;
+/** Record a named screen or view inside the app. */
+export declare function screen(name: string, properties?: Record<string, unknown>): void;
+/**
+ * Tell the workspace who this browser belongs to, in the APP's own terms.
+ * A claim, recorded as data; the workspace never grants anything on it.
+ */
+export declare function identify(userId: string, traits?: Record<string, unknown>): void;
+/** Attach this person to a company, account or team the app knows about. */
+export declare function group(groupId: string, traits?: Record<string, unknown>): void;
+/** Link a past anonymous identity to a known one. */
+export declare function alias(userId: string, previousId?: string): void;
+/** Record that this app was opened. Called once automatically on load. */
+export declare function page(): void;
 `,
     "core-scheduler.d.ts": `/**
  * Core Scheduled Jobs Framework
@@ -5936,8 +6026,6 @@ export type Doc<T> = {
  * - Security validation on all field names
  */
 export declare class EntityDO extends DurableObject<Env> {
-    ctx: DurableObjectState;
-    env: Env;
     private _tableReady;
     private _migrationDone;
     constructor(ctx: DurableObjectState, env: Env);
@@ -6942,13 +7030,6 @@ export declare function toChannelName(appName: string): string;
  * these entries in the observability timeline.
  */
 export declare function flog(level: 'info' | 'warn' | 'error', system: string, message: string, data?: Record<string, unknown>): void;
-/**
- * Emit an event to the workspace unified event stream.
- * Fire-and-forget: uses ctx.waitUntil so it doesn't block the response.
- * Silently skips if workspace env vars are not configured (standalone mode).
- *
- * Automatically routes events to a channel derived from APP_NAME when available.
- */
 export declare function emitEvent(ctx: WaitUntilContext, env: EventEnv, event: EmitEventParams): void;
 export {};
 `,
@@ -7023,7 +7104,109 @@ export declare const isStr: (s: unknown) => s is string;
  * that would cause structured clone to fail in ctx.storage.put().
  */
 export declare function safeClone<T>(value: T, fallback?: T): T;
-export declare function platformFetch(env: Env, url: string | URL, init?: RequestInit): Promise<Response>;
+/**
+ * Platform fetch - routes requests through WorkspaceObject DO for production workers.
+ *
+ * Workers for Platforms (WfP) workers cannot reliably make HTTP requests back to their
+ * parent platform worker (they get 522 timeouts). This utility routes platform API calls
+ * through the WorkspaceObject Durable Object binding, which works across worker boundaries.
+ *
+ * Supported paths:
+ * - /api/proxy/integrations/* - Integration proxy (Nango)
+ * - /api/proxy/openai/* - AI Gateway proxy
+ * - /api/storage/presign - Storage presigned URLs
+ *
+ * For preview containers (DEPLOYMENT_MODE !== 'production'), uses standard fetch.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Instead of:
+ * const response = await fetch('https://runwork.ai/api/proxy/integrations/proxy/contacts', options);
+ *
+ * // Use:
+ * const response = await platformFetch(env, 'https://runwork.ai/api/proxy/integrations/proxy/contacts', options);
+ * \`\`\`
+ */
+/**
+ * What the app was doing when it made a call.
+ *
+ * Internal plumbing, deliberately not exported from the package: app authors
+ * never set this, the framework establishes it at each entry point (schedule
+ * tick, workflow run, route handler, agent turn) and \`platformFetch\` below
+ * reads it. It lives beside \`platformFetch\` because that is its only consumer.
+ *
+ * WHY IT EXISTS: usage rows record \`appId\` and \`userId\` and nothing about what
+ * was executing, so a HubSpot call made by a nightly schedule cannot be told
+ * apart from one a person made from their own agent. \`runId\` is the field that
+ * cannot be reconstructed later: it links one run's AI calls and integration
+ * calls together, which is what per-run cost is built from.
+ *
+ * Design: docs/plans/2026-08-28-baselines-capture-redesign.md section 4.1.
+ */
+export interface RunContext {
+    /**
+     * WHAT was executing. Only constructs the framework itself runs, never
+     * "where the caller was" (a browser, MCP, the CLI): that is a different
+     * question and \`audit_logs.actor_type\` owns it.
+     */
+    kind: 'schedule' | 'workflow' | 'endpoint' | 'route' | 'agent';
+    /**
+     * Human-readable name, following the convention the audit rows already use:
+     * a schedule/workflow/agent slug, or \`METHOD /path\` for endpoints and routes.
+     *
+     * OMITTED rather than defaulted when genuinely unknown. A placeholder string
+     * like 'unknown' becomes a value every query has to filter out, and it is
+     * indistinguishable from an app that named something 'unknown'.
+     */
+    name?: string;
+    /**
+     * App-local registry key, so a usage row joins back to a registration. The
+     * app id is a column of its own, so this is the part after it: a slug for
+     * schedules, workflows and agents, \`METHOD /path\` for endpoints.
+     */
+    resourceKey?: string;
+    /** One id shared by everything emitted inside this execution. */
+    runId: string;
+    /** The enclosing run, for workflow steps, nested calls and sub-agents. */
+    parentRunId?: string;
+    trigger?: 'cron' | 'manual' | 'webhook' | 'chat' | 'api';
+    /**
+     * The person who started this run. Named to match the governance program's
+     * \`DelegationChain.triggererUserId\` (\`worker/types/permissions.ts\`), which is
+     * the same fact: one name for it across both programs.
+     *
+     * ATTRIBUTION, NEVER AUTHORITY. This travels on a header from the app, behind
+     * the shared WORKSPACE_API_KEY, so an app can put any user id here. The
+     * platform may RECORD it; nothing may ever AUTHORIZE on it. Whose authority a
+     * run borrows is resolved platform-side by PermissionService, not stated by
+     * the caller.
+     */
+    triggererUserId?: string;
+    attempt?: number;
+}
+/** Header carrying the context to the platform side, which writes the audit row. */
+export declare const RUN_CONTEXT_HEADER = "x-runwork-run-context";
+/**
+ * Run \`fn\` with \`ctx\` as the ambient execution context.
+ *
+ * Nesting is automatic: entering a context inside another records the outer
+ * \`runId\` as \`parentRunId\` unless the caller set one. That is what makes a
+ * sub-agent's calls point at the run that started it. Re-entering the SAME
+ * run id is not nesting (a workflow resumes into its own run across wake-ups)
+ * and must not make a run its own parent.
+ */
+export declare function withRunContext<T>(ctx: RunContext, fn: () => T): T;
+/** The current execution context, or undefined outside any entry point. */
+export declare function getRunContext(): RunContext | undefined;
+/**
+ * Merge the context header into request headers.
+ *
+ * One serialised header rather than several, so adding a field never needs a
+ * matching change in the platform's parsing. Never overwrites a header the
+ * caller set: a caller that knows its own context beats the ambient one.
+ */
+export declare function withRunContextHeader(init?: HeadersInit): HeadersInit | undefined;
+export declare function platformFetch(env: Env, url: string | URL, rawInit?: RequestInit): Promise<Response>;
 /**
  * Workspace API fetch - routes workspace service requests through WorkspaceObject DO
  * for production WfP workers, avoiding 522 recursive invocation errors.
@@ -7036,7 +7219,7 @@ export declare function platformFetch(env: Env, url: string | URL, init?: Reques
  * @param path - Workspace API sub-path (e.g., '/ingest-event')
  * @param init - Standard fetch options
  */
-export declare function workspaceApiFetch(env: Pick<Env, 'WORKSPACE_API_URL' | 'WORKSPACE_API_KEY' | 'WORKSPACE_ID' | 'DEPLOYMENT_MODE' | 'WorkspaceObject'>, path: string, init?: RequestInit): Promise<Response>;
+export declare function workspaceApiFetch(env: Pick<Env, 'WORKSPACE_API_URL' | 'WORKSPACE_API_KEY' | 'WORKSPACE_ID' | 'DEPLOYMENT_MODE' | 'WorkspaceObject'>, path: string, rawInit?: RequestInit): Promise<Response>;
 `,
     "workflows.d.ts": `import type { WorkflowDefinition } from './core-workflow-types';
 /**
@@ -7231,7 +7414,7 @@ export declare class BaseAgent extends AIChatAgent<Env> {
  * - Types are defined in core-workflow-types.ts
  * - Native DO-based implementation is in core-workflow-instance.ts and core-workflow-coordinator.ts
  */
-import type { Env } from './core-utils';
+import { type Env } from './core-utils';
 export type { WorkflowResult, WorkflowStatus, WorkflowInstanceInfo, WorkflowDefinition, WorkflowContext, WorkflowStepUtilities, StepOptions, WaitEventOptions, WorkflowLogger, WorkflowState, WorkflowStatusResponse, } from './core-workflow-types';
 import type { WorkflowInstanceInfo } from './core-workflow-types';
 /**
@@ -7780,8 +7963,8 @@ export declare const integrationApiSchema: z.ZodObject<{
     endpoint: z.ZodString;
     data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
     endpoint: string;
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
     data?: Record<string, unknown> | undefined;
 }, {
     endpoint: string;
@@ -8022,7 +8205,7 @@ function createKeyboardListener() {
 }
 
 // src/generated/version.ts
-var VERSION = "0.25.3";
+var VERSION = "0.27.0";
 
 // src/commands/dev.ts
 var exports_dev = {};
@@ -8103,6 +8286,7 @@ async function execDev(options) {
     await ensureGitCredentialHelper(creds.baseUrl);
   }
   ensureRunworkRemote(cwd, client.getGitRemoteUrl(config.workspaceId, config.appId));
+  let editsUnprotected = false;
   const oldManifest = await loadManifest(cwd);
   if (oldManifest) {
     const userEdits = await detectUserEdits(cwd, oldManifest);
@@ -8126,9 +8310,22 @@ async function execDev(options) {
         execFileSync("git", ["add", "--", ...userEdits], { stdio: "pipe" });
         execFileSync("git", ["commit", "-m", "sync: user edits"], { stdio: "pipe" });
       } catch {}
+      editsUnprotected = hasTrackedChanges(cwd);
+      if (editsUnprotected) {
+        if (useJson) {
+          jsonLine({
+            event: "startup",
+            phase: "user_edits_unprotected",
+            timestamp: ts(),
+            warning: "Could not commit your edits (a commit hook or lock may be interfering). Skipping the template update so they are not lost."
+          });
+        } else {
+          console.warn(yellow("Could not commit your edits (a commit hook or lock may be interfering). Skipping the template update so they are not lost."));
+        }
+      }
     }
   }
-  if (!noSync) {
+  if (!noSync && !editsUnprotected) {
     if (useJson) {
       jsonLine({ event: "startup", phase: "template_update", timestamp: ts() });
     } else {
@@ -8971,10 +9168,39 @@ function startAppProbeScript(pattern) {
 function isCommandNotFoundExit(code) {
   return typeof code === "number" && COMMAND_NOT_FOUND_EXIT_CODES.includes(code);
 }
-var PATH_REFRESH_FAILED_MARKER = "__runwork_path_refresh_failed__", WINDOWS_PATH_REFRESH, COMMAND_NOT_FOUND_EXIT_CODES;
+function expandWindowsPathTemplate(path2, resolved) {
+  for (const [placeholder, defaults] of Object.entries(WINDOWS_PATH_PLACEHOLDERS)) {
+    if (!path2.startsWith(placeholder))
+      continue;
+    const rest = path2.slice(placeholder.length).replace(/^[/\\]/, "");
+    const fromEnv = resolved[placeholder];
+    if (fromEnv) {
+      return { path: `${fromEnv.replace(/[/\\]+$/, "")}\\${rest.replace(/\//g, "\\")}`, needsHomeJoin: false };
+    }
+    if ("absoluteDefault" in defaults) {
+      return { path: `${defaults.absoluteDefault}\\${rest.replace(/\//g, "\\")}`, needsHomeJoin: false };
+    }
+    return { path: `${defaults.homeRelativeDefault}/${rest}`, needsHomeJoin: true };
+  }
+  return { path: path2, needsHomeJoin: !/^([A-Za-z]:[\\/]|\\\\|\/)/.test(path2) };
+}
+function parseConfigDeclaredPath(text2, key) {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`^\\s*${escapedKey}\\s*=\\s*"((?:[^"\\\\]|\\\\.)*)"`, "m").exec(text2);
+  if (!match)
+    return null;
+  const path2 = match[1].replace(/\\(.)/g, "$1");
+  return path2 || null;
+}
+var PATH_REFRESH_FAILED_MARKER = "__runwork_path_refresh_failed__", WINDOWS_PATH_REFRESH, COMMAND_NOT_FOUND_EXIT_CODES, WINDOWS_PATH_PLACEHOLDERS;
 var init_detection_probes = __esm(() => {
   WINDOWS_PATH_REFRESH = "try { $env:Path = [Environment]::GetEnvironmentVariable('Path','Machine') + ';' + " + "[Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:Path } " + `catch { Write-Output '${PATH_REFRESH_FAILED_MARKER}' }; `;
   COMMAND_NOT_FOUND_EXIT_CODES = [127, 9009];
+  WINDOWS_PATH_PLACEHOLDERS = {
+    "%APPDATA%": { homeRelativeDefault: "AppData/Roaming" },
+    "%LOCALAPPDATA%": { homeRelativeDefault: "AppData/Local" },
+    "%ProgramFiles%": { absoluteDefault: "C:\\Program Files" }
+  };
 });
 
 // src/utils/which.ts
@@ -9387,6 +9613,9 @@ function getAgent(slug) {
 function getAgents() {
   return AGENT_REGISTRY;
 }
+function getDetectableAgents() {
+  return AGENT_REGISTRY.filter((a) => a.detection);
+}
 function isConnectOnlyAgent(agent) {
   if (!agent)
     return false;
@@ -9415,11 +9644,15 @@ function resolveAgentCli(agent) {
     return;
   return detectionBinaryTarget(agent.detection);
 }
-var CLAUDE_CODE_NATIVE_INSTALL_PATHS, CHATGPT_SECURITY_SETTINGS_URL = "https://chatgpt.com/plugins#settings/Security", CHATGPT_CREATE_CONNECTOR_URL = "https://chatgpt.com/plugins#settings/Connectors?create-connector=true&redirectAfter=%2Fplugins", AGENT_REGISTRY, slugIndex, nameIndex, CUSTOM_ADAPTER_SLUGS, getRegistryAgent, getRegistryAgents;
+var CLAUDE_CODE_NATIVE_INSTALL_PATHS, CODEX_CONFIG_FILE = ".codex/config.toml", CODEX_BUNDLED_CLI_PATHS, CHATGPT_SECURITY_SETTINGS_URL = "https://chatgpt.com/plugins#settings/Security", CHATGPT_CREATE_CONNECTOR_URL = "https://chatgpt.com/plugins#settings/Connectors?create-connector=true&redirectAfter=%2Fplugins", AGENT_REGISTRY, slugIndex, nameIndex, CUSTOM_ADAPTER_SLUGS, getRegistryAgent, getRegistryAgents;
 var init_registry_data = __esm(() => {
   CLAUDE_CODE_NATIVE_INSTALL_PATHS = [
     { macos: ".local/bin/claude", linux: ".local/bin/claude", windows: ".local/bin/claude.exe" }
   ];
+  CODEX_BUNDLED_CLI_PATHS = [
+    { macos: "/Applications/ChatGPT.app/Contents/Resources/codex" },
+    { macos: "/Applications/Codex.app/Contents/Resources/codex" }
+  ];
   AGENT_REGISTRY = [
     {
       slug: "claude-code",
@@ -9477,7 +9710,7 @@ var init_registry_data = __esm(() => {
           {
             method: "path",
             target: {
-              windows: "AppData/Roaming/Claude/claude_desktop_config.json",
+              windows: "%APPDATA%/Claude/claude_desktop_config.json",
               linux: ".config/Claude/claude_desktop_config.json"
             }
           }
@@ -9490,7 +9723,7 @@ var init_registry_data = __esm(() => {
       skillsPaths: { global: ".claude/skills", project: ".claude/skills" },
       mcpConfigPath: {
         macos: "Library/Application Support/Claude/claude_desktop_config.json",
-        windows: "AppData/Roaming/Claude/claude_desktop_config.json",
+        windows: "%APPDATA%/Claude/claude_desktop_config.json",
         linux: ".config/Claude/claude_desktop_config.json"
       },
       mcpConfigKey: "mcpServers",
@@ -9651,8 +9884,18 @@ var init_registry_data = __esm(() => {
       name: "Codex CLI",
       description: "AI in your terminal by OpenAI, great for coding, debugging, and automating dev tasks",
       category: "cli",
-      detection: { method: "binary", target: "codex" },
-      launch: { cli: "codex", cliAcceptsPrompt: true },
+      detection: {
+        method: "any",
+        target: [
+          { method: "binary", target: "codex" },
+          {
+            method: "config-value",
+            target: { file: CODEX_CONFIG_FILE, key: "CODEX_CLI_PATH" }
+          },
+          ...CODEX_BUNDLED_CLI_PATHS.map((target) => ({ method: "path", target }))
+        ]
+      },
+      launch: { cli: "codex", cliAcceptsPrompt: true, cliWellKnownPaths: CODEX_BUNDLED_CLI_PATHS },
       logo: "codex",
       downloadUrl: "https://learn.chatgpt.com/docs/codex/cli",
       install: {
@@ -9689,6 +9932,7 @@ var init_registry_data = __esm(() => {
       launch: { url: "https://chatgpt.com/?prompt={prompt}" },
       logo: "openai",
       downloadUrl: "https://chatgpt.com",
+      suggestsCli: "codex",
       firstClass: true,
       resumeCapability: {
         mode: "url-prompt",
@@ -9745,6 +9989,7 @@ var init_registry_data = __esm(() => {
         ]
       },
       launch: { app: { macos: "ChatGPT Classic", windows: "ChatGPT Classic" }, bundleId: { macos: "com.openai.chat" }, appxPackage: "OpenAI.ChatGPT", url: "https://chatgpt.com/?prompt={prompt}" },
+      suggestsCli: "codex",
       logo: "openai",
       downloadUrl: "https://chatgpt.com/download",
       downloadUrls: {
@@ -9800,8 +10045,8 @@ var init_registry_data = __esm(() => {
         target: [
           { method: "binary", target: "windsurf" },
           { method: "path", target: { macos: "/Applications/Windsurf.app" } },
-          { method: "path", target: { windows: "AppData/Local/Programs/Windsurf" } },
-          { method: "path", target: { windows: "C:\\Program Files\\Windsurf" } }
+          { method: "path", target: { windows: "%LOCALAPPDATA%/Programs/Windsurf" } },
+          { method: "path", target: { windows: "%ProgramFiles%/Windsurf" } }
         ]
       },
       launch: { app: { macos: "Windsurf", windows: "Windsurf" } },
@@ -9881,7 +10126,14 @@ var init_registry_data = __esm(() => {
       name: "GitHub Copilot (VS Code)",
       description: "GitHub's AI pair programmer in VS Code",
       category: "extension",
-      detection: { method: "binary", target: "code" },
+      detection: {
+        method: "path",
+        target: {
+          macos: "Library/Application Support/Code/User/globalStorage/github.copilot",
+          windows: "%APPDATA%/Code/User/globalStorage/github.copilot",
+          linux: ".config/Code/User/globalStorage/github.copilot"
+        }
+      },
       launch: { app: { macos: "Visual Studio Code", windows: "Code" }, cli: "code" },
       logo: "vscode",
       downloadUrl: "https://marketplace.visualstudio.com/items?itemName=GitHub.copilot",
@@ -9983,12 +10235,145 @@ var init_registry_data = __esm(() => {
   getRegistryAgents = getAgents;
 });
 
+// src/agents/detection.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
+import { homedir as homedir6, platform as platform2 } from "os";
+import { join as join22 } from "path";
+import { promisify } from "util";
+function isWindows() {
+  return platform2() === "win32";
+}
+function toList(value) {
+  return Array.isArray(value) ? value : [value];
+}
+async function runPowerShell(script) {
+  const execFileAsync = promisify(execFile);
+  try {
+    await execFileAsync("powershell", ["-NoProfile", "-Command", script]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveDetectionPath(target) {
+  const resolved = resolvePlatformString(target);
+  if (!resolved)
+    return null;
+  const expanded = expandWindowsPathTemplate(resolved, {
+    "%APPDATA%": process.env.APPDATA,
+    "%LOCALAPPDATA%": process.env.LOCALAPPDATA,
+    "%ProgramFiles%": process.env.ProgramFiles
+  });
+  return expanded.needsHomeJoin ? join22(homedir6(), expanded.path) : expanded.path;
+}
+function checkPath(target) {
+  const absolute = resolveDetectionPath(target);
+  if (!absolute)
+    return null;
+  return existsSync26(absolute) ? absolute : null;
+}
+function checkConfigDeclaredPath(target) {
+  const configPath = resolveDetectionPath(target.file);
+  if (!configPath)
+    return null;
+  let text2;
+  try {
+    if (!existsSync26(configPath))
+      return null;
+    text2 = readFileSync23(configPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const declared = parseConfigDeclaredPath(text2, target.key);
+  return declared && existsSync26(declared) ? declared : null;
+}
+async function checkMacosBundleId(target) {
+  if (platform2() !== "darwin")
+    return false;
+  const execFileAsync = promisify(execFile);
+  for (const id of toList(target)) {
+    if (!isValidBundleId(id))
+      continue;
+    try {
+      await execFileAsync("sh", ["-c", macosBundleIdProbeScript(id)]);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+async function checkWindowsAppxPackage(target) {
+  if (!isWindows())
+    return false;
+  const probes = toList(target).map((pkg) => runPowerShell(appxPackageProbeScript(pkg)));
+  const results = await Promise.all(probes);
+  return results.some(Boolean);
+}
+async function checkWindowsStartApp(target) {
+  if (!isWindows())
+    return false;
+  const probes = toList(target).map((pattern) => runPowerShell(startAppProbeScript(pattern)));
+  const results = await Promise.all(probes);
+  return results.some(Boolean);
+}
+async function runAgentDetectionDetailed(detection) {
+  switch (detection.method) {
+    case "binary": {
+      const target = resolvePlatformString(detection.target);
+      const resolved = target ? whichBinary(target) : null;
+      return resolved ? { detected: true, via: "binary", resolvedPath: resolved } : NOT_DETECTED;
+    }
+    case "path": {
+      const resolved = checkPath(detection.target);
+      return resolved ? { detected: true, via: "path", resolvedPath: resolved } : NOT_DETECTED;
+    }
+    case "config-value": {
+      const resolved = checkConfigDeclaredPath(detection.target);
+      return resolved ? { detected: true, via: "config-value", resolvedPath: resolved } : NOT_DETECTED;
+    }
+    case "windows-appx":
+      return await checkWindowsAppxPackage(detection.target) ? { detected: true, via: "windows-appx" } : NOT_DETECTED;
+    case "windows-start-app":
+      return await checkWindowsStartApp(detection.target) ? { detected: true, via: "windows-start-app" } : NOT_DETECTED;
+    case "macos-bundle-id":
+      return await checkMacosBundleId(detection.target) ? { detected: true, via: "macos-bundle-id" } : NOT_DETECTED;
+    case "any": {
+      const probes = await Promise.all(detection.target.map((p) => runAgentDetectionDetailed(p)));
+      return probes.find((p) => p.detected) ?? NOT_DETECTED;
+    }
+    case "always":
+      return { detected: true, via: "always" };
+    default:
+      return NOT_DETECTED;
+  }
+}
+async function runAgentDetection(detection) {
+  return (await runAgentDetectionDetailed(detection)).detected;
+}
+
+class RegistryDetectedAdapter {
+  async detect() {
+    const def = getRegistryAgent(this.slug);
+    if (!def)
+      return false;
+    return runAgentDetection(def.detection);
+  }
+}
+var NOT_DETECTED;
+var init_detection = __esm(() => {
+  init_which();
+  init_registry_data();
+  init_registry();
+  init_detection_probes();
+  NOT_DETECTED = { detected: false };
+});
+
 // src/agents/registry.ts
-import { platform as platform2, homedir as homedir6 } from "os";
-import { isAbsolute as isAbsolute2, join as join22 } from "path";
-import { existsSync as existsSync26 } from "fs";
+import { platform as platform3, homedir as homedir7 } from "os";
+import { isAbsolute as isAbsolute3, join as join23 } from "path";
+import { existsSync as existsSync27 } from "fs";
 function getNodePlatform() {
-  const p = platform2();
+  const p = platform3();
   if (p === "darwin")
     return "macos";
   if (p === "win32")
@@ -10005,7 +10390,7 @@ function resolveToAbsolute(ps, scope) {
   const resolved = resolvePlatformString(ps);
   if (!resolved)
     return;
-  return scope === "global" ? join22(homedir6(), resolved) : join22(process.cwd(), resolved);
+  return scope === "global" ? join23(homedir7(), resolved) : join23(process.cwd(), resolved);
 }
 function resolveAgentCliCommand(slug) {
   const agent = getAgent(slug);
@@ -10014,19 +10399,40 @@ function resolveAgentCliCommand(slug) {
     return null;
   if (whichBinary(cli))
     return cli;
+  const declared = vendorDeclaredCliPath(slug);
+  if (declared)
+    return declared;
   for (const candidate of agent?.launch?.cliWellKnownPaths ?? []) {
     const resolved = resolvePlatformString(candidate);
     if (!resolved)
       continue;
-    const absolute = isAbsolute2(resolved) ? resolved : join22(homedir6(), resolved);
-    if (existsSync26(absolute))
+    const absolute = isAbsolute3(resolved) ? resolved : join23(homedir7(), resolved);
+    if (existsSync27(absolute))
       return absolute;
   }
   return null;
 }
+function configValueMatchers(detection) {
+  if (!detection)
+    return [];
+  if (detection.method === "config-value")
+    return [detection.target];
+  if (detection.method === "any")
+    return detection.target.flatMap(configValueMatchers);
+  return [];
+}
+function vendorDeclaredCliPath(slug) {
+  for (const matcher of configValueMatchers(getAgent(slug)?.detection)) {
+    const resolved = checkConfigDeclaredPath(matcher);
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
 var init_registry = __esm(() => {
   init_which();
   init_registry_data();
+  init_detection();
   init_registry_data();
 });
 
@@ -10867,6 +11273,8 @@ function scanClaudeJsonlHead(head) {
       result.firstTimestamp = o.timestamp;
     if (!result.cwd && typeof o.cwd === "string")
       result.cwd = o.cwd;
+    if (!result.surface && typeof o.entrypoint === "string")
+      result.surface = o.entrypoint;
     if (!result.title && o.type === "ai-title" && typeof o.aiTitle === "string") {
       result.title = titleFromText(o.aiTitle);
     }
@@ -10892,7 +11300,7 @@ function scanClaudeJsonlHead(head) {
         }
       }
     }
-    if (result.title && result.firstTimestamp && result.cwd)
+    if (result.title && result.firstTimestamp && result.cwd && result.surface)
       break;
   }
   if (!result.title && firstUserText)
@@ -10921,6 +11329,8 @@ function scanCodexRolloutHead(head) {
         result.cwd = p.cwd;
       if (typeof p.id === "string" && !result.sessionId)
         result.sessionId = p.id;
+      if (typeof p.originator === "string" && !result.surface)
+        result.surface = p.originator;
     }
     if (!result.title && o.type === "response_item" && p.type === "message" && p.role === "user" && Array.isArray(p.content)) {
       for (const item of p.content) {
@@ -11020,23 +11430,23 @@ function skillNameFromPath(path2) {
 }
 
 // src/utils/trash.ts
-import { cpSync, existsSync as existsSync27, mkdirSync as mkdirSync13, readdirSync as readdirSync5, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync3 } from "fs";
-import { basename as basename2, dirname as dirname6, join as join23 } from "path";
-import { homedir as homedir7 } from "os";
+import { cpSync, existsSync as existsSync28, mkdirSync as mkdirSync13, readdirSync as readdirSync5, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync3 } from "fs";
+import { basename as basename2, dirname as dirname6, join as join24 } from "path";
+import { homedir as homedir8 } from "os";
 function trashRoot() {
-  return join23(homedir7(), ".runwork", "trash");
+  return join24(homedir8(), ".runwork", "trash");
 }
 function batchDir(now) {
   const stamp = now.toISOString().replace(/[:.]/g, "-");
-  return join23(trashRoot(), `${stamp}-${process.pid}`);
+  return join24(trashRoot(), `${stamp}-${process.pid}`);
 }
 function pruneTrash(now = new Date) {
   const root = trashRoot();
-  if (!existsSync27(root))
+  if (!existsSync28(root))
     return;
   const cutoff = now.getTime() - TRASH_RETENTION_DAYS * 24 * 60 * 60 * 1000;
   for (const entry of readdirSync5(root)) {
-    const dir = join23(root, entry);
+    const dir = join24(root, entry);
     try {
       if (statSync3(dir).mtimeMs < cutoff)
         rmSync4(dir, { recursive: true, force: true });
@@ -11044,7 +11454,7 @@ function pruneTrash(now = new Date) {
   }
 }
 function moveToTrash(sourcePath, reason, now = new Date) {
-  if (!existsSync27(sourcePath))
+  if (!existsSync28(sourcePath))
     return null;
   if (!activeBatch || !activeBatch.startsWith(trashRoot())) {
     activeBatch = batchDir(now);
@@ -11052,8 +11462,8 @@ function moveToTrash(sourcePath, reason, now = new Date) {
   }
   const parent = basename2(dirname6(sourcePath));
   const grandparent = basename2(dirname6(dirname6(sourcePath)));
-  const destDir = join23(activeBatch, `${grandparent}__${parent}`.replace(/[^a-zA-Z0-9._-]/g, "-"));
-  const dest = join23(destDir, basename2(sourcePath));
+  const destDir = join24(activeBatch, `${grandparent}__${parent}`.replace(/[^a-zA-Z0-9._-]/g, "-"));
+  const dest = join24(destDir, basename2(sourcePath));
   try {
     mkdirSync13(destDir, { recursive: true });
     try {
@@ -11065,7 +11475,7 @@ function moveToTrash(sourcePath, reason, now = new Date) {
   } catch {
     return null;
   }
-  const manifestPath = join23(activeBatch, "manifest.json");
+  const manifestPath = join24(activeBatch, "manifest.json");
   const manifest = readJsonOrNull(manifestPath) ?? { entries: [] };
   manifest.entries.push({ from: sourcePath, to: dest, reason, at: now.toISOString() });
   try {
@@ -11108,27 +11518,27 @@ function configHash(value) {
 var init_hash = () => {};
 
 // src/agents/utils/json-config.ts
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, existsSync as existsSync29 } from "fs";
 import { dirname as dirname7 } from "path";
 function isRunworkManagedKey(key) {
   return key === RUNWORK_WORKSPACE_MCP_NAME || key.startsWith(RUNWORK_MCP_PREFIX) || key.startsWith(RUNWORK_MCP_PREFIX_LEGACY);
 }
 function readJsonConfig(filePath) {
-  if (!existsSync28(filePath))
+  if (!existsSync29(filePath))
     return {};
   try {
-    return JSON.parse(readFileSync23(filePath, "utf-8"));
+    return JSON.parse(readFileSync24(filePath, "utf-8"));
   } catch (err) {
     console.warn(`  [config] ${filePath} is not valid JSON: ${err instanceof Error ? err.message : err}`);
     return {};
   }
 }
 function existingContentIsUnparseable(filePath) {
-  if (!existsSync28(filePath))
+  if (!existsSync29(filePath))
     return { bad: false };
   let raw;
   try {
-    raw = readFileSync23(filePath, "utf-8");
+    raw = readFileSync24(filePath, "utf-8");
   } catch {
     return { bad: false };
   }
@@ -11150,7 +11560,7 @@ function writeJsonConfig(filePath, config) {
 `);
 }
 function removeRunworkMcpServers(filePath, topKey) {
-  if (!existsSync28(filePath))
+  if (!existsSync29(filePath))
     return false;
   const config = readJsonConfig(filePath);
   const existing = config[topKey] || {};
@@ -11205,25 +11615,25 @@ var init_json_config = __esm(() => {
 });
 
 // src/agents/utils/skill-removal.ts
-import { existsSync as existsSync29, readdirSync as readdirSync6 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync6 } from "fs";
+import { join as join25 } from "path";
 function removeMatchingSkillDirs(dir, allowed, reason = "skill removed") {
-  if (!allowed.size || !existsSync29(dir))
+  if (!allowed.size || !existsSync30(dir))
     return;
   for (const entry of readdirSync6(dir)) {
     if (!allowed.has(entry))
       continue;
-    moveToTrash(join24(dir, entry), reason);
+    moveToTrash(join25(dir, entry), reason);
   }
 }
 function removeMatchingSkillFiles(dir, allowed, suffix, reason = "skill removed") {
-  if (!allowed.size || !existsSync29(dir))
+  if (!allowed.size || !existsSync30(dir))
     return;
   const names = new Set([...allowed].map((slug) => `${slug}${suffix}`));
   for (const entry of readdirSync6(dir)) {
     if (!names.has(entry))
       continue;
-    moveToTrash(join24(dir, entry), reason);
+    moveToTrash(join25(dir, entry), reason);
   }
 }
 var init_skill_removal = __esm(() => {
@@ -11231,7 +11641,7 @@ var init_skill_removal = __esm(() => {
 });
 
 // src/agents/utils/instruction-hint.ts
-import { existsSync as existsSync30, readFileSync as readFileSync24, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15 } from "fs";
 import { dirname as dirname8 } from "path";
 function writeHintToFile(filePath, hint) {
   mkdirSync15(dirname8(filePath), { recursive: true });
@@ -11241,8 +11651,8 @@ ${hint}
 ${END_MARKER}`;
   }
   let content = "";
-  if (existsSync30(filePath)) {
-    content = readFileSync24(filePath, "utf-8");
+  if (existsSync31(filePath)) {
+    content = readFileSync25(filePath, "utf-8");
   }
   const startIdx = content.indexOf(START_MARKER);
   const endIdx = content.indexOf(END_MARKER);
@@ -11264,9 +11674,9 @@ ${END_MARKER}`;
   writeFileSync15(filePath, content);
 }
 function removeHintFromFile(filePath) {
-  if (!existsSync30(filePath))
+  if (!existsSync31(filePath))
     return false;
-  let content = readFileSync24(filePath, "utf-8");
+  let content = readFileSync25(filePath, "utf-8");
   const startIdx = content.indexOf(START_MARKER);
   const endIdx = content.indexOf(END_MARKER);
   if (startIdx < 0 || endIdx < 0)
@@ -11284,9 +11694,9 @@ function removeHintFromFile(filePath) {
   return true;
 }
 function removeTeamInstructionsFromFile(filePath) {
-  if (!existsSync30(filePath))
+  if (!existsSync31(filePath))
     return false;
-  let content = readFileSync24(filePath, "utf-8");
+  let content = readFileSync25(filePath, "utf-8");
   const startIdx = content.indexOf(TEAM_START_MARKER);
   const endIdx = content.indexOf(TEAM_END_MARKER);
   if (startIdx < 0 || endIdx < 0)
@@ -11306,8 +11716,8 @@ function removeTeamInstructionsFromFile(filePath) {
 function writeTeamInstructionsToFile(filePath, instructions) {
   mkdirSync15(dirname8(filePath), { recursive: true });
   let content = "";
-  if (existsSync30(filePath)) {
-    content = readFileSync24(filePath, "utf-8");
+  if (existsSync31(filePath)) {
+    content = readFileSync25(filePath, "utf-8");
   }
   const block = `${TEAM_START_MARKER}
 ${instructions}
@@ -11756,117 +12166,70 @@ function vlog(...args) {
 }
 var verbose = false;
 
-// src/agents/detection.ts
-import { execFile } from "child_process";
-import { existsSync as existsSync31 } from "fs";
-import { homedir as homedir8, platform as platform3 } from "os";
-import { isAbsolute as isAbsolute3, join as join25 } from "path";
-import { promisify } from "util";
-function isWindows() {
-  return platform3() === "win32";
+// src/agents/transcript-sources.ts
+import { accessSync, constants, statSync as statSync4 } from "fs";
+function classifyFsErrorCode(code) {
+  if (code === "ENOENT" || code === "ENOTDIR")
+    return "missing-dir";
+  if (code === "EACCES" || code === "EPERM")
+    return "permission-denied";
+  return "error";
 }
-function toList(value) {
-  return Array.isArray(value) ? value : [value];
+function errorCode(err) {
+  const e = err;
+  return e && typeof e === "object" && typeof e.code === "string" ? e.code : undefined;
 }
-async function runPowerShell(script) {
-  const execFileAsync = promisify(execFile);
+function probeTranscriptSource(source) {
+  if (source.available && !source.available()) {
+    return { status: "missing-tool", path: source.path, detail: source.tool ?? "unknown tool" };
+  }
   try {
-    await execFileAsync("powershell", ["-NoProfile", "-Command", script]);
-    return true;
-  } catch {
-    return false;
+    statSync4(source.path);
+  } catch (err) {
+    return { status: classifyFsErrorCode(errorCode(err)), path: source.path, detail: errorCode(err) };
   }
+  try {
+    accessSync(source.path, source.kind === "dir" ? constants.R_OK | constants.X_OK : constants.R_OK);
+  } catch (err) {
+    return { status: classifyFsErrorCode(errorCode(err)), path: source.path, detail: errorCode(err) };
+  }
+  return { status: "ok", path: source.path };
 }
-function resolveDetectionPath(target) {
-  const resolved = resolvePlatformString(target);
-  if (!resolved)
-    return null;
-  return isAbsolute3(resolved) ? resolved : join25(homedir8(), resolved);
+function diagnoseTranscriptRead(agent, thrown) {
+  const probe = summarizeTranscriptSources(agent.transcriptSources?.() ?? []);
+  const base = { agentSlug: agent.slug, sessions: null };
+  if (probe.status !== "ok" && probe.status !== "no-reader") {
+    return {
+      ...base,
+      status: probe.status,
+      path: probe.path,
+      ...probe.detail ? { detail: probe.detail } : {}
+    };
+  }
+  if (thrown !== undefined) {
+    return { ...base, status: "error", detail: thrown instanceof Error ? thrown.message : String(thrown) };
+  }
+  return probe.status === "ok" ? { ...base, status: "error", path: probe.path, detail: "read returned no result" } : { ...base, status: "no-reader" };
 }
-function checkPath(target) {
-  const absolute = resolveDetectionPath(target);
-  if (!absolute)
-    return null;
-  return existsSync31(absolute) ? absolute : null;
-}
-async function checkMacosBundleId(target) {
-  if (platform3() !== "darwin")
-    return false;
-  const execFileAsync = promisify(execFile);
-  for (const id of toList(target)) {
-    if (!isValidBundleId(id))
-      continue;
-    try {
-      await execFileAsync("sh", ["-c", macosBundleIdProbeScript(id)]);
-      return true;
-    } catch {}
-  }
-  return false;
-}
-async function checkWindowsAppxPackage(target) {
-  if (!isWindows())
-    return false;
-  const probes = toList(target).map((pkg) => runPowerShell(appxPackageProbeScript(pkg)));
-  const results = await Promise.all(probes);
-  return results.some(Boolean);
-}
-async function checkWindowsStartApp(target) {
-  if (!isWindows())
-    return false;
-  const probes = toList(target).map((pattern) => runPowerShell(startAppProbeScript(pattern)));
-  const results = await Promise.all(probes);
-  return results.some(Boolean);
-}
-async function runAgentDetectionDetailed(detection) {
-  switch (detection.method) {
-    case "binary": {
-      const target = resolvePlatformString(detection.target);
-      const resolved = target ? whichBinary(target) : null;
-      return resolved ? { detected: true, via: "binary", resolvedPath: resolved } : NOT_DETECTED;
-    }
-    case "path": {
-      const resolved = checkPath(detection.target);
-      return resolved ? { detected: true, via: "path", resolvedPath: resolved } : NOT_DETECTED;
-    }
-    case "windows-appx":
-      return await checkWindowsAppxPackage(detection.target) ? { detected: true, via: "windows-appx" } : NOT_DETECTED;
-    case "windows-start-app":
-      return await checkWindowsStartApp(detection.target) ? { detected: true, via: "windows-start-app" } : NOT_DETECTED;
-    case "macos-bundle-id":
-      return await checkMacosBundleId(detection.target) ? { detected: true, via: "macos-bundle-id" } : NOT_DETECTED;
-    case "any": {
-      const probes = await Promise.all(detection.target.map((p) => runAgentDetectionDetailed(p)));
-      return probes.find((p) => p.detected) ?? NOT_DETECTED;
-    }
-    case "always":
-      return { detected: true, via: "always" };
-    default:
-      return NOT_DETECTED;
-  }
-}
-async function runAgentDetection(detection) {
-  return (await runAgentDetectionDetailed(detection)).detected;
+function transcriptSourcesReadable(sources) {
+  return summarizeTranscriptSources(sources).status === "ok";
 }
-
-class RegistryDetectedAdapter {
-  async detect() {
-    const def = getRegistryAgent(this.slug);
-    if (!def)
-      return false;
-    return runAgentDetection(def.detection);
+function summarizeTranscriptSources(sources) {
+  if (sources.length === 0)
+    return { status: "no-reader", path: "" };
+  const probes = sources.map(probeTranscriptSource);
+  const rank = ["permission-denied", "missing-tool", "error", "ok", "missing-dir"];
+  for (const status of rank) {
+    const hit = probes.find((p) => p.status === status);
+    if (hit)
+      return hit;
   }
+  return probes[0];
 }
-var NOT_DETECTED;
-var init_detection = __esm(() => {
-  init_which();
-  init_registry_data();
-  init_registry();
-  init_detection_probes();
-  NOT_DETECTED = { detected: false };
-});
+var init_transcript_sources = () => {};
 
 // src/agents/claude-code.ts
-import { chmodSync, existsSync as existsSync32, mkdirSync as mkdirSync16, readFileSync as readFileSync25, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync16 } from "fs";
+import { chmodSync, existsSync as existsSync32, mkdirSync as mkdirSync16, readFileSync as readFileSync26, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, writeFileSync as writeFileSync16 } from "fs";
 import { join as join26 } from "path";
 import { homedir as homedir9 } from "os";
 function getPluginJson() {
@@ -11910,6 +12273,7 @@ var init_claude_code = __esm(() => {
   init_instruction_hint();
   init_session_start_hook();
   init_detection();
+  init_transcript_sources();
   ClaudeCodeAdapter = class ClaudeCodeAdapter extends RegistryDetectedAdapter {
     name = "Claude Code";
     slug = "claude-code";
@@ -12056,7 +12420,7 @@ ${instructions}`;
       let settings = {};
       if (hadFile) {
         try {
-          settings = JSON.parse(readFileSync25(settingsPath, "utf-8"));
+          settings = JSON.parse(readFileSync26(settingsPath, "utf-8"));
         } catch {}
       }
       if (settings.permissions && typeof settings.permissions === "object") {
@@ -12117,7 +12481,7 @@ ${instructions}`;
         const settingsPath = join26(homedir9(), ".claude", "settings.json");
         if (existsSync32(settingsPath)) {
           try {
-            const settings = JSON.parse(readFileSync25(settingsPath, "utf-8"));
+            const settings = JSON.parse(readFileSync26(settingsPath, "utf-8"));
             if (settings.permissions) {
               for (const key of ["allow", "deny"]) {
                 const arr = settings.permissions[key];
@@ -12207,7 +12571,7 @@ ${instructions}`;
             const filePath = join26(cwdPath, file);
             let stat;
             try {
-              stat = statSync4(filePath);
+              stat = statSync5(filePath);
             } catch {
               continue;
             }
@@ -12215,7 +12579,7 @@ ${instructions}`;
               continue;
             let content;
             try {
-              content = readFileSync25(filePath, "utf-8");
+              content = readFileSync26(filePath, "utf-8");
             } catch {
               continue;
             }
@@ -12299,9 +12663,15 @@ ${instructions}`;
         return null;
       }
     }
+    transcriptRoot() {
+      return join26(homedir9(), ".claude", "projects");
+    }
+    transcriptSources() {
+      return [{ path: this.transcriptRoot(), kind: "dir" }];
+    }
     async readSessionDigests(sinceISO) {
       try {
-        const projectsDir = join26(homedir9(), ".claude", "projects");
+        const projectsDir = this.transcriptRoot();
         if (!existsSync32(projectsDir))
           return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
@@ -12326,7 +12696,7 @@ ${instructions}`;
             const filePath = join26(cwdPath, file);
             let stat;
             try {
-              stat = statSync4(filePath);
+              stat = statSync5(filePath);
             } catch {
               continue;
             }
@@ -12334,7 +12704,7 @@ ${instructions}`;
               continue;
             let content;
             try {
-              content = readFileSync25(filePath, "utf-8");
+              content = readFileSync26(filePath, "utf-8");
             } catch {
               continue;
             }
@@ -12350,8 +12720,8 @@ ${instructions}`;
     }
     async listSessions(sinceISO) {
       try {
-        const projectsDir = join26(homedir9(), ".claude", "projects");
-        if (!existsSync32(projectsDir))
+        const projectsDir = this.transcriptRoot();
+        if (!transcriptSourcesReadable(this.transcriptSources()))
           return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         let cwdEntries;
@@ -12375,7 +12745,7 @@ ${instructions}`;
             const filePath = join26(cwdPath, file);
             let stat;
             try {
-              stat = statSync4(filePath);
+              stat = statSync5(filePath);
             } catch {
               continue;
             }
@@ -12390,7 +12760,7 @@ ${instructions}`;
             const sessionId = file.slice(0, -".jsonl".length);
             let endedAt = null;
             try {
-              const stamp = JSON.parse(readFileSync25(join26(homedir9(), ".runwork", "sessions", `${sessionId}.ended.json`), "utf-8"));
+              const stamp = JSON.parse(readFileSync26(join26(homedir9(), ".runwork", "sessions", `${sessionId}.ended.json`), "utf-8"));
               if (stamp && typeof stamp.endedAt === "string")
                 endedAt = stamp.endedAt;
             } catch {}
@@ -12402,7 +12772,8 @@ ${instructions}`;
               startedAt: scanned.firstTimestamp,
               lastActivityAt: resolveLastActivity(filePath, stat.mtimeMs),
               endedAt,
-              transcriptPath: filePath
+              transcriptPath: filePath,
+              surface: scanned.surface ?? null
             });
           }
         }
@@ -12413,7 +12784,7 @@ ${instructions}`;
     }
     async readSkillUsage(lastSyncAt) {
       try {
-        const projectsDir = join26(homedir9(), ".claude", "projects");
+        const projectsDir = this.transcriptRoot();
         if (!existsSync32(projectsDir))
           return null;
         const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
@@ -12448,7 +12819,7 @@ ${instructions}`;
             const filePath = join26(cwdPath, file);
             let fileStat;
             try {
-              fileStat = statSync4(filePath);
+              fileStat = statSync5(filePath);
             } catch {
               continue;
             }
@@ -12456,7 +12827,7 @@ ${instructions}`;
               continue;
             let content;
             try {
-              content = readFileSync25(filePath, "utf-8");
+              content = readFileSync26(filePath, "utf-8");
             } catch {
               continue;
             }
@@ -12704,7 +13075,7 @@ var init_claude_desktop_plugin_tree = __esm(() => {
 });
 
 // src/agents/claude-desktop.ts
-import { existsSync as existsSync34, mkdtempSync as mkdtempSync3, readdirSync as readdirSync8, readFileSync as readFileSync26, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync18, mkdirSync as mkdirSync18 } from "fs";
+import { existsSync as existsSync34, mkdtempSync as mkdtempSync3, readdirSync as readdirSync8, readFileSync as readFileSync27, rmSync as rmSync7, statSync as statSync6, writeFileSync as writeFileSync18, mkdirSync as mkdirSync18 } from "fs";
 import { dirname as dirname9, join as join28 } from "path";
 import { homedir as homedir10, platform as platform4, tmpdir as tmpdir3 } from "os";
 function isRunworkRpmPluginName(name) {
@@ -12823,7 +13194,7 @@ function findRpmPluginByName(pluginName) {
     if (!existsSync34(manifestPath))
       return null;
     try {
-      const manifest = JSON.parse(readFileSync26(manifestPath, "utf-8"));
+      const manifest = JSON.parse(readFileSync27(manifestPath, "utf-8"));
       const entry = manifest.plugins?.find((p) => p.name === pluginName);
       if (!entry?.id)
         return null;
@@ -12863,6 +13234,7 @@ function setCoworkPluginEnabled(pluginsDir, enabled) {
 var PLUGIN_NAME2 = "runwork", PLUGIN_VERSION2 = "1.0.0", PLUGIN_DESCRIPTION = "Skills and tools from your Runwork workspace", PLUGIN_AUTHOR_NAME = "Runwork", ClaudeDesktopAdapter;
 var init_claude_desktop = __esm(() => {
   init_types();
+  init_transcript_sources();
   init_session_digest();
   init_json_config();
   init_instruction_hint();
@@ -13003,7 +13375,7 @@ var init_claude_desktop = __esm(() => {
       let desktopConfig = {};
       if (existsSync34(configPath)) {
         try {
-          desktopConfig = JSON.parse(readFileSync26(configPath, "utf-8"));
+          desktopConfig = JSON.parse(readFileSync27(configPath, "utf-8"));
         } catch {}
       }
       if (!desktopConfig.preferences)
@@ -13042,7 +13414,7 @@ var init_claude_desktop = __esm(() => {
         if (!existsSync34(manifestPath))
           continue;
         try {
-          const manifest = JSON.parse(readFileSync26(manifestPath, "utf-8"));
+          const manifest = JSON.parse(readFileSync27(manifestPath, "utf-8"));
           if (!Array.isArray(manifest.plugins))
             continue;
           const ours = manifest.plugins.filter((p) => isRunworkRpmPluginName(p.name));
@@ -13136,7 +13508,7 @@ var init_claude_desktop = __esm(() => {
                   const filePath = join28(projPath, file);
                   let stat;
                   try {
-                    stat = statSync5(filePath);
+                    stat = statSync6(filePath);
                   } catch {
                     continue;
                   }
@@ -13144,7 +13516,7 @@ var init_claude_desktop = __esm(() => {
                     continue;
                   let content;
                   try {
-                    content = readFileSync26(filePath, "utf-8");
+                    content = readFileSync27(filePath, "utf-8");
                   } catch {
                     continue;
                   }
@@ -13161,10 +13533,13 @@ var init_claude_desktop = __esm(() => {
         return null;
       }
     }
+    transcriptSources() {
+      return [{ path: getCoworkBaseDir(), kind: "dir" }];
+    }
     async listSessions(sinceISO) {
       try {
         const baseDir = getCoworkBaseDir();
-        if (!existsSync34(baseDir))
+        if (!transcriptSourcesReadable(this.transcriptSources()))
           return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         let accounts;
@@ -13181,7 +13556,7 @@ var init_claude_desktop = __esm(() => {
               const metaPath = join28(orgPath, entry);
               let meta;
               try {
-                meta = JSON.parse(readFileSync26(metaPath, "utf-8"));
+                meta = JSON.parse(readFileSync27(metaPath, "utf-8"));
               } catch {
                 continue;
               }
@@ -13200,7 +13575,7 @@ var init_claude_desktop = __esm(() => {
                   const filePath = join28(projPath, file);
                   let stat;
                   try {
-                    stat = statSync5(filePath);
+                    stat = statSync6(filePath);
                   } catch {
                     continue;
                   }
@@ -13217,7 +13592,8 @@ var init_claude_desktop = __esm(() => {
                 title: typeof meta.title === "string" && meta.title ? meta.title : null,
                 startedAt: typeof meta.createdAt === "number" ? new Date(meta.createdAt).toISOString() : null,
                 lastActivityAt: new Date(lastActivityMs).toISOString(),
-                transcriptPath
+                transcriptPath,
+                surface: "local-agent"
               });
             }
           }
@@ -13283,7 +13659,7 @@ var init_claude_desktop = __esm(() => {
         const scheduledTasksPath = join28(claudeAppDir, "scheduled-tasks.json");
         if (existsSync34(scheduledTasksPath)) {
           try {
-            const raw = readFileSync26(scheduledTasksPath, "utf-8");
+            const raw = readFileSync27(scheduledTasksPath, "utf-8");
             const parsed = JSON.parse(raw);
             const tasks = Array.isArray(parsed) ? parsed : Object.values(parsed);
             for (const task of tasks) {
@@ -13327,7 +13703,7 @@ var init_claude_desktop = __esm(() => {
         }
         const versionPath = join28(claudeAppDir, "claude-code", "sdk-version");
         if (existsSync34(versionPath)) {
-          return readFileSync26(versionPath, "utf-8").trim();
+          return readFileSync27(versionPath, "utf-8").trim();
         }
         return null;
       } catch {
@@ -13341,7 +13717,7 @@ var init_claude_desktop = __esm(() => {
             continue;
           const orgPath = join28(baseDir, orgDir);
           try {
-            if (!statSync5(orgPath).isDirectory())
+            if (!statSync6(orgPath).isDirectory())
               continue;
           } catch {
             continue;
@@ -13351,7 +13727,7 @@ var init_claude_desktop = __esm(() => {
               continue;
             const userPath = join28(orgPath, userDir);
             try {
-              if (!statSync5(userPath).isDirectory())
+              if (!statSync6(userPath).isDirectory())
                 continue;
             } catch {
               continue;
@@ -13360,7 +13736,7 @@ var init_claude_desktop = __esm(() => {
               if (!file.endsWith(".json"))
                 continue;
               try {
-                const session = JSON.parse(readFileSync26(join28(userPath, file), "utf-8"));
+                const session = JSON.parse(readFileSync27(join28(userPath, file), "utf-8"));
                 onSession(session);
               } catch {
                 continue;
@@ -13479,6 +13855,7 @@ var init_cursor = __esm(async () => {
   init_skill_removal();
   init_json_config();
   init_detection();
+  init_transcript_sources();
   await init_sqlite();
   CursorAdapter = class CursorAdapter extends RegistryDetectedAdapter {
     name = "Cursor";
@@ -13737,6 +14114,16 @@ ${instructions}`;
         return null;
       }
     }
+    transcriptSources() {
+      return [
+        {
+          path: this.globalStorageDbPath(),
+          kind: "file",
+          tool: "sqlite",
+          available: sqliteAvailable
+        }
+      ];
+    }
     globalStorageDbPath() {
       const os2 = platform5();
       if (os2 === "darwin") {
@@ -13764,7 +14151,7 @@ ${instructions}`;
     async listSessions(sinceISO) {
       try {
         const dbPath = this.globalStorageDbPath();
-        if (!existsSync35(dbPath) || !sqliteAvailable())
+        if (!transcriptSourcesReadable(this.transcriptSources()))
           return null;
         const rows = queryReadonlySqlite(dbPath, `SELECT json_object('id', json_extract(value,'$.composerId'), 'name', json_extract(value,'$.name'), 'createdAt', json_extract(value,'$.createdAt'), 'lastUpdatedAt', json_extract(value,'$.lastUpdatedAt')) FROM cursorDiskKV WHERE key LIKE 'composerData:%'`);
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
@@ -13893,7 +14280,7 @@ ${hint}`;
 });
 
 // src/agents/codex.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync21, readdirSync as readdirSync11, readFileSync as readFileSync27, statSync as statSync6, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync21, readdirSync as readdirSync11, readFileSync as readFileSync28, statSync as statSync7, writeFileSync as writeFileSync21 } from "fs";
 import { basename as basename3, join as join31 } from "path";
 import { homedir as homedir13 } from "os";
 import { parse, stringify } from "smol-toml";
@@ -13903,6 +14290,7 @@ function isRunworkManagedCodexKey(key) {
 var CodexAdapter, CodexDesktopAdapter;
 var init_codex = __esm(async () => {
   init_types();
+  init_transcript_sources();
   init_session_digest();
   init_session_listing();
   init_skill_removal();
@@ -13925,7 +14313,7 @@ var init_codex = __esm(async () => {
       const configPath = join31(homedir13(), ".codex", "config.toml");
       let parsed = {};
       if (existsSync37(configPath)) {
-        parsed = parse(readFileSync27(configPath, "utf-8"));
+        parsed = parse(readFileSync28(configPath, "utf-8"));
       }
       if (!parsed.mcp_servers || typeof parsed.mcp_servers !== "object") {
         parsed.mcp_servers = {};
@@ -13980,7 +14368,7 @@ var init_codex = __esm(async () => {
       const configPath = scope === "project" ? join31(process.cwd(), ".codex", "config.toml") : join31(homedir13(), ".codex", "config.toml");
       let parsed = {};
       if (existsSync37(configPath)) {
-        parsed = parse(readFileSync27(configPath, "utf-8"));
+        parsed = parse(readFileSync28(configPath, "utf-8"));
       }
       if (config.modelPreference) {
         parsed.model = config.modelPreference;
@@ -14039,7 +14427,7 @@ var init_codex = __esm(async () => {
       const configPath = join31(homedir13(), ".codex", "config.toml");
       if (existsSync37(configPath)) {
         try {
-          const parsed = parse(readFileSync27(configPath, "utf-8"));
+          const parsed = parse(readFileSync28(configPath, "utf-8"));
           if (parsed.mcp_servers && typeof parsed.mcp_servers === "object") {
             const mcpServers = parsed.mcp_servers;
             for (const key of Object.keys(mcpServers)) {
@@ -14088,7 +14476,7 @@ var init_codex = __esm(async () => {
         if (messageCount === 0) {
           const historyPath = join31(codexDir, "history.jsonl");
           if (existsSync37(historyPath)) {
-            const content = readFileSync27(historyPath, "utf-8").trim();
+            const content = readFileSync28(historyPath, "utf-8").trim();
             if (content) {
               for (const line of content.split(/[\r\n]+/)) {
                 try {
@@ -14121,6 +14509,12 @@ var init_codex = __esm(async () => {
         return null;
       }
     }
+    transcriptRoot() {
+      return join31(homedir13(), ".codex", "sessions");
+    }
+    transcriptSources() {
+      return [{ path: this.transcriptRoot(), kind: "dir" }];
+    }
     scanRolloutActivity(sinceMs) {
       const days = new Set;
       const result = {
@@ -14131,7 +14525,7 @@ var init_codex = __esm(async () => {
         latestMs: 0,
         activeDays: []
       };
-      const sessionsDir = join31(homedir13(), ".codex", "sessions");
+      const sessionsDir = this.transcriptRoot();
       if (!existsSync37(sessionsDir))
         return result;
       const files = [];
@@ -14154,7 +14548,7 @@ var init_codex = __esm(async () => {
       for (const file of files) {
         let stat;
         try {
-          stat = statSync6(file);
+          stat = statSync7(file);
         } catch {
           continue;
         }
@@ -14162,7 +14556,7 @@ var init_codex = __esm(async () => {
           continue;
         let content;
         try {
-          content = readFileSync27(file, "utf-8");
+          content = readFileSync28(file, "utf-8");
         } catch {
           continue;
         }
@@ -14221,8 +14615,8 @@ var init_codex = __esm(async () => {
     }
     async readSessionDigests(sinceISO) {
       try {
-        const sessionsDir = join31(homedir13(), ".codex", "sessions");
-        if (!existsSync37(sessionsDir))
+        const sessionsDir = this.transcriptRoot();
+        if (!transcriptSourcesReadable(this.transcriptSources()))
           return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         const files = [];
@@ -14246,7 +14640,7 @@ var init_codex = __esm(async () => {
         for (const file of files) {
           let stat;
           try {
-            stat = statSync6(file);
+            stat = statSync7(file);
           } catch {
             continue;
           }
@@ -14254,7 +14648,7 @@ var init_codex = __esm(async () => {
             continue;
           let content;
           try {
-            content = readFileSync27(file, "utf-8");
+            content = readFileSync28(file, "utf-8");
           } catch {
             continue;
           }
@@ -14269,8 +14663,8 @@ var init_codex = __esm(async () => {
     }
     async listSessions(sinceISO) {
       try {
-        const sessionsDir = join31(homedir13(), ".codex", "sessions");
-        if (!existsSync37(sessionsDir))
+        const sessionsDir = this.transcriptRoot();
+        if (!transcriptSourcesReadable(this.transcriptSources()))
           return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         const files = [];
@@ -14294,7 +14688,7 @@ var init_codex = __esm(async () => {
         for (const file of files) {
           let stat;
           try {
-            stat = statSync6(file);
+            stat = statSync7(file);
           } catch {
             continue;
           }
@@ -14313,7 +14707,8 @@ var init_codex = __esm(async () => {
             title: scanned.title,
             startedAt: scanned.firstTimestamp,
             lastActivityAt: resolveLastActivity(file, stat.mtimeMs),
-            transcriptPath: file
+            transcriptPath: file,
+            surface: scanned.surface ?? null
           });
         }
         return sessions;
@@ -14325,7 +14720,7 @@ var init_codex = __esm(async () => {
       try {
         const versionPath = join31(homedir13(), ".codex", "version.json");
         if (existsSync37(versionPath)) {
-          const data = JSON.parse(readFileSync27(versionPath, "utf-8"));
+          const data = JSON.parse(readFileSync28(versionPath, "utf-8"));
           return data.latest_version ?? null;
         }
       } catch {}
@@ -14333,7 +14728,7 @@ var init_codex = __esm(async () => {
     }
     async readSkillUsage(lastSyncAt) {
       try {
-        const sessionsDir = join31(homedir13(), ".codex", "sessions");
+        const sessionsDir = this.transcriptRoot();
         if (!existsSync37(sessionsDir))
           return null;
         const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
@@ -14350,7 +14745,7 @@ var init_codex = __esm(async () => {
             if (entry.endsWith(".jsonl")) {
               let fileStat;
               try {
-                fileStat = statSync6(fullPath);
+                fileStat = statSync7(fullPath);
               } catch {
                 continue;
               }
@@ -14359,7 +14754,7 @@ var init_codex = __esm(async () => {
               this.parseRolloutForSkills(fullPath, sinceMs, skillCounts);
             } else {
               try {
-                if (statSync6(fullPath).isDirectory())
+                if (statSync7(fullPath).isDirectory())
                   walkDir2(fullPath);
               } catch {
                 continue;
@@ -14386,7 +14781,7 @@ var init_codex = __esm(async () => {
     parseRolloutForSkills(filePath, sinceMs, skillCounts) {
       let content;
       try {
-        content = readFileSync27(filePath, "utf-8");
+        content = readFileSync28(filePath, "utf-8");
       } catch {
         return;
       }
@@ -14439,7 +14834,7 @@ var init_codex = __esm(async () => {
       let state = {};
       if (existsSync37(statePath)) {
         try {
-          state = JSON.parse(readFileSync27(statePath, "utf-8"));
+          state = JSON.parse(readFileSync28(statePath, "utf-8"));
         } catch {
           return "app_running";
         }
@@ -14474,17 +14869,11 @@ var init_codex = __esm(async () => {
   CodexDesktopAdapter = class CodexDesktopAdapter extends CodexAdapter {
     name = "Codex";
     slug = "codex-app";
-    async readUsageStats() {
-      return null;
-    }
-    async listSessions() {
-      return null;
-    }
   };
 });
 
 // src/agents/cline.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync22, readFileSync as readFileSync28, readdirSync as readdirSync12, rmSync as rmSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync22, readFileSync as readFileSync29, readdirSync as readdirSync12, rmSync as rmSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync22 } from "fs";
 import { join as join32 } from "path";
 import { homedir as homedir14 } from "os";
 var ClineAdapter;
@@ -14545,7 +14934,7 @@ var init_cline = __esm(() => {
       let state = {};
       if (existsSync38(globalStatePath)) {
         try {
-          state = JSON.parse(readFileSync28(globalStatePath, "utf-8"));
+          state = JSON.parse(readFileSync29(globalStatePath, "utf-8"));
         } catch {}
       }
       if (config.modelPreference) {
@@ -14602,7 +14991,7 @@ var init_cline = __esm(() => {
 });
 
 // src/agents/gemini.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync23, readdirSync as readdirSync13, readFileSync as readFileSync29, statSync as statSync7, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync23, readdirSync as readdirSync13, readFileSync as readFileSync30, statSync as statSync8, writeFileSync as writeFileSync23 } from "fs";
 import { basename as basename4, join as join33 } from "path";
 import { homedir as homedir15 } from "os";
 var GeminiAdapter;
@@ -14612,6 +15001,7 @@ var init_gemini = __esm(() => {
   init_skill_removal();
   init_trash();
   init_types();
+  init_transcript_sources();
   init_instruction_hint();
   init_json_config();
   init_detection();
@@ -14661,7 +15051,7 @@ var init_gemini = __esm(() => {
       let settings = {};
       if (existsSync39(settingsPath)) {
         try {
-          settings = JSON.parse(readFileSync29(settingsPath, "utf-8"));
+          settings = JSON.parse(readFileSync30(settingsPath, "utf-8"));
         } catch {}
       }
       if (config.modelPreference) {
@@ -14684,7 +15074,7 @@ var init_gemini = __esm(() => {
     }
     async readUsageStats(lastSyncAt) {
       try {
-        const tmpDir = join33(homedir15(), ".gemini", "tmp");
+        const tmpDir = this.transcriptRoot();
         if (!existsSync39(tmpDir))
           return null;
         const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
@@ -14714,7 +15104,7 @@ var init_gemini = __esm(() => {
             const filePath = join33(chatsDir, file.name);
             let stat;
             try {
-              stat = statSync7(filePath);
+              stat = statSync8(filePath);
             } catch {
               continue;
             }
@@ -14722,7 +15112,7 @@ var init_gemini = __esm(() => {
               continue;
             let session;
             try {
-              session = JSON.parse(readFileSync29(filePath, "utf-8"));
+              session = JSON.parse(readFileSync30(filePath, "utf-8"));
             } catch {
               continue;
             }
@@ -14762,8 +15152,14 @@ var init_gemini = __esm(() => {
         return null;
       }
     }
+    transcriptRoot() {
+      return join33(homedir15(), ".gemini", "tmp");
+    }
+    transcriptSources() {
+      return [{ path: this.transcriptRoot(), kind: "dir" }];
+    }
     *chatFiles(sinceMs) {
-      const tmpDir = join33(homedir15(), ".gemini", "tmp");
+      const tmpDir = this.transcriptRoot();
       if (!existsSync39(tmpDir))
         return;
       let projects;
@@ -14788,7 +15184,7 @@ var init_gemini = __esm(() => {
           const filePath = join33(chatsDir, file);
           let stat;
           try {
-            stat = statSync7(filePath);
+            stat = statSync8(filePath);
           } catch {
             continue;
           }
@@ -14800,12 +15196,14 @@ var init_gemini = __esm(() => {
     }
     async listSessions(sinceISO) {
       try {
+        if (!transcriptSourcesReadable(this.transcriptSources()))
+          return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         const sessions = [];
         for (const { filePath, project, mtimeMs } of this.chatFiles(sinceMs)) {
           let session;
           try {
-            session = JSON.parse(readFileSync29(filePath, "utf-8"));
+            session = JSON.parse(readFileSync30(filePath, "utf-8"));
           } catch {
             continue;
           }
@@ -14839,12 +15237,14 @@ var init_gemini = __esm(() => {
     }
     async readSessionDigests(sinceISO) {
       try {
+        if (!transcriptSourcesReadable(this.transcriptSources()))
+          return null;
         const sinceMs = sinceISO ? new Date(sinceISO).getTime() : 0;
         const digests = [];
         for (const { filePath, project } of this.chatFiles(sinceMs)) {
           let content;
           try {
-            content = readFileSync29(filePath, "utf-8");
+            content = readFileSync30(filePath, "utf-8");
           } catch {
             continue;
           }
@@ -14884,6 +15284,7 @@ var init_generic_adapter = __esm(() => {
   init_json_config();
   init_instruction_hint();
   init_registry();
+  init_detection_probes();
   init_detection();
   init_trash();
   GenericAgentAdapter = class GenericAgentAdapter extends RegistryDetectedAdapter {
@@ -14908,7 +15309,13 @@ var init_generic_adapter = __esm(() => {
     async writeMcpServers(servers, _scope) {
       if (!this.def.mcpConfigPath)
         return;
-      const filePath = join34(homedir16(), resolvePlatformString(this.def.mcpConfigPath) || "");
+      const resolved = resolvePlatformString(this.def.mcpConfigPath) || "";
+      const expanded = expandWindowsPathTemplate(resolved, {
+        "%APPDATA%": process.env.APPDATA,
+        "%LOCALAPPDATA%": process.env.LOCALAPPDATA,
+        "%ProgramFiles%": process.env.ProgramFiles
+      });
+      const filePath = expanded.needsHomeJoin ? join34(homedir16(), expanded.path) : expanded.path;
       if (!filePath)
         return;
       const entries = {};
@@ -15061,6 +15468,43 @@ var init_detect = __esm(async () => {
   ALL_ADAPTERS = buildAllAdapters();
 });
 
+// ../../shared/types/local-conversations.ts
+function describeScanOutcome(outcome) {
+  switch (outcome.status) {
+    case "ok":
+    case "no-reader":
+      return null;
+    case "missing-dir":
+      return `no conversation history found${outcome.path ? ` at ${outcome.path}` : ""}`;
+    case "permission-denied":
+      return `access denied${outcome.path ? ` to ${outcome.path}` : ""}`;
+    case "missing-tool":
+      return `needs ${outcome.detail ?? "a tool that is not installed"}`;
+    case "error":
+      return `could not be read${outcome.detail ? `: ${outcome.detail}` : ""}`;
+  }
+}
+function scanOutcomeNeedsAttention(outcome) {
+  return outcome.status === "permission-denied" || outcome.status === "error";
+}
+function describeStoreOutcome(outcome) {
+  if (outcome.status === "orphaned") {
+    return `not read: nothing on this machine was detected as ${outcome.members.join(" or ")}`;
+  }
+  if (outcome.status === "ok")
+    return null;
+  return describeScanOutcome({
+    agentSlug: outcome.storeId,
+    status: outcome.status,
+    sessions: outcome.sessions,
+    path: outcome.path,
+    ...outcome.detail ? { detail: outcome.detail } : {}
+  });
+}
+function storeOutcomeNeedsAttention(outcome) {
+  return outcome.status === "orphaned" || outcome.status === "permission-denied" || outcome.status === "error";
+}
+
 // src/utils/insight-id.ts
 import { createHash as createHash3 } from "node:crypto";
 function computeInsightId(userSeed, localKey) {
@@ -15072,7 +15516,7 @@ function insightLocalKey(teaches, slug) {
 var init_insight_id = () => {};
 
 // src/reflect/insight-store.ts
-import { existsSync as existsSync41, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync31 } from "fs";
 import { join as join35 } from "path";
 import { homedir as homedir17 } from "os";
 function storePath2() {
@@ -15083,7 +15527,7 @@ function readAll() {
   if (!existsSync41(path2))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync30(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync31(path2, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -15128,7 +15572,7 @@ var init_insight_store = __esm(() => {
 var DEFAULT_DAILY_TIER2_BUDGET = 3;
 
 // src/reflect/cadence.ts
-import { existsSync as existsSync42, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync32 } from "fs";
 import { join as join36 } from "path";
 import { homedir as homedir18 } from "os";
 function remainingDailyAnalyses(state, now = new Date, budget = DEFAULT_DAILY_TIER2_BUDGET) {
@@ -15150,7 +15594,7 @@ function loadCadenceState() {
     const p = statePath();
     if (!existsSync42(p))
       return { ...DEFAULT_STATE };
-    const parsed = JSON.parse(readFileSync31(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync32(p, "utf-8"));
     const state = { ...DEFAULT_STATE, ...parsed && typeof parsed === "object" ? parsed : {} };
     if (state.enabled === false && state.disabledByUser !== true) {
       state.enabled = true;
@@ -15211,7 +15655,7 @@ __export(exports_run_log, {
   RUN_LOG_CAP: () => RUN_LOG_CAP,
   ANALYST_ERROR_MAX_CHARS: () => ANALYST_ERROR_MAX_CHARS
 });
-import { existsSync as existsSync43, mkdirSync as mkdirSync25, readFileSync as readFileSync32, readdirSync as readdirSync15, statSync as statSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync25, readFileSync as readFileSync33, readdirSync as readdirSync15, statSync as statSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync25 } from "fs";
 import { dirname as dirname10, join as join37 } from "path";
 import { homedir as homedir19 } from "os";
 function runLogPath() {
@@ -15222,7 +15666,7 @@ function loadRunLog() {
     const p = runLogPath();
     if (!existsSync43(p))
       return [];
-    const parsed = JSON.parse(readFileSync32(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync33(p, "utf-8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
@@ -15355,7 +15799,7 @@ function acquireRunLock(nowMs = Date.now()) {
       return true;
     } catch {
       try {
-        if (nowMs - statSync8(p).mtimeMs < RUN_STALE_MS)
+        if (nowMs - statSync9(p).mtimeMs < RUN_STALE_MS)
           return false;
         unlinkSync7(p);
       } catch {
@@ -15390,7 +15834,7 @@ var init_run_log = __esm(() => {
 });
 
 // src/reflect/conversation-queue.ts
-import { existsSync as existsSync44, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync34 } from "fs";
 import { join as join38 } from "path";
 import { homedir as homedir20 } from "os";
 function conversationKey(c) {
@@ -15404,7 +15848,7 @@ function loadQueueState() {
     const p = queuePath();
     if (!existsSync44(p))
       return { entries: {} };
-    const parsed = JSON.parse(readFileSync33(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync34(p, "utf-8"));
     if (parsed && typeof parsed === "object" && parsed.entries && typeof parsed.entries === "object") {
       return { entries: parsed.entries };
     }
@@ -15612,7 +16056,7 @@ function parseHandoffResult(kind, text2) {
 }
 
 // src/reflect/model-repair.ts
-import { existsSync as existsSync45, readFileSync as readFileSync34, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync35, writeFileSync as writeFileSync26 } from "fs";
 import { homedir as homedir21 } from "os";
 import { join as join39 } from "path";
 function codexConfigPath() {
@@ -15649,7 +16093,7 @@ function repairCodexModelPin() {
     const path2 = codexConfigPath();
     if (!existsSync45(path2))
       return null;
-    const current = readFileSync34(path2, "utf-8");
+    const current = readFileSync35(path2, "utf-8");
     const stripped = stripModelPin(current);
     if (!stripped)
       return null;
@@ -16043,6 +16487,7 @@ var init_reflect = __esm(async () => {
   init_store();
   init_client();
   init_resolve();
+  init_transcript_sources();
   init_session_digest();
   init_insight_id();
   init_insight_store();
@@ -16107,13 +16552,13 @@ var init_reflect = __esm(async () => {
     const seen = new Set;
     for (const adapter2 of adapters) {
       if (!adapter2.readSessionDigests) {
-        perAgent.push({ slug: adapter2.slug, sessions: "unsupported" });
+        perAgent.push({ agentSlug: adapter2.slug, status: "no-reader", sessions: null });
         continue;
       }
       try {
         const sessions = await adapter2.readSessionDigests(sinceISO);
         if (sessions === null) {
-          perAgent.push({ slug: adapter2.slug, sessions: "unsupported" });
+          perAgent.push(diagnoseTranscriptRead(adapter2));
           continue;
         }
         let added = 0;
@@ -16125,20 +16570,26 @@ var init_reflect = __esm(async () => {
           digests.push(s);
           added++;
         }
-        perAgent.push({ slug: adapter2.slug, sessions: added });
-      } catch {
-        perAgent.push({ slug: adapter2.slug, sessions: "error" });
+        perAgent.push({ agentSlug: adapter2.slug, status: "ok", sessions: added });
+      } catch (err) {
+        perAgent.push(diagnoseTranscriptRead(adapter2, err));
       }
     }
     if (!json) {
       console.error(bold(`
 Reflection over the last ${days} days`));
-      for (const a of perAgent)
-        console.error(`  ${cyan(a.slug)}: ${a.sessions === "unsupported" ? gray("no transcript reader") : a.sessions === "error" ? red("read error") : `${a.sessions} session(s)`}`);
+      for (const a of perAgent) {
+        const reason = describeScanOutcome(a);
+        if (reason === null) {
+          console.error(`  ${cyan(a.agentSlug)}: ${a.status === "no-reader" ? gray("no transcript reader") : `${a.sessions} session(s)`}`);
+        } else {
+          console.error(`  ${cyan(a.agentSlug)}: ${scanOutcomeNeedsAttention(a) ? red(reason) : gray(reason)}`);
+        }
+      }
     }
     if (digests.length === 0) {
       if (json) {
-        jsonOut({ insights: [], reason: "no-sessions" });
+        jsonOut({ insights: [], reason: "no-sessions", perAgent });
         return;
       }
       console.error(yellow(`
@@ -16465,7 +16916,214 @@ ${all.length} insight(s) from your recent work:
   });
 });
 
+// src/agents/transcript-stores.ts
+function joiner(input) {
+  const sep4 = input.sep ?? (input.platform === "win32" ? "\\" : "/");
+  return (...parts) => parts.join(sep4);
+}
+function home(input) {
+  return input.homeDir.replace(/[/\\]+$/, "");
+}
+function appDataRoot(input) {
+  const join41 = joiner(input);
+  if (input.platform === "darwin")
+    return join41(home(input), "Library", "Application Support");
+  if (input.platform === "win32") {
+    return input.appData ?? join41(home(input), "AppData", "Roaming");
+  }
+  return join41(home(input), ".config");
+}
+function localAppDataRoot(input) {
+  const join41 = joiner(input);
+  return input.localAppData ?? join41(home(input), "AppData", "Local");
+}
+function codexOriginator(head) {
+  for (const line of head.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let o;
+    try {
+      o = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (o.type !== "session_meta")
+      continue;
+    const payload = o.payload;
+    return typeof payload?.originator === "string" ? payload.originator : null;
+  }
+  return null;
+}
+function claudeEntrypoint(head) {
+  for (const line of head.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let o;
+    try {
+      o = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof o.entrypoint === "string")
+      return o.entrypoint;
+  }
+  return null;
+}
+function attributeCodexOriginator(marker) {
+  switch (marker) {
+    case "Codex Desktop":
+    case "codex_work_desktop":
+      return "codex-app";
+    case "codex-tui":
+    case "codex_exec":
+    case "Claude Code":
+      return "codex";
+    default:
+      return null;
+  }
+}
+function attributeClaudeEntrypoint(marker) {
+  switch (marker) {
+    case "cli":
+    case "sdk-cli":
+      return "claude-code";
+    case "claude-desktop":
+    case "local-agent":
+      return "claude-desktop";
+    default:
+      return null;
+  }
+}
+function resolveTranscriptStores(input) {
+  const resolved = [];
+  for (const def of TRANSCRIPT_STORES) {
+    const path2 = def.path(input);
+    if (path2 === null)
+      continue;
+    resolved.push({ def, path: path2, altPaths: def.altPaths?.(input) ?? [] });
+  }
+  return resolved;
+}
+function familyMembers(family, table = TRANSCRIPT_STORES) {
+  const slugs = new Set;
+  for (const store of table) {
+    if (store.family !== family)
+      continue;
+    for (const member of store.members)
+      slugs.add(member);
+  }
+  return [...slugs];
+}
+function isStoreUnlocked(def, detectedSlugs, table = TRANSCRIPT_STORES) {
+  const detected = detectedSlugs instanceof Set ? detectedSlugs : new Set(detectedSlugs);
+  return familyMembers(def.family, table).some((m) => detected.has(m));
+}
+function telemetryOwner(def, detectedSlugs) {
+  const detected = detectedSlugs instanceof Set ? detectedSlugs : new Set(detectedSlugs);
+  if (detected.has(def.readerSlug))
+    return def.readerSlug;
+  return def.members.find((m) => detected.has(m)) ?? null;
+}
+function suppressedStoreReaders(detectedSlugs, sharesImplementation, table = TRANSCRIPT_STORES) {
+  const detected = detectedSlugs instanceof Set ? detectedSlugs : new Set(detectedSlugs);
+  const suppressed = new Set;
+  for (const store of table) {
+    const owner = telemetryOwner(store, detected);
+    if (owner === null)
+      continue;
+    for (const member of store.members) {
+      if (member === owner || !detected.has(member))
+        continue;
+      if (sharesImplementation(member, owner))
+        suppressed.add(member);
+    }
+  }
+  return suppressed;
+}
+function attributeTranscript(def, head) {
+  if (head === null || !def.marker) {
+    return { agentSlug: def.defaultMember, marker: null, recognised: false };
+  }
+  const marker = def.marker(head);
+  if (marker === null)
+    return { agentSlug: def.defaultMember, marker: null, recognised: false };
+  const slug = def.attribute?.(marker) ?? null;
+  return slug === null ? { agentSlug: def.defaultMember, marker, recognised: false } : { agentSlug: slug, marker, recognised: true };
+}
+var CODEX_HEAD, CLAUDE_HEAD, TRANSCRIPT_STORES;
+var init_transcript_stores = __esm(() => {
+  CODEX_HEAD = 256 * 1024;
+  CLAUDE_HEAD = 64 * 1024;
+  TRANSCRIPT_STORES = [
+    {
+      id: "codex/sessions",
+      readerSlug: "codex",
+      family: "codex",
+      members: ["codex", "codex-app"],
+      defaultMember: "codex",
+      kind: "dir",
+      path: (i) => joiner(i)(home(i), ".codex", "sessions"),
+      matches: (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"),
+      headBytes: CODEX_HEAD,
+      marker: codexOriginator,
+      attribute: attributeCodexOriginator
+    },
+    {
+      id: "claude/projects",
+      readerSlug: "claude-code",
+      family: "claude",
+      members: ["claude-code", "claude-desktop"],
+      defaultMember: "claude-code",
+      kind: "dir",
+      path: (i) => joiner(i)(home(i), ".claude", "projects"),
+      matches: (n) => n.endsWith(".jsonl"),
+      subordinate: (rel) => rel.split(/[\\/]/).length > 2,
+      headBytes: CLAUDE_HEAD,
+      marker: claudeEntrypoint,
+      attribute: attributeClaudeEntrypoint
+    },
+    {
+      id: "claude/cowork",
+      readerSlug: "claude-desktop",
+      family: "claude",
+      members: ["claude-desktop"],
+      defaultMember: "claude-desktop",
+      kind: "dir",
+      path: (i) => joiner(i)(appDataRoot(i), "Claude", "local-agent-mode-sessions"),
+      altPaths: (i) => i.platform === "win32" ? [joiner(i)(localAppDataRoot(i), "Packages", "Claude_pzs8sxrjxfjjc", "LocalCache", "Roaming", "Claude", "local-agent-mode-sessions")] : [],
+      matches: (n) => n.endsWith(".jsonl"),
+      headBytes: CLAUDE_HEAD,
+      marker: claudeEntrypoint,
+      attribute: attributeClaudeEntrypoint,
+      note: "macOS TCC can refuse this while it still exists"
+    },
+    {
+      id: "gemini/tmp",
+      readerSlug: "gemini",
+      family: "gemini",
+      members: ["gemini"],
+      defaultMember: "gemini",
+      kind: "dir",
+      path: (i) => joiner(i)(home(i), ".gemini", "tmp"),
+      matches: (n) => n.endsWith(".json")
+    },
+    {
+      id: "cursor/state",
+      readerSlug: "cursor",
+      family: "cursor",
+      members: ["cursor"],
+      defaultMember: "cursor",
+      kind: "file",
+      path: (i) => joiner(i)(appDataRoot(i), "Cursor", "User", "globalStorage", "state.vscdb"),
+      tool: "sqlite"
+    }
+  ];
+});
+
 // src/reflect/conversation-registry.ts
+import { homedir as homedir22, platform as platform7 } from "os";
 function computeStatus(lastActivityAt, nowMs, idleMinutes = DEFAULT_IDLE_MINUTES) {
   const lastMs = new Date(lastActivityAt).getTime();
   if (Number.isNaN(lastMs))
@@ -16496,43 +17154,114 @@ function mergeSessionListings(listings, opts) {
     status: isFreshEndStamp(s.endedAt, s.lastActivityAt) ? "finished" : computeStatus(s.lastActivityAt, opts.nowMs, opts.idleMinutes)
   }));
 }
+function machineStores(opts) {
+  return opts.stores ?? resolveTranscriptStores({
+    platform: platform7(),
+    homeDir: homedir22(),
+    appData: process.env.APPDATA ?? null,
+    localAppData: process.env.LOCALAPPDATA ?? null
+  });
+}
+function attributeListing(store, sessions) {
+  if (!store.def.attribute)
+    return sessions;
+  return sessions.map((s) => {
+    const surface = s.surface ?? null;
+    const slug = surface === null ? null : store.def.attribute?.(surface) ?? null;
+    return {
+      ...s,
+      agentSlug: slug ?? store.def.defaultMember,
+      surface
+    };
+  });
+}
 async function listLocalConversations(opts = {}) {
-  const adapters = await detectAgents();
+  const detected = opts.detected ?? (await detectAgents()).map((a) => a.slug);
+  const detectedSet = new Set(detected);
   const sinceISO = opts.sinceISO ?? null;
+  const maxPerStore = opts.maxPerStore ?? DEFAULT_MAX_PER_STORE;
   const listings = [];
-  const perAgent = [];
-  for (const adapter2 of adapters) {
-    if (!adapter2.listSessions) {
-      perAgent.push({ slug: adapter2.slug, sessions: "unsupported" });
+  const perStore = [];
+  const stores = machineStores(opts);
+  const table = stores.map((s) => s.def);
+  for (const store of stores) {
+    const base = {
+      storeId: store.def.id,
+      family: store.def.family,
+      members: [...familyMembers(store.def.family, table)],
+      path: store.path
+    };
+    if (!isStoreUnlocked(store.def, detectedSet, table)) {
+      perStore.push({ ...base, status: "orphaned", sessions: null });
+      continue;
+    }
+    const reader = (opts.readerFor ?? getAdapterBySlug)(store.def.readerSlug);
+    if (!reader?.listSessions) {
+      perStore.push({ ...base, status: "no-reader", sessions: null });
       continue;
     }
     try {
-      const sessions = await adapter2.listSessions(sinceISO);
+      const sessions = await reader.listSessions(sinceISO);
       if (sessions === null) {
-        perAgent.push({ slug: adapter2.slug, sessions: "unsupported" });
+        const outcome = diagnoseTranscriptRead(reader);
+        perStore.push({ ...base, status: outcome.status, sessions: null, ...outcome.detail ? { detail: outcome.detail } : {} });
         continue;
       }
-      listings.push(sessions);
-      perAgent.push({ slug: adapter2.slug, sessions: sessions.length });
-    } catch {
-      perAgent.push({ slug: adapter2.slug, sessions: "error" });
+      const attributed = attributeListing(store, sessions).sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt)).slice(0, maxPerStore);
+      listings.push(attributed);
+      perStore.push({
+        ...base,
+        status: "ok",
+        sessions: attributed.length,
+        ...sessions.length > attributed.length ? { truncated: sessions.length } : {}
+      });
+    } catch (err) {
+      const outcome = diagnoseTranscriptRead(reader, err);
+      perStore.push({ ...base, status: outcome.status, sessions: null, ...outcome.detail ? { detail: outcome.detail } : {} });
     }
   }
   const conversations = mergeSessionListings(listings, {
     nowMs: opts.nowMs ?? Date.now(),
     idleMinutes: opts.idleMinutes
   });
-  return { conversations, perAgent };
+  return { conversations, perAgent: derivePerAgent(perStore, conversations), perStore };
+}
+function derivePerAgent(perStore, conversations) {
+  const counts = new Map;
+  for (const c of conversations)
+    counts.set(c.agentSlug, (counts.get(c.agentSlug) ?? 0) + 1);
+  const rows = new Map;
+  for (const store of perStore) {
+    for (const slug of store.members) {
+      const existing = rows.get(slug);
+      if (store.status === "ok") {
+        rows.set(slug, { agentSlug: slug, status: "ok", sessions: counts.get(slug) ?? 0 });
+        continue;
+      }
+      if (!existing || existing.status !== "ok") {
+        rows.set(slug, {
+          agentSlug: slug,
+          status: store.status === "orphaned" ? "missing-dir" : store.status,
+          sessions: null,
+          ...store.path ? { path: store.path } : {},
+          ...store.detail ? { detail: store.detail } : {}
+        });
+      }
+    }
+  }
+  return [...rows.values()];
 }
-var DEFAULT_IDLE_MINUTES = 10;
+var DEFAULT_IDLE_MINUTES = 10, DEFAULT_MAX_PER_STORE = 500;
 var init_conversation_registry = __esm(async () => {
+  init_transcript_sources();
+  init_transcript_stores();
   await init_detect();
 });
 
 // src/reflect/session-summary.ts
 import { createHash as createHash4 } from "crypto";
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync as readFileSync35 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 import { isAbsolute as isAbsolute4 } from "path";
 function validateAssetMarkers(markers, knownSkills) {
   if (!markers || markers.length === 0)
@@ -16634,7 +17363,7 @@ function digestForEntry(entry) {
     return null;
   let content;
   try {
-    content = readFileSync35(entry.transcriptPath, "utf-8");
+    content = readFileSync36(entry.transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -16762,18 +17491,18 @@ var init_session_summary = __esm(() => {
 });
 
 // src/reflect/telemetry-outbox.ts
-import { existsSync as existsSync46, readFileSync as readFileSync36 } from "fs";
-import { join as join41 } from "path";
-import { homedir as homedir22 } from "os";
+import { existsSync as existsSync47, readFileSync as readFileSync37 } from "fs";
+import { join as join42 } from "path";
+import { homedir as homedir23 } from "os";
 function outboxPath() {
-  return join41(homedir22(), ".runwork", "telemetry-outbox.json");
+  return join42(homedir23(), ".runwork", "telemetry-outbox.json");
 }
 function loadTelemetryOutbox() {
   try {
     const p = outboxPath();
-    if (!existsSync46(p))
+    if (!existsSync47(p))
       return [];
-    const parsed = JSON.parse(readFileSync36(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync37(p, "utf-8"));
     if (!Array.isArray(parsed))
       return [];
     return parsed.filter((e) => !!e && typeof e === "object" && typeof e.dedupeKey === "string" && !!e.event && typeof e.event === "object");
@@ -16834,8 +17563,8 @@ var init_active_time = __esm(() => {
 
 // src/reflect/pattern-store.ts
 import { createHash as createHash5 } from "crypto";
-import { join as join42 } from "path";
-import { homedir as homedir23 } from "os";
+import { join as join43 } from "path";
+import { homedir as homedir24 } from "os";
 function addBuckets(a, b) {
   if (!a)
     return b ? { ...b } : null;
@@ -16996,7 +17725,7 @@ function buildPatternEvent(payload, nowISO) {
   };
 }
 function storePath3() {
-  return join42(homedir23(), ".runwork", "pattern-store.json");
+  return join43(homedir24(), ".runwork", "pattern-store.json");
 }
 function loadPatternStore() {
   const parsed = readJsonOrNull(storePath3());
@@ -17206,7 +17935,7 @@ var init_triage = __esm(async () => {
 });
 
 // src/reflect/conversation-analysis.ts
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 import { basename as basename5 } from "path";
 function brokenAnalystBinaries() {
   return TIER2_ANALYSTS.filter((a) => {
@@ -17234,7 +17963,7 @@ function isPromptStillValid(key) {
   if (!standing?.promptPath || standing.promptConversationKey !== key)
     return false;
   try {
-    return existsSync47(standing.promptPath);
+    return existsSync48(standing.promptPath);
   } catch {
     return false;
   }
@@ -17922,7 +18651,7 @@ var init_welcome = __esm(() => {
 });
 
 // src/index.ts
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 
 // src/commands/login.ts
 init_login_flow();
@@ -18231,7 +18960,18 @@ var deployCommand = new Command5("deploy").description("Deploy the current app t
     console.log("Syncing...");
   try {
     commitWorkingTree(cwd, `deploy: ${new Date().toISOString().replace("T", " ").slice(0, 19)}`);
-  } catch {}
+  } catch (err) {
+    if (hasTrackedChanges(cwd)) {
+      const detail = err instanceof Error ? err.message : String(err);
+      if (useJson) {
+        jsonOut(buildErrorResponse("deploy", "Could not commit your changes", `Your working tree has uncommitted changes that could not be committed (${detail.slice(0, 300)}). Deploying now would ship the PREVIOUS commit while reporting success.`, ["Check for a failing pre-commit hook or a stale .git/index.lock", "Commit the changes yourself with git commit", "Then re-run runwork deploy"]));
+        process.exit(1);
+      }
+      console.error("Could not commit your changes, so nothing new would be deployed.");
+      console.error("A pre-commit hook or a stale .git/index.lock may be interfering. Commit manually, then re-run `runwork deploy`.");
+      process.exit(1);
+    }
+  }
   if (!hasCommits(cwd)) {
     if (useJson) {
       jsonOut(buildErrorResponse("deploy", "Nothing to deploy", "No commits exist and the working tree has no changes to commit, so there is nothing to sync or deploy.", ["Make changes to your app first", "Run runwork dev to develop and verify changes", "Then run runwork deploy"]));
@@ -20278,34 +21018,184 @@ var skillsCommand = new Command13("skills").description("Manage workspace skills
 await init_reflect();
 
 // src/commands/conversations.ts
-init_conversation_queue();
-init_session_summary();
-init_telemetry_outbox();
-init_insight_store();
-init_atomic_json();
-init_store();
-init_client();
-init_resolve();
-init_workspace_state();
-init_colors();
-await __promiseAll([
-  init_conversation_registry(),
-  init_conversation_analysis()
-]);
+init_transcript_stores();
+await init_detect();
 import { Command as Command15 } from "commander";
-import { join as join43 } from "path";
-import { homedir as homedir24 } from "os";
-var DEFAULT_LOOKBACK_DAYS = 30;
-function sinceFromDays(days) {
-  if (days <= 0)
+import { join as join44 } from "path";
+import { homedir as homedir25, platform as platform8 } from "os";
+
+// src/agents/store-census.ts
+init_transcript_stores();
+import { readdirSync as readdirSync16, statSync as statSync10, existsSync as existsSync46, openSync as openSync5, readSync as readSync3, closeSync as closeSync5 } from "fs";
+import { join as join41 } from "path";
+function sanitizeMarker(raw) {
+  const cleaned = raw.replace(/[^\x20-\x7E]/g, "").trim();
+  return cleaned.length > 64 ? `${cleaned.slice(0, 63)}…` : cleaned;
+}
+function readHead(path2, n) {
+  let fd;
+  try {
+    fd = openSync5(path2, "r");
+    const buf = Buffer.alloc(n);
+    const read = readSync3(fd, buf, 0, n, 0);
+    return buf.subarray(0, read).toString("utf-8");
+  } catch {
     return null;
-  return new Date(Date.now() - days * 24 * 3600 * 1000).toISOString();
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync5(fd);
+      } catch {}
+    }
+  }
 }
-function parseDays(raw) {
-  const n = Number(raw);
-  if (!Number.isFinite(n) || n < 0)
-    return DEFAULT_LOOKBACK_DAYS;
-  return Math.floor(n);
+function isPermissionError(err) {
+  const code = err?.code;
+  return code === "EACCES" || code === "EPERM";
+}
+function isMissingError(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function collect(dir, def, out, budget) {
+  if (budget.left <= 0)
+    return;
+  const entries = readdirSync16(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (budget.left <= 0)
+      return;
+    const full = join41(dir, e.name);
+    if (e.isDirectory()) {
+      try {
+        collect(full, def, out, budget);
+      } catch (err) {
+        if (isPermissionError(err))
+          throw err;
+      }
+    } else if (!def.matches || def.matches(e.name)) {
+      out.push(full);
+      budget.left--;
+    }
+  }
+}
+var DEFAULT_MAX_FILES = 2000;
+function censusStore(store, unlocked, opts = {}) {
+  const { def, path: path2, altPaths } = store;
+  const base = {
+    storeId: def.id,
+    family: def.family,
+    members: def.members,
+    path: path2,
+    unlocked,
+    status: "ok"
+  };
+  const altHits = altPaths.filter((p) => {
+    try {
+      return existsSync46(p);
+    } catch {
+      return false;
+    }
+  });
+  if (altHits.length > 0)
+    base.altHits = altHits;
+  if (!existsSync46(path2))
+    return { ...base, status: "missing" };
+  if (def.kind === "file") {
+    try {
+      const s = statSync10(path2);
+      return { ...base, files: 1, bytes: s.size, newestAt: new Date(s.mtimeMs).toISOString() };
+    } catch (err) {
+      return { ...base, status: isPermissionError(err) ? "permission-denied" : "error", detail: String(err) };
+    }
+  }
+  const all = [];
+  const budget = { left: opts.maxFiles ?? DEFAULT_MAX_FILES };
+  try {
+    collect(path2, def, all, budget);
+  } catch (err) {
+    if (isPermissionError(err))
+      return { ...base, status: "permission-denied", detail: "EACCES" };
+    if (isMissingError(err))
+      return { ...base, status: "missing" };
+    return { ...base, status: "error", detail: err instanceof Error ? err.message : String(err) };
+  }
+  const files = [];
+  let nested = 0;
+  for (const f of all) {
+    const rel = f.slice(path2.length).replace(/^[\\/]+/, "");
+    if (def.subordinate?.(rel))
+      nested++;
+    else
+      files.push(f);
+  }
+  let bytes = 0;
+  let newest = 0;
+  for (const f of all) {
+    try {
+      const s = statSync10(f);
+      bytes += s.size;
+      if (s.mtimeMs > newest)
+        newest = s.mtimeMs;
+    } catch {}
+  }
+  const result = {
+    ...base,
+    files: files.length,
+    ...nested > 0 ? { nested } : {},
+    bytes,
+    newestAt: newest > 0 ? new Date(newest).toISOString() : null
+  };
+  if (opts.skipMarkers || !def.marker)
+    return result;
+  const counts = new Map;
+  for (const f of files) {
+    const head = readHead(f, def.headBytes ?? 64 * 1024);
+    const { agentSlug, marker, recognised } = attributeTranscript(def, head);
+    const clean = marker === null ? null : sanitizeMarker(marker);
+    const key = clean ?? "\x00none";
+    const existing = counts.get(key);
+    if (existing)
+      existing.count++;
+    else
+      counts.set(key, { marker: clean, count: 1, agentSlug, recognised });
+  }
+  result.markers = [...counts.values()].sort((a, b) => b.count - a.count);
+  return result;
+}
+function censusStores(stores, detectedSlugs, opts = {}) {
+  const detected = new Set(detectedSlugs);
+  return stores.map((store) => censusStore(store, isStoreUnlocked(store.def, detected), opts));
+}
+function orphanedStoresWithContent(censuses) {
+  return censuses.filter((c) => !c.unlocked && c.status === "ok" && (c.files ?? 0) > 0);
+}
+
+// src/commands/conversations.ts
+init_conversation_queue();
+init_session_summary();
+init_telemetry_outbox();
+init_insight_store();
+init_atomic_json();
+init_store();
+init_client();
+init_resolve();
+init_workspace_state();
+init_colors();
+await __promiseAll([
+  init_conversation_registry(),
+  init_conversation_analysis()
+]);
+var DEFAULT_LOOKBACK_DAYS = 0;
+function sinceFromDays(days) {
+  if (days <= 0)
+    return null;
+  return new Date(Date.now() - days * 24 * 3600 * 1000).toISOString();
+}
+function parseDays(raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0)
+    return DEFAULT_LOOKBACK_DAYS;
+  return Math.floor(n);
 }
 function bareRegistrySkillId(skill) {
   if (skill.type !== "external" || typeof skill.id !== "string")
@@ -20359,22 +21249,34 @@ function fit(text2, width) {
   return text2.length > width ? text2.slice(0, width - 1) + "…" : text2;
 }
 var conversationsCommand = new Command15("conversations").description("Local AI conversations across your agents (registry, end detection)");
-conversationsCommand.command("list").description("List local conversations across all detected agents (metadata only)").option("--days <n>", "Look back this many days (0 = no limit)", String(DEFAULT_LOOKBACK_DAYS)).option("--idle-minutes <n>", "Idle threshold that marks a conversation finished", String(DEFAULT_IDLE_MINUTES)).action(async (opts, command) => {
+conversationsCommand.command("list").description("List local conversations across all detected agents (metadata only)").option("--days <n>", "Narrow to this many days (0 = no window, the default)", String(DEFAULT_LOOKBACK_DAYS)).option("--idle-minutes <n>", "Idle threshold that marks a conversation finished", String(DEFAULT_IDLE_MINUTES)).action(async (opts, command) => {
   const json = command.optsWithGlobals().json === true || !process.stdout.isTTY;
   const days = parseDays(opts.days);
   const idleMinutes = Math.max(1, Number(opts.idleMinutes) || DEFAULT_IDLE_MINUTES);
   const result = await listLocalConversations({ sinceISO: sinceFromDays(days), idleMinutes });
   if (json) {
-    jsonOut({ conversations: result.conversations, perAgent: result.perAgent });
+    jsonOut({ conversations: result.conversations, perAgent: result.perAgent, perStore: result.perStore });
     return;
   }
   console.log(bold(days > 0 ? `
 Local conversations, last ${days} day(s)` : `
 Local conversations (all)`));
+  for (const s of result.perStore) {
+    const reason = describeStoreOutcome(s);
+    if (reason === null)
+      continue;
+    const line = `  ${s.storeId}: ${reason}`;
+    console.log(storeOutcomeNeedsAttention(s) ? yellow(line) : dim(line));
+  }
   for (const a of result.perAgent) {
-    if (a.sessions === "unsupported")
+    if (a.status === "no-reader")
       continue;
-    console.log(dim(`  ${a.slug}: ${a.sessions === "error" ? "read error" : `${a.sessions} session(s)`}`));
+    const reason = describeScanOutcome(a);
+    if (reason === null) {
+      console.log(dim(`  ${a.agentSlug}: ${a.sessions} session(s)`));
+    } else {
+      console.log(`  ${a.agentSlug}: ${scanOutcomeNeedsAttention(a) ? yellow(reason) : dim(reason)}`);
+    }
   }
   console.log("");
   const width = process.stdout.columns || 120;
@@ -20391,7 +21293,36 @@ Local conversations (all)`));
   if (result.conversations.length === 0)
     console.log(dim("  none"));
 });
-conversationsCommand.command("scan").description("Detect finished conversations (idle threshold) and queue them for reflection").option("--days <n>", "Look back this many days (0 = no limit)", String(DEFAULT_LOOKBACK_DAYS)).option("--idle-minutes <n>", "Idle threshold that marks a conversation finished", String(DEFAULT_IDLE_MINUTES)).action(async (opts, command) => {
+conversationsCommand.command("status").description("Why each agent did or did not contribute conversations (no conversation data)").option("--days <n>", "Narrow to this many days (0 = no window, the default)", String(DEFAULT_LOOKBACK_DAYS)).action(async (opts, command) => {
+  const json = command.optsWithGlobals().json === true || !process.stdout.isTTY;
+  const days = parseDays(opts.days);
+  const { perAgent, perStore } = await listLocalConversations({ sinceISO: sinceFromDays(days) });
+  if (json) {
+    jsonOut({ perAgent, perStore });
+    return;
+  }
+  console.log(bold(days > 0 ? `
+Conversation sources, last ${days} day(s)` : `
+Conversation sources`));
+  for (const s of perStore) {
+    const reason = describeStoreOutcome(s);
+    if (reason === null) {
+      console.log(`  ${cyan(s.storeId)}: ${s.sessions} conversation(s)`);
+    } else {
+      console.log(`  ${cyan(s.storeId)}: ${storeOutcomeNeedsAttention(s) ? yellow(reason) : dim(reason)}`);
+    }
+  }
+  console.log("");
+  for (const a of perAgent) {
+    const reason = describeScanOutcome(a);
+    if (reason === null) {
+      console.log(`  ${cyan(a.agentSlug)}: ${a.status === "no-reader" ? dim("no transcript reader") : `${a.sessions} conversation(s)`}`);
+    } else {
+      console.log(`  ${cyan(a.agentSlug)}: ${scanOutcomeNeedsAttention(a) ? yellow(reason) : dim(reason)}`);
+    }
+  }
+});
+conversationsCommand.command("scan").description("Detect finished conversations (idle threshold) and queue them for reflection").option("--days <n>", "Narrow to this many days (0 = no window, the default)", String(DEFAULT_LOOKBACK_DAYS)).option("--idle-minutes <n>", "Idle threshold that marks a conversation finished", String(DEFAULT_IDLE_MINUTES)).action(async (opts, command) => {
   const json = command.optsWithGlobals().json === true || !process.stdout.isTTY;
   const days = parseDays(opts.days);
   const idleMinutes = Math.max(1, Number(opts.idleMinutes) || DEFAULT_IDLE_MINUTES);
@@ -20454,11 +21385,13 @@ conversationsCommand.command("scan").description("Detect finished conversations
   const snapshot = {
     generatedAt: new Date().toISOString(),
     idleMinutes,
-    conversations: [...listed, ...rescued].sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt))
+    conversations: [...listed, ...rescued].sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt)),
+    perAgent: result.perAgent,
+    perStore: result.perStore
   };
-  writeJsonAtomic(join43(homedir24(), ".runwork", "conversations.json"), snapshot);
+  writeJsonAtomic(join44(homedir25(), ".runwork", "conversations.json"), snapshot);
   if (json) {
-    jsonOut({ queued: scan.queued, reopened: scan.reopened, pruned: scan.pruned, pending, finished: finished.length });
+    jsonOut({ queued: scan.queued, reopened: scan.reopened, pruned: scan.pruned, pending, finished: finished.length, perAgent: result.perAgent });
     return;
   }
   console.log(green(`Scanned ${result.conversations.length} conversation(s): ${scan.queued} newly queued, ${scan.reopened} reopened, ${pending} pending analysis.`));
@@ -20479,15 +21412,71 @@ conversationsCommand.command("analyze").description("Analyze queued finished con
   }
   console.log(outcome.reason ? dim(describeAnalysisOutcome(outcome)) : green(describeAnalysisOutcome(outcome)));
 });
+conversationsCommand.command("stores").description("Every local transcript store: what is in it, who wrote it, and whether anything reads it").option("--max-files <n>", "Cap transcripts inspected per store", String(DEFAULT_MAX_FILES)).option("--no-markers", "Skip provenance reads; counts, sizes and mtimes only").action(async (opts, command) => {
+  const json = command.optsWithGlobals().json === true || !process.stdout.isTTY;
+  const maxFiles = Math.max(1, Number(opts.maxFiles) || DEFAULT_MAX_FILES);
+  const detected = (await detectAgents()).map((a) => a.slug);
+  const stores = resolveTranscriptStores({
+    platform: platform8(),
+    homeDir: homedir25(),
+    appData: process.env.APPDATA ?? null,
+    localAppData: process.env.LOCALAPPDATA ?? null
+  });
+  const censuses = censusStores(stores, detected, {
+    maxFiles,
+    skipMarkers: opts.markers === false
+  });
+  if (json) {
+    jsonOut({ detected, stores: censuses });
+    return;
+  }
+  console.log(bold(`
+Transcript stores`));
+  console.log(dim(`  detected agents: ${detected.length > 0 ? detected.join(", ") : "none"}
+`));
+  for (const c of censuses) {
+    const owner = c.unlocked ? green("read") : yellow("ORPHANED");
+    console.log(`${bold(c.storeId)}  ${owner}  ${dim(`family ${c.family}: ${c.members.join(", ")}`)}`);
+    console.log(dim(`  ${c.path}`));
+    if (c.status !== "ok") {
+      console.log(`  ${yellow(c.status)}${c.detail ? dim(` (${c.detail})`) : ""}`);
+    } else {
+      const mb = ((c.bytes ?? 0) / 1e6).toFixed(1);
+      const newest = c.newestAt ? c.newestAt.slice(0, 16).replace("T", " ") : "-";
+      const nested = c.nested ? `, plus ${c.nested} subagent transcript(s)` : "";
+      console.log(dim(`  ${c.files} conversation(s)${nested}, ${mb} MB, newest ${newest}`));
+      for (const m of c.markers ?? []) {
+        if (m.marker === null) {
+          console.log(`    ${String(m.count).padStart(5)}  ${dim(`(no marker, pre-dates the field) -> ${m.agentSlug}`)}`);
+          continue;
+        }
+        const flag = m.recognised ? dim(`-> ${m.agentSlug}`) : yellow(`-> ${m.agentSlug} (UNRECOGNISED surface)`);
+        console.log(`    ${String(m.count).padStart(5)}  ${cyan(m.marker)} ${flag}`);
+      }
+    }
+    for (const alt of c.altHits ?? []) {
+      console.log(`  ${yellow("also present:")} ${dim(alt)}`);
+    }
+    console.log("");
+  }
+  const orphans = orphanedStoresWithContent(censuses);
+  if (orphans.length > 0) {
+    console.log(yellow(`${orphans.length} store(s) hold transcripts that no detected agent reads:`));
+    for (const o of orphans) {
+      console.log(`  ${o.path}  ${dim(`(${o.files} transcripts; needs one of: ${o.members.join(", ")})`)}`);
+    }
+    console.log("");
+  }
+});
 
 // src/commands/instructions.ts
 init_store();
 init_client();
 init_resolve();
 import { Command as Command16 } from "commander";
-import { readFileSync as readFileSync37, existsSync as existsSync48 } from "fs";
-import { join as join44 } from "path";
-import { homedir as homedir25 } from "os";
+import { readFileSync as readFileSync38, existsSync as existsSync49 } from "fs";
+import { join as join45 } from "path";
+import { homedir as homedir26 } from "os";
 
 // ../../shared/agent-instructions/runwork-instructions.ts
 function formatList(items, max = 8) {
@@ -20967,13 +21956,13 @@ async function buildInstructionContext(client, workspace) {
 // src/commands/instructions.ts
 function readSetupExtras(workspaceId) {
   for (const path2 of [
-    join44(process.cwd(), ".runwork", "setup.json"),
-    join44(homedir25(), ".runwork", "setup.json")
+    join45(process.cwd(), ".runwork", "setup.json"),
+    join45(homedir26(), ".runwork", "setup.json")
   ]) {
-    if (!existsSync48(path2))
+    if (!existsSync49(path2))
       continue;
     try {
-      const state = JSON.parse(readFileSync37(path2, "utf-8"));
+      const state = JSON.parse(readFileSync38(path2, "utf-8"));
       if (state.workspaceId === workspaceId) {
         return { workspaceSlug: state.workspaceSlug, persona: state.persona };
       }
@@ -21017,16 +22006,16 @@ import { Command as Command17 } from "commander";
 import * as path3 from "node:path";
 
 // src/utils/data-input.ts
-import { readFileSync as readFileSync38, existsSync as existsSync49 } from "fs";
+import { readFileSync as readFileSync39, existsSync as existsSync50 } from "fs";
 async function parseDataInput(dataFlag) {
   if (dataFlag) {
     if (dataFlag.startsWith("@")) {
       const filePath = dataFlag.slice(1);
-      if (!existsSync49(filePath)) {
+      if (!existsSync50(filePath)) {
         console.error(`File not found: ${filePath}`);
         process.exit(1);
       }
-      const content = readFileSync38(filePath, "utf-8");
+      const content = readFileSync39(filePath, "utf-8");
       return parseJson(content, filePath);
     }
     return parseJson(dataFlag, "--data");
@@ -22080,7 +23069,7 @@ init_resolve();
 init_prompt();
 init_http();
 import { Command as Command21 } from "commander";
-import { writeFileSync as writeFileSync29, readFileSync as readFileSync39 } from "fs";
+import { writeFileSync as writeFileSync29, readFileSync as readFileSync40 } from "fs";
 import { basename as basename6 } from "path";
 function formatSize(bytes) {
   if (bytes === undefined)
@@ -22190,7 +23179,7 @@ var uploadCommand = new Command21("upload").description("Upload a local file to
   const { workspaceId } = await resolveWorkspace2(client, opts);
   const objectKey = key || basename6(localPath);
   try {
-    const fileBuffer = readFileSync39(localPath);
+    const fileBuffer = readFileSync40(localPath);
     const { url } = await client.getPresignedUrl(workspaceId, bucket, { action: "write", key: objectKey });
     const response = await httpFetch(url, { method: "PUT", body: fileBuffer });
     if (!response.ok) {
@@ -22707,8 +23696,8 @@ init_resolve();
 init_prompt();
 await init_detect();
 import { Command as Command27 } from "commander";
-import { join as join49 } from "path";
-import { homedir as homedir28 } from "os";
+import { join as join50 } from "path";
+import { homedir as homedir29 } from "os";
 
 // src/commands/sync.ts
 init_store();
@@ -22719,9 +23708,9 @@ await __promiseAll([
   init_codex()
 ]);
 import { Command as Command26 } from "commander";
-import { readFileSync as readFileSync41, existsSync as existsSync52 } from "fs";
-import { join as join48 } from "path";
-import { homedir as homedir27 } from "os";
+import { readFileSync as readFileSync42, existsSync as existsSync53 } from "fs";
+import { join as join49 } from "path";
+import { homedir as homedir28 } from "os";
 
 // src/commands/mcp-entries.ts
 init_types();
@@ -22785,6 +23774,7 @@ var RUNWORK_AGENT_DEFAULTS = {
 };
 var AGENT_DEFAULTS_SCHEMA_VERSION = 1;
 // src/commands/sync-telemetry.ts
+init_transcript_stores();
 var TELEMETRY_BACKFILL_MS = 30 * 24 * 60 * 60 * 1000;
 function resolveTelemetrySince(state, nowMs = Date.now()) {
   if (state.lastTelemetryAt)
@@ -22795,11 +23785,20 @@ async function collectTelemetryEvents(params) {
   const now = params.now ?? new Date().toISOString();
   const events = [];
   const adapterResults = [];
+  const bySlug = new Map(params.adapters.map((a) => [a.slug, a]));
+  const suppressed = suppressedStoreReaders(params.adapters.map((a) => a.slug), (a, b) => {
+    const left = bySlug.get(a);
+    const right = bySlug.get(b);
+    if (!left || !right)
+      return false;
+    return left.readUsageStats !== undefined && left.readUsageStats === right.readUsageStats || left.readSkillUsage !== undefined && left.readSkillUsage === right.readSkillUsage;
+  });
   for (const adapter2 of params.adapters) {
     let stats = "unsupported";
     let skills = "unsupported";
     let error;
-    if (adapter2.readUsageStats) {
+    const readsStore = !suppressed.has(adapter2.slug);
+    if (adapter2.readUsageStats && readsStore) {
       try {
         stats = await adapter2.readUsageStats(params.since);
         if (stats && stats.hasNewActivity) {
@@ -22827,7 +23826,7 @@ async function collectTelemetryEvents(params) {
         stats = null;
       }
     }
-    if (adapter2.readSkillUsage) {
+    if (adapter2.readSkillUsage && readsStore) {
       try {
         skills = await adapter2.readSkillUsage(params.since);
         if (skills && skills.length > 0) {
@@ -23433,7 +24432,11 @@ async function executeSyncPlan(plan, resolvedConflicts, ctx) {
     if (!action.remoteContent)
       continue;
     const skillFile = makeSkillFile(action.name, action.remoteContent);
-    await writeSkillToAgents(skillFile, action.source, ctx);
+    const outcome = await writeSkillToAgents(skillFile, action.source, ctx);
+    if (!writeLanded(outcome)) {
+      vlog(`  Pull FAILED for ${action.name} (${outcome.succeeded}/${outcome.attempted} agent writes); will retry next sync`);
+      continue;
+    }
     newHashes[action.name] = {
       localHash: contentHash(buildSkillMd2(skillFile)),
       remoteHash: contentHash(action.remoteContent),
@@ -23475,7 +24478,11 @@ async function executeSyncPlan(plan, resolvedConflicts, ctx) {
       vlog(`  Pushed (conflict resolved): ${action.name}`);
     } else if (resolution === "remote" && action.remoteContent) {
       const skillFile = makeSkillFile(action.name, action.remoteContent);
-      await writeSkillToAgents(skillFile, action.source, ctx);
+      const outcome = await writeSkillToAgents(skillFile, action.source, ctx);
+      if (!writeLanded(outcome)) {
+        vlog(`  Conflict pull FAILED for ${action.name} (${outcome.succeeded}/${outcome.attempted} agent writes); will retry next sync`);
+        continue;
+      }
       newHashes[action.name] = {
         localHash: contentHash(buildSkillMd2(skillFile)),
         remoteHash: contentHash(action.remoteContent),
@@ -23487,6 +24494,7 @@ async function executeSyncPlan(plan, resolvedConflicts, ctx) {
   }
   for (const _action of plan.skips) {}
   const deletionSlugs = plan.deletions.map((action) => toSlug(action.name));
+  let removalsFailed = false;
   if (deletionSlugs.length) {
     for (const adapter2 of ctx.adapters) {
       if (!adapter2.supportsSkills() || !adapter2.removeSkills)
@@ -23494,14 +24502,19 @@ async function executeSyncPlan(plan, resolvedConflicts, ctx) {
       for (const scope of ctx.scopes) {
         try {
           await adapter2.removeSkills(deletionSlugs, scope);
-        } catch {}
+        } catch {
+          removalsFailed = true;
+        }
       }
     }
     for (const action of plan.deletions) {
-      vlog(`  Deleted locally: ${action.name}`);
+      vlog(removalsFailed ? `  Deletion of ${action.name} incomplete; will retry next sync` : `  Deleted locally: ${action.name}`);
     }
   }
-  return newHashes;
+  return {
+    newHashes,
+    failedDeletions: removalsFailed ? plan.deletions.map((action) => action.name) : []
+  };
 }
 function makeSkillFile(name, content) {
   return {
@@ -23512,17 +24525,25 @@ function makeSkillFile(name, content) {
   };
 }
 async function writeSkillToAgents(skillFile, source, ctx) {
+  let attempted = 0;
+  let succeeded = 0;
   for (const adapter2 of ctx.adapters) {
     if (source === "app" && ctx.hasMcp && adapter2.mcpProvidesSkills)
       continue;
     for (const scope of ctx.scopes) {
       if (!adapter2.supportsSkills())
         continue;
+      attempted++;
       try {
         await adapter2.writeSkills([skillFile], scope);
+        succeeded++;
       } catch {}
     }
   }
+  return { attempted, succeeded };
+}
+function writeLanded(outcome) {
+  return outcome.attempted === 0 || outcome.succeeded > 0;
 }
 function extractDescription(content) {
   const match = content.match(/^---\n[\s\S]*?description:\s*(.+)\n[\s\S]*?---/);
@@ -23581,10 +24602,10 @@ function sameStringSet(a, b) {
 }
 
 // src/utils/sync-lock.ts
-import { existsSync as existsSync51, mkdirSync as mkdirSync28, readFileSync as readFileSync40, unlinkSync as unlinkSync8, writeFileSync as writeFileSync30 } from "fs";
-import { join as join47 } from "path";
-import { homedir as homedir26 } from "os";
-var LOCK_PATH = join47(homedir26(), ".runwork", "sync.lock");
+import { existsSync as existsSync52, mkdirSync as mkdirSync28, readFileSync as readFileSync41, unlinkSync as unlinkSync8, writeFileSync as writeFileSync30 } from "fs";
+import { join as join48 } from "path";
+import { homedir as homedir27 } from "os";
+var LOCK_PATH = join48(homedir27(), ".runwork", "sync.lock");
 var STALE_LOCK_MS = 5 * 60 * 1000;
 var DEFAULT_WAIT_MS = 30000;
 var exitHandlerRegistered = false;
@@ -23604,15 +24625,15 @@ function isProcessAlive(pid) {
 }
 function readLock() {
   try {
-    return JSON.parse(readFileSync40(LOCK_PATH, "utf-8"));
+    return JSON.parse(readFileSync41(LOCK_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLockExclusive() {
   try {
-    if (!existsSync51(join47(homedir26(), ".runwork"))) {
-      mkdirSync28(join47(homedir26(), ".runwork"), { recursive: true });
+    if (!existsSync52(join48(homedir27(), ".runwork"))) {
+      mkdirSync28(join48(homedir27(), ".runwork"), { recursive: true });
     }
     writeFileSync30(LOCK_PATH, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), {
       flag: "wx"
@@ -23681,10 +24702,10 @@ Tip: ${hint.title}`);
   } catch {}
 }
 function loadSetupState(filePath) {
-  if (!existsSync52(filePath))
+  if (!existsSync53(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync41(filePath, "utf-8"));
+    return JSON.parse(readFileSync42(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -23705,15 +24726,15 @@ function readLocalSkills(state) {
     if (!baseDir)
       continue;
     for (const skillName of state.skills) {
-      const skillMdPath = join48(baseDir, skillName, "SKILL.md");
-      if (existsSync52(skillMdPath)) {
-        results.push({ name: skillName, content: readFileSync41(skillMdPath, "utf-8") });
+      const skillMdPath = join49(baseDir, skillName, "SKILL.md");
+      if (existsSync53(skillMdPath)) {
+        results.push({ name: skillName, content: readFileSync42(skillMdPath, "utf-8") });
         continue;
       }
       const filename = skillName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const flatPath = join48(baseDir, `${filename}.md`);
-      if (existsSync52(flatPath)) {
-        results.push({ name: skillName, content: readFileSync41(flatPath, "utf-8") });
+      const flatPath = join49(baseDir, `${filename}.md`);
+      if (existsSync53(flatPath)) {
+        results.push({ name: skillName, content: readFileSync42(flatPath, "utf-8") });
       }
     }
     if (results.length > 0)
@@ -23937,7 +24958,7 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
   if (adapters.length > 0) {
     console.log(`  Syncing to: ${adapters.map((a) => a.name).join(", ")}`);
   }
-  const newHashes = await executeSyncPlan(plan, resolvedConflicts, {
+  const { newHashes, failedDeletions } = await executeSyncPlan(plan, resolvedConflicts, {
     client,
     workspaceId: state.workspaceId,
     adapters,
@@ -23967,9 +24988,9 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
     persona: state.persona
   });
   let projectAppSkillFilter = null;
-  if (existsSync52(".runwork.json")) {
+  if (existsSync53(".runwork.json")) {
     try {
-      const config = JSON.parse(readFileSync41(".runwork.json", "utf-8"));
+      const config = JSON.parse(readFileSync42(".runwork.json", "utf-8"));
       if (config.appName) {
         projectAppSkillFilter = config.appName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
       }
@@ -24238,7 +25259,7 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
   }
   for (const adapter2 of adapters) {
     if (adapter2 instanceof CodexAdapter) {
-      const runworkDir = join48(homedir27(), ".runwork");
+      const runworkDir = join49(homedir28(), ".runwork");
       const result = adapter2.registerDesktopWorkspace(runworkDir, "Runwork");
       if (result === "written") {
         vlog(`  [${adapter2.name}] Registered workspace in Codex desktop app`);
@@ -24324,7 +25345,10 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
   for (const [name, hash] of Object.entries(newHashes)) {
     mergedHashes[name] = hash;
   }
+  const retryDeletions = new Set(failedDeletions);
   for (const del of plan.deletions) {
+    if (retryDeletions.has(del.name))
+      continue;
     delete mergedHashes[del.name];
   }
   state.skillHashes = mergedHashes;
@@ -24395,8 +25419,8 @@ var syncCommand = new Command26("sync").description("Sync skills bidirectionally
     verbose: !!opts.verbose,
     redetect: !!opts.redetect
   };
-  const projectStatePath = join48(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join48(homedir27(), ".runwork", "setup.json");
+  const projectStatePath = join49(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join49(homedir28(), ".runwork", "setup.json");
   const projectState = loadSetupState(projectStatePath);
   const userState = loadSetupState(userStatePath);
   if (!projectState && !userState) {
@@ -24465,7 +25489,7 @@ function toSkillFilename(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
 }
 function loadSetupStateForScope(scope) {
-  const path4 = scope === "project" ? join49(process.cwd(), ".runwork", "setup.json") : join49(homedir28(), ".runwork", "setup.json");
+  const path4 = scope === "project" ? join50(process.cwd(), ".runwork", "setup.json") : join50(homedir29(), ".runwork", "setup.json");
   return readJsonOrNull(path4);
 }
 async function parkAndTeardownWorkspace(previous, scopes) {
@@ -24634,8 +25658,8 @@ Re-run without --dry-run to sync workspace data.`);
   }
   persistDefaultWorkspace(workspaceId, workspaceName);
   for (const s of scopes) {
-    const dir = s === "project" ? ".runwork" : join49(homedir28(), ".runwork");
-    writeJsonAtomic(join49(dir, "setup.json"), state);
+    const dir = s === "project" ? ".runwork" : join50(homedir29(), ".runwork");
+    writeJsonAtomic(join50(dir, "setup.json"), state);
   }
   if (restored)
     clearParkedState(workspaceId);
@@ -24643,7 +25667,7 @@ Re-run without --dry-run to sync workspace data.`);
 Syncing workspace data...
 `);
   for (const s of scopes) {
-    const statePath2 = s === "project" ? join49(process.cwd(), ".runwork", "setup.json") : join49(homedir28(), ".runwork", "setup.json");
+    const statePath2 = s === "project" ? join50(process.cwd(), ".runwork", "setup.json") : join50(homedir29(), ".runwork", "setup.json");
     await syncFromState(state, statePath2, credentials, {
       dryRun: false,
       pullOnly: true,
@@ -24663,16 +25687,16 @@ init_client();
 import { Command as Command28 } from "commander";
 
 // src/utils/setup-state.ts
-import { existsSync as existsSync53, readFileSync as readFileSync42 } from "fs";
-import { join as join50 } from "path";
-import { homedir as homedir29 } from "os";
+import { existsSync as existsSync54, readFileSync as readFileSync43 } from "fs";
+import { join as join51 } from "path";
+import { homedir as homedir30 } from "os";
 function loadSetupState2() {
-  const projectPath = join50(process.cwd(), ".runwork", "setup.json");
-  const userPath = join50(homedir29(), ".runwork", "setup.json");
+  const projectPath = join51(process.cwd(), ".runwork", "setup.json");
+  const userPath = join51(homedir30(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
-    if (existsSync53(p)) {
+    if (existsSync54(p)) {
       try {
-        return JSON.parse(readFileSync42(p, "utf-8"));
+        return JSON.parse(readFileSync43(p, "utf-8"));
       } catch {
         continue;
       }
@@ -24731,14 +25755,14 @@ init_client();
 init_types();
 await init_detect();
 import { Command as Command29 } from "commander";
-import { existsSync as existsSync54, readFileSync as readFileSync43 } from "fs";
-import { resolve as resolve3, join as join51 } from "path";
-import { homedir as homedir30 } from "os";
+import { existsSync as existsSync55, readFileSync as readFileSync44 } from "fs";
+import { resolve as resolve3, join as join52 } from "path";
+import { homedir as homedir31 } from "os";
 function loadSetupState3(filePath) {
-  if (!existsSync54(filePath))
+  if (!existsSync55(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync43(filePath, "utf-8"));
+    return JSON.parse(readFileSync44(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -24754,8 +25778,8 @@ var buildPluginCommand = new Command29("build-plugin").description("Build an ins
     process.exit(1);
   }
   const credentials = requireAuth();
-  const projectStatePath = join51(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join51(homedir30(), ".runwork", "setup.json");
+  const projectStatePath = join52(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join52(homedir31(), ".runwork", "setup.json");
   const state = loadSetupState3(projectStatePath) ?? loadSetupState3(userStatePath);
   if (!state) {
     console.error("No setup state found. Run `runwork setup` first.");
@@ -24848,14 +25872,14 @@ init_prompt();
 init_subprocess();
 await init_detect();
 import { Command as Command30 } from "commander";
-import { existsSync as existsSync55, readFileSync as readFileSync44, writeFileSync as writeFileSync32, readdirSync as readdirSync16, rmSync as rmSync12, unlinkSync as unlinkSync9, lstatSync, readlinkSync } from "fs";
-import { join as join52, resolve as resolve4, relative as relative5, isAbsolute as isAbsolute5 } from "path";
-import { homedir as homedir31 } from "os";
+import { existsSync as existsSync56, readFileSync as readFileSync45, writeFileSync as writeFileSync32, readdirSync as readdirSync17, rmSync as rmSync12, unlinkSync as unlinkSync9, lstatSync, readlinkSync } from "fs";
+import { join as join53, resolve as resolve4, relative as relative5, isAbsolute as isAbsolute5 } from "path";
+import { homedir as homedir32 } from "os";
 function loadSetupState4(filePath) {
-  if (!existsSync55(filePath))
+  if (!existsSync56(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync44(filePath, "utf-8"));
+    return JSON.parse(readFileSync45(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -24863,22 +25887,22 @@ function loadSetupState4(filePath) {
 var PRESERVED_ENTRIES = ["bin", "apps", "trash"];
 function removeRunworkState(stateDir, opts) {
   const result = { removed: [], preserved: [], errors: [] };
-  if (!existsSync55(stateDir))
+  if (!existsSync56(stateDir))
     return result;
   const preserve = new Set(PRESERVED_ENTRIES);
   if (opts.keepAuth)
     preserve.add(".credentials");
   let entries;
   try {
-    entries = readdirSync16(stateDir);
+    entries = readdirSync17(stateDir);
   } catch (err) {
     result.errors.push(`${stateDir}: ${err instanceof Error ? err.message : err}`);
     return result;
   }
   for (const entry of entries) {
-    const target = join52(stateDir, entry);
+    const target = join53(stateDir, entry);
     if (preserve.has(entry)) {
-      if (existsSync55(target))
+      if (existsSync56(target))
         result.preserved.push(target);
       continue;
     }
@@ -24894,11 +25918,11 @@ function removeRunworkState(stateDir, opts) {
 var SHELL_PROFILES = [".zshrc", ".zprofile", ".bashrc", ".bash_profile", ".profile"];
 var BIN_DIR_PATTERN = /\.runwork[\\/]bin/;
 function stripRunworkPathLines(file) {
-  if (!existsSync55(file))
+  if (!existsSync56(file))
     return false;
   let content;
   try {
-    content = readFileSync44(file, "utf-8");
+    content = readFileSync45(file, "utf-8");
   } catch {
     return false;
   }
@@ -24927,7 +25951,7 @@ function stripRunworkPathLines(file) {
   }
 }
 function cleanShellProfilePathEntries() {
-  return SHELL_PROFILES.map((name) => join52(homedir31(), name)).filter(stripRunworkPathLines);
+  return SHELL_PROFILES.map((name) => join53(homedir32(), name)).filter(stripRunworkPathLines);
 }
 function cleanPowerShellProfilePathEntries() {
   if (process.platform !== "win32")
@@ -24967,7 +25991,7 @@ function removeRunworkSymlink(linkPath) {
   } catch {
     return false;
   }
-  const ours = resolve4(join52(homedir31(), ".runwork", "bin"));
+  const ours = resolve4(join53(homedir32(), ".runwork", "bin"));
   const rel = relative5(ours, resolve4(target));
   const insideOurs = rel === "" || !rel.startsWith("..") && !isAbsolute5(rel);
   if (!insideOurs)
@@ -24980,8 +26004,8 @@ function removeRunworkSymlink(linkPath) {
   }
 }
 var uninstallCommand = new Command30("uninstall").description("Remove all Runwork configuration from local agents (MCP servers, skills, instructions)").option("-y, --yes", "Skip confirmation prompt").option("--keep-auth", "Keep authentication credentials (only remove agent configs)").action(async (opts) => {
-  const projectStatePath = join52(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join52(homedir31(), ".runwork", "setup.json");
+  const projectStatePath = join53(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join53(homedir32(), ".runwork", "setup.json");
   const projectState = loadSetupState4(projectStatePath);
   const userState = loadSetupState4(userStatePath);
   if (!projectState && !userState) {
@@ -25068,8 +26092,8 @@ This will remove all Runwork configuration from your local agents:
         }
       }
     }
-    const stateDir = label === "project" ? join52(process.cwd(), ".runwork") : join52(homedir31(), ".runwork");
-    if (existsSync55(stateDir)) {
+    const stateDir = label === "project" ? join53(process.cwd(), ".runwork") : join53(homedir32(), ".runwork");
+    if (existsSync56(stateDir)) {
       const outcome = removeRunworkState(stateDir, {
         keepAuth: Boolean(opts.keepAuth) && label === "user"
       });
@@ -25099,7 +26123,7 @@ This will remove all Runwork configuration from your local agents:
       console.log(`    - ${file}`);
   }
   const removedLinks = [
-    join52(homedir31(), ".local", "bin", "runwork"),
+    join53(homedir32(), ".local", "bin", "runwork"),
     "/usr/local/bin/runwork"
   ].filter(removeRunworkSymlink);
   if (removedLinks.length > 0) {
@@ -25111,7 +26135,7 @@ This will remove all Runwork configuration from your local agents:
   if (process.platform === "win32") {
     console.log("");
     console.log("  Still on your PATH (remove by hand if you want it gone):");
-    console.log(`    ${join52(homedir31(), ".runwork", "bin")} in your user PATH`);
+    console.log(`    ${join53(homedir32(), ".runwork", "bin")} in your user PATH`);
   }
   console.log("");
   if (errors > 0) {
@@ -25237,7 +26261,7 @@ var membersCommand = new Command32("members").description("List workspace member
 init_store();
 init_client();
 import { Command as Command33 } from "commander";
-import { readFileSync as readFileSync45 } from "fs";
+import { readFileSync as readFileSync46 } from "fs";
 function normalizeApiPath(rawPath, baseUrl) {
   if (/^https?:\/\//i.test(rawPath)) {
     const target = new URL(rawPath);
@@ -25270,7 +26294,7 @@ to be read or pasted manually. Prefer a dedicated command when one exists
     let curlStr = opts.curl;
     if (opts.curlFile) {
       try {
-        curlStr = readFileSync45(opts.curlFile, "utf-8");
+        curlStr = readFileSync46(opts.curlFile, "utf-8");
       } catch (err) {
         console.error(`Could not read --curl-file: ${err instanceof Error ? err.message : err}`);
         process.exit(1);
@@ -25290,7 +26314,7 @@ to be read or pasted manually. Prefer a dedicated command when one exists
     let raw = opts.body;
     if (raw.startsWith("@")) {
       try {
-        raw = readFileSync45(raw.slice(1), "utf-8");
+        raw = readFileSync46(raw.slice(1), "utf-8");
       } catch (err) {
         console.error(`Could not read body file: ${err instanceof Error ? err.message : err}`);
         process.exit(1);
@@ -25344,9 +26368,9 @@ init_preflight();
 init_credentials();
 await init_detect();
 import { parse as parse2 } from "smol-toml";
-import { existsSync as existsSync56, readFileSync as readFileSync46 } from "fs";
-import { join as join53, sep as sep4 } from "path";
-import { homedir as homedir32, platform as osPlatform2, arch as osArch } from "os";
+import { existsSync as existsSync57, readFileSync as readFileSync47 } from "fs";
+import { join as join54, sep as sep4 } from "path";
+import { homedir as homedir33, platform as osPlatform2, arch as osArch } from "os";
 var BASE_URL2 = process.env.RUNWORK_DOWNLOAD_BASE_URL || "https://runwork.ai";
 var LATEST_JSON_URL2 = `${BASE_URL2}/cli/latest.json`;
 function detectPlatform() {
@@ -25374,10 +26398,10 @@ function buildContext() {
   const credentials = getCredentials();
   const client = credentials ? new ApiClient(credentials) : null;
   let config = null;
-  const configPath = join53(process.cwd(), ".runwork.json");
-  if (existsSync56(configPath)) {
+  const configPath = join54(process.cwd(), ".runwork.json");
+  if (existsSync57(configPath)) {
     try {
-      config = JSON.parse(readFileSync46(configPath, "utf-8"));
+      config = JSON.parse(readFileSync47(configPath, "utf-8"));
     } catch {}
   }
   return { credentials, client, config, cwd: process.cwd() };
@@ -25431,8 +26455,8 @@ async function checkCliVersion() {
   };
 }
 async function checkCliArtifactReachable() {
-  const platform7 = detectPlatform();
-  if (!platform7.key) {
+  const platform9 = detectPlatform();
+  if (!platform9.key) {
     return {
       name: "cli-artifact",
       status: "skip",
@@ -25448,12 +26472,12 @@ async function checkCliArtifactReachable() {
       fix: "check network / outbound access to runwork.ai"
     };
   }
-  const entry = manifest.artifacts?.[platform7.key];
+  const entry = manifest.artifacts?.[platform9.key];
   if (!entry?.path) {
     return {
       name: "cli-artifact",
       status: "fail",
-      message: `manifest has no artifact for ${platform7.key}`
+      message: `manifest has no artifact for ${platform9.key}`
     };
   }
   const artifactUrl = `${BASE_URL2}${entry.path}`;
@@ -25466,7 +26490,7 @@ async function checkCliArtifactReachable() {
         message: `${artifactUrl} returned HTTP ${response.status}`
       };
     }
-    return { name: "cli-artifact", status: "pass", message: `${platform7.key} reachable` };
+    return { name: "cli-artifact", status: "pass", message: `${platform9.key} reachable` };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -25478,9 +26502,9 @@ async function checkCliArtifactReachable() {
 }
 async function checkCliInstallLocation() {
   const isWindows2 = osPlatform2() === "win32";
-  const home = homedir32();
-  const canonicalDir = join53(home, ".runwork", "bin");
-  const canonicalBinary = isWindows2 ? join53(canonicalDir, "runwork.exe") : join53(canonicalDir, "runwork");
+  const home2 = homedir33();
+  const canonicalDir = join54(home2, ".runwork", "bin");
+  const canonicalBinary = isWindows2 ? join54(canonicalDir, "runwork.exe") : join54(canonicalDir, "runwork");
   const candidates = [process.execPath, process.argv[1] || ""].filter(Boolean);
   const runsFromCanonical = candidates.some((p) => normalizePath(p) === normalizePath(canonicalBinary));
   if (runsFromCanonical) {
@@ -25490,7 +26514,7 @@ async function checkCliInstallLocation() {
       message: `canonical (${canonicalBinary})`
     };
   }
-  if (existsSync56(canonicalBinary)) {
+  if (existsSync57(canonicalBinary)) {
     return {
       name: "cli-install-location",
       status: "warn",
@@ -25623,8 +26647,8 @@ async function checkGitCredentialHelper(ctx) {
   };
 }
 async function checkProjectConfig(ctx) {
-  const configPath = join53(ctx.cwd, ".runwork.json");
-  if (!existsSync56(configPath)) {
+  const configPath = join54(ctx.cwd, ".runwork.json");
+  if (!existsSync57(configPath)) {
     if (!ctx.credentials) {
       return { name: "project-config", status: "skip", message: "no project (not logged in)" };
     }
@@ -25686,7 +26710,7 @@ async function checkGitRemote(ctx) {
   if (!ctx.config) {
     return { name: "git-remote", status: "skip", message: "skipped (no project)" };
   }
-  if (!existsSync56(join53(ctx.cwd, ".git"))) {
+  if (!existsSync57(join54(ctx.cwd, ".git"))) {
     return {
       name: "git-remote",
       status: "fail",
@@ -25740,12 +26764,12 @@ async function checkDeployFreshness(ctx) {
   return { name: "deploy-freshness", status: "skip", message: "local HEAD unknown" };
 }
 function loadSetupState5() {
-  const projectPath = join53(process.cwd(), ".runwork", "setup.json");
-  const userPath = join53(homedir32(), ".runwork", "setup.json");
+  const projectPath = join54(process.cwd(), ".runwork", "setup.json");
+  const userPath = join54(homedir33(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
-    if (existsSync56(p)) {
+    if (existsSync57(p)) {
       try {
-        return JSON.parse(readFileSync46(p, "utf-8"));
+        return JSON.parse(readFileSync47(p, "utf-8"));
       } catch {
         continue;
       }
@@ -25760,13 +26784,13 @@ async function checkCodexNetwork() {
   if (!state || !state.configuredAgents.includes("codex")) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const configPath = join53(homedir32(), ".codex", "config.toml");
-  if (!existsSync56(configPath)) {
+  const configPath = join54(homedir33(), ".codex", "config.toml");
+  if (!existsSync57(configPath)) {
     return { name, status: "skip", message: "no Codex config found" };
   }
   let parsed;
   try {
-    parsed = parse2(readFileSync46(configPath, "utf-8"));
+    parsed = parse2(readFileSync47(configPath, "utf-8"));
   } catch {
     return { name, status: "warn", message: "could not parse ~/.codex/config.toml" };
   }
@@ -25819,19 +26843,19 @@ async function checkCodexDesktopProject() {
   if (!usesCodex) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const statePath2 = join53(homedir32(), ".codex", ".codex-global-state.json");
-  if (!existsSync56(statePath2)) {
+  const statePath2 = join54(homedir33(), ".codex", ".codex-global-state.json");
+  if (!existsSync57(statePath2)) {
     return { name, status: "skip", message: "Codex desktop app not detected" };
   }
   let savedRoots = [];
   try {
-    const parsed = JSON.parse(readFileSync46(statePath2, "utf-8"));
+    const parsed = JSON.parse(readFileSync47(statePath2, "utf-8"));
     const roots = parsed["electron-saved-workspace-roots"];
     savedRoots = Array.isArray(roots) ? roots.filter((r) => typeof r === "string") : [];
   } catch {
     return { name, status: "warn", message: "could not read Codex desktop state" };
   }
-  const runworkDir = join53(homedir32(), ".runwork");
+  const runworkDir = join54(homedir33(), ".runwork");
   if (savedRoots.includes(runworkDir)) {
     return { name, status: "pass", message: "Runwork project added to Codex desktop sidebar" };
   }
@@ -25879,31 +26903,35 @@ async function checkAgentSetup() {
     details.push(`${state.configuredAgents.length} agent(s) configured`);
   }
   let mcpChecked = false;
+  let mcpAllHealthy = true;
   for (const slug of state.configuredAgents) {
     const adapter2 = getAdapterBySlug(slug);
     if (!adapter2 || !adapter2.supportsMcpScope("user"))
       continue;
     const mcpConfigPath = getMcpConfigPath2(slug, "user");
-    if (mcpConfigPath && existsSync56(mcpConfigPath)) {
+    if (mcpConfigPath && existsSync57(mcpConfigPath)) {
       try {
-        const content = readFileSync46(mcpConfigPath, "utf-8");
+        const content = readFileSync47(mcpConfigPath, "utf-8");
         const missingMcp = state.mcpServers.filter((name) => !content.includes(name));
         if (missingMcp.length > 0) {
           details.push(`${missingMcp.length} MCP server(s) missing from ${slug} config`);
           upgrade("warn");
-        } else {
-          details.push(`${state.mcpServers.length} MCP server(s) configured`);
+          mcpAllHealthy = false;
         }
         mcpChecked = true;
-        break;
       } catch {}
     }
   }
+  if (mcpChecked && mcpAllHealthy && state.mcpServers.length > 0) {
+    details.push(`${state.mcpServers.length} MCP server(s) configured`);
+  }
   if (!mcpChecked && state.mcpServers.length > 0) {
     details.push("could not verify MCP servers");
     upgrade("warn");
   }
   let skillsChecked = false;
+  let skillsAllHealthy = true;
+  let skillsSummaryLine = null;
   for (const slug of state.configuredAgents) {
     const skillsDir = getSkillsDir(slug, "user");
     if (!skillsDir)
@@ -25914,19 +26942,22 @@ async function checkAgentSetup() {
     const missingSkills = state.skills.filter((name) => {
       if (isCoveredByMcp(name))
         return false;
-      const skillPath = join53(skillsDir, name, "SKILL.md");
-      return !existsSync56(skillPath);
+      const skillPath = join54(skillsDir, name, "SKILL.md");
+      return !existsSync57(skillPath);
     });
     if (missingSkills.length > 0) {
       details.push(`${missingSkills.length} skill(s) missing from ${slug}`);
       upgrade("warn");
-    } else if (state.skills.length > 0) {
+      skillsAllHealthy = false;
+    } else if (state.skills.length > 0 && !skillsSummaryLine) {
       const mcpCoveredCount = state.skills.filter(isCoveredByMcp).length;
       const onDiskCount = state.skills.length - mcpCoveredCount;
-      details.push(mcpCoveredCount > 0 ? `${state.skills.length} skill(s) installed (${onDiskCount} on disk, ${mcpCoveredCount} via MCP)` : `${state.skills.length} skill(s) installed`);
+      skillsSummaryLine = mcpCoveredCount > 0 ? `${state.skills.length} skill(s) installed (${onDiskCount} on disk, ${mcpCoveredCount} via MCP)` : `${state.skills.length} skill(s) installed`;
     }
     skillsChecked = true;
-    break;
+  }
+  if (skillsChecked && skillsAllHealthy && skillsSummaryLine) {
+    details.push(skillsSummaryLine);
   }
   if (!skillsChecked && state.skills.length > 0) {
     details.push("could not verify skills");
@@ -25942,28 +26973,28 @@ async function checkAgentSetup() {
   };
 }
 function getMcpConfigPath2(slug, scope) {
-  const home = homedir32();
+  const home2 = homedir33();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join53(process.cwd(), ".mcp.json") : join53(home, ".claude", "settings.json");
+      return scope === "project" ? join54(process.cwd(), ".mcp.json") : join54(home2, ".claude", "settings.json");
     case "cursor":
-      return scope === "project" ? join53(process.cwd(), ".cursor", "mcp.json") : join53(home, ".cursor", "mcp.json");
+      return scope === "project" ? join54(process.cwd(), ".cursor", "mcp.json") : join54(home2, ".cursor", "mcp.json");
     case "windsurf":
-      return scope === "project" ? join53(process.cwd(), ".windsurf", "mcp.json") : join53(home, ".windsurf", "mcp.json");
+      return scope === "project" ? join54(process.cwd(), ".windsurf", "mcp.json") : join54(home2, ".windsurf", "mcp.json");
     case "codex":
     case "codex-app":
-      return scope === "user" ? join53(home, ".codex", "config.toml") : null;
+      return scope === "user" ? join54(home2, ".codex", "config.toml") : null;
     case "gemini":
-      return scope === "user" ? join53(home, ".gemini", "settings.json") : null;
+      return scope === "user" ? join54(home2, ".gemini", "settings.json") : null;
     default:
       return null;
   }
 }
 async function checkWorkspacePointers() {
-  const userStatePath = join53(homedir32(), ".runwork", "setup.json");
-  const state = existsSync56(userStatePath) ? (() => {
+  const userStatePath = join54(homedir33(), ".runwork", "setup.json");
+  const state = existsSync57(userStatePath) ? (() => {
     try {
-      return JSON.parse(readFileSync46(userStatePath, "utf-8"));
+      return JSON.parse(readFileSync47(userStatePath, "utf-8"));
     } catch {
       return null;
     }
@@ -25993,15 +27024,15 @@ async function checkWorkspacePointers() {
   };
 }
 function getSkillsDir(slug, scope) {
-  const home = homedir32();
+  const home2 = homedir33();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join53(process.cwd(), ".claude", "skills") : join53(home, ".claude", "skills");
+      return scope === "project" ? join54(process.cwd(), ".claude", "skills") : join54(home2, ".claude", "skills");
     case "codex":
     case "codex-app":
-      return scope === "project" ? join53(process.cwd(), ".agents", "skills") : join53(home, ".agents", "skills");
+      return scope === "project" ? join54(process.cwd(), ".agents", "skills") : join54(home2, ".agents", "skills");
     case "gemini":
-      return scope === "project" ? join53(process.cwd(), ".gemini", "skills") : join53(home, ".gemini", "skills");
+      return scope === "project" ? join54(process.cwd(), ".gemini", "skills") : join54(home2, ".gemini", "skills");
     default:
       return null;
   }
@@ -26054,8 +27085,8 @@ async function runAllChecks(options) {
 // src/health/fix.ts
 init_credentials();
 init_remote();
-import { existsSync as existsSync57 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync58 } from "fs";
+import { join as join55 } from "path";
 async function applyDoctorFixes(ctx, failingNames) {
   const failing = new Set(failingNames);
   const outcomes = [];
@@ -26082,7 +27113,7 @@ async function applyDoctorFixes(ctx, failingNames) {
         applied: false,
         message: "no project config -- run inside an app directory"
       });
-    } else if (!existsSync57(join54(ctx.cwd, ".git"))) {
+    } else if (!existsSync58(join55(ctx.cwd, ".git"))) {
       outcomes.push({
         name: "git-remote",
         applied: false,
@@ -26101,10 +27132,10 @@ async function applyDoctorFixes(ctx, failingNames) {
 }
 
 // src/agents/runtime-detection.ts
-import { existsSync as existsSync58, readFileSync as readFileSync47, statSync as statSync10, readdirSync as readdirSync17 } from "fs";
-import { homedir as homedir33 } from "os";
-import { join as join55 } from "path";
-var RUNWORK_SESSIONS_DIR = join55(homedir33(), ".runwork", "sessions");
+import { existsSync as existsSync59, readFileSync as readFileSync48, statSync as statSync12, readdirSync as readdirSync18 } from "fs";
+import { homedir as homedir34 } from "os";
+import { join as join56 } from "path";
+var RUNWORK_SESSIONS_DIR = join56(homedir34(), ".runwork", "sessions");
 function detectCurrentAgent() {
   const claudeCodeSessionId = process.env.CLAUDE_CODE_SESSION_ID;
   if (claudeCodeSessionId) {
@@ -26167,11 +27198,11 @@ function detectCurrentAgent() {
   return null;
 }
 function readHookSessionInfo(sessionId) {
-  const path4 = join55(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
-  if (!existsSync58(path4))
+  const path4 = join56(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync59(path4))
     return null;
   try {
-    const raw = readFileSync47(path4, "utf8");
+    const raw = readFileSync48(path4, "utf8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -26179,40 +27210,40 @@ function readHookSessionInfo(sessionId) {
   }
 }
 function findClaudeCodeSessionFile(sessionId) {
-  const root = join55(homedir33(), ".claude", "projects");
-  if (!existsSync58(root))
+  const root = join56(homedir34(), ".claude", "projects");
+  if (!existsSync59(root))
     return null;
   let projectDirs;
   try {
-    projectDirs = readdirSync17(root);
+    projectDirs = readdirSync18(root);
   } catch {
     return null;
   }
   for (const dir of projectDirs) {
-    const candidate = join55(root, dir, `${sessionId}.jsonl`);
-    if (existsSync58(candidate))
+    const candidate = join56(root, dir, `${sessionId}.jsonl`);
+    if (existsSync59(candidate))
       return candidate;
   }
   return null;
 }
 function findCodexRolloutFile(threadId) {
-  const root = join55(homedir33(), ".codex", "sessions");
-  if (!existsSync58(root))
+  const root = join56(homedir34(), ".codex", "sessions");
+  if (!existsSync59(root))
     return null;
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync17(dir);
+      entries = readdirSync18(dir);
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = join55(dir, entry);
+      const full = join56(dir, entry);
       let s;
       try {
-        s = statSync10(full);
+        s = statSync12(full);
       } catch {
         continue;
       }
@@ -26226,30 +27257,30 @@ function findCodexRolloutFile(threadId) {
   return null;
 }
 function findNewestClaudeCodeSession() {
-  const root = join55(homedir33(), ".claude", "projects");
-  if (!existsSync58(root))
+  const root = join56(homedir34(), ".claude", "projects");
+  if (!existsSync59(root))
     return null;
   let projectDirs;
   try {
-    projectDirs = readdirSync17(root);
+    projectDirs = readdirSync18(root);
   } catch {
     return null;
   }
   let best = null;
   for (const dir of projectDirs) {
-    const projectPath = join55(root, dir);
+    const projectPath = join56(root, dir);
     let files;
     try {
-      files = readdirSync17(projectPath);
+      files = readdirSync18(projectPath);
     } catch {
       continue;
     }
     for (const file of files) {
       if (!file.endsWith(".jsonl"))
         continue;
-      const full = join55(projectPath, file);
+      const full = join56(projectPath, file);
       try {
-        const s = statSync10(full);
+        const s = statSync12(full);
         if (!best || s.mtimeMs > best.mtime) {
           best = {
             sessionId: file.replace(/\.jsonl$/, ""),
@@ -26265,8 +27296,8 @@ function findNewestClaudeCodeSession() {
   return best ? { sessionId: best.sessionId, path: best.path } : null;
 }
 function findNewestCodexRollout() {
-  const root = join55(homedir33(), ".codex", "sessions");
-  if (!existsSync58(root))
+  const root = join56(homedir34(), ".codex", "sessions");
+  if (!existsSync59(root))
     return null;
   const stack = [root];
   let best = null;
@@ -26274,15 +27305,15 @@ function findNewestCodexRollout() {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync17(dir);
+      entries = readdirSync18(dir);
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = join55(dir, entry);
+      const full = join56(dir, entry);
       let s;
       try {
-        s = statSync10(full);
+        s = statSync12(full);
       } catch {
         continue;
       }
@@ -26506,13 +27537,697 @@ var doctorCommand = new Command34("doctor").description("Check system health: au
   }
 });
 
+// src/commands/debug.ts
+init_colors();
+import { Command as Command35 } from "commander";
+import { readFileSync as readFileSync49 } from "fs";
+import { homedir as homedir36, platform as platform9, release, arch, type as osType } from "os";
+import { join as join59 } from "path";
+
+// src/debug/capture-plan.ts
+init_transcript_stores();
+init_registry_data();
+var CONFIG_MAX_BYTES = 64 * 1024;
+var LOG_TAIL_BYTES = 64 * 1024;
+var CENSUS_MAX_ENTRIES = 200;
+var ENV_NAMES = [
+  "PATH",
+  "SHELL",
+  "HOME",
+  "USERPROFILE",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "XDG_CONFIG_HOME",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "NO_PROXY",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "RUNWORK_HTTP_TRANSPORT",
+  "RUNWORK_API_URL",
+  "TERM_PROGRAM",
+  "LANG"
+];
+function buildCapturePlan(input) {
+  const sep5 = input.sep ?? (input.platform === "win32" ? "\\" : "/");
+  const join57 = (...parts) => parts.join(sep5);
+  const home2 = input.homeDir.replace(/[/\\]+$/, "");
+  const rw = (...parts) => join57(home2, ".runwork", ...parts);
+  const steps = [];
+  steps.push({ id: "env", kind: "env", names: ENV_NAMES, note: "process environment (proxy credentials stripped)" });
+  for (const [id, file] of [
+    ["runwork.setup", "setup.json"],
+    ["runwork.workspaces", "workspaces.json"],
+    ["runwork.reflect-state", "reflect-state.json"],
+    ["runwork.reflect-runs", "reflect-runs.json"],
+    ["runwork.telemetry-outbox", "telemetry-outbox.json"],
+    ["runwork.session-summaries-outbox", "session-summaries-outbox.json"]
+  ]) {
+    steps.push({ id, kind: "file", path: rw(file), maxBytes: CONFIG_MAX_BYTES });
+  }
+  for (const [id, file] of [
+    ["runwork.conversations", "conversations.json"],
+    ["runwork.reflect-queue", "reflect-queue.json"],
+    ["runwork.insights", "insights.json"],
+    ["runwork.pattern-store", "pattern-store.json"]
+  ]) {
+    steps.push({ id, kind: "stat", path: rw(file), note: "size and mtime only: contains conversation text" });
+  }
+  steps.push({ id: "runwork.dir", kind: "census", path: rw(), depth: 1, maxEntries: CENSUS_MAX_ENTRIES }, { id: "runwork.bin", kind: "census", path: rw("bin"), depth: 1, maxEntries: 50, note: "which CLI binaries are installed here" }, { id: "runwork.sessions", kind: "census", path: rw("sessions"), depth: 1, maxEntries: CENSUS_MAX_ENTRIES, note: "written by the agent hooks we install" }, { id: "runwork.log", kind: "file", path: rw("desktop-launch.log"), maxBytes: LOG_TAIL_BYTES, tail: true, note: "tail: this log has no rotation" });
+  for (const [id, ...parts] of [
+    ["claude.settings", ".claude", "settings.json"],
+    ["claude.md", ".claude", "CLAUDE.md"],
+    ["claude.mcp", ".claude", ".mcp.json"],
+    ["codex.config", ".codex", "config.toml"],
+    ["codex.agents-md", ".codex", "AGENTS.md"],
+    ["gemini.settings", ".gemini", "settings.json"]
+  ]) {
+    steps.push({ id, kind: "file", path: join57(home2, ...parts), maxBytes: CONFIG_MAX_BYTES });
+  }
+  steps.push({
+    id: "claude.desktop-config",
+    kind: "file",
+    path: join57(appDataRootFor(input, join57), "Claude", "claude_desktop_config.json"),
+    maxBytes: CONFIG_MAX_BYTES,
+    note: "the MCP config we write for Claude Desktop, next to its session store"
+  });
+  steps.push({
+    id: "codex.version",
+    kind: "file",
+    path: join57(home2, ".codex", "version.json"),
+    maxBytes: 4096,
+    note: "Codex build, for placing an unrecognised originator value"
+  });
+  for (const [id, ...parts] of [
+    ["claude.skills", ".claude", "skills"],
+    ["claude.plugins", ".claude", "plugins"],
+    ["agents.skills", ".agents", "skills"],
+    ["codex.skills", ".codex", "skills"]
+  ]) {
+    steps.push({ id, kind: "census", path: join57(home2, ...parts), depth: 1, maxEntries: CENSUS_MAX_ENTRIES });
+  }
+  for (const store of resolveTranscriptStores({
+    platform: input.platform,
+    homeDir: home2,
+    sep: sep5,
+    appData: input.appData,
+    localAppData: input.localAppData
+  })) {
+    const id = `stores.${store.def.id.replace(/\//g, ".")}`;
+    steps.push(store.def.kind === "file" ? { id, kind: "stat", path: store.path, ...store.def.note ? { note: store.def.note } : {} } : { id, kind: "census", path: store.path, depth: 2, maxEntries: CENSUS_MAX_ENTRIES, ...store.def.note ? { note: store.def.note } : {} });
+    for (const parent of parentsWorthProbing(store.path, sep5)) {
+      steps.push({ id: `${id}.parent`, kind: "census", path: parent, depth: 1, maxEntries: 50, note: "is the vendor directory there at all" });
+    }
+    store.altPaths.forEach((alt, i) => {
+      steps.push({ id: `${id}.alt${i}`, kind: "stat", path: alt, note: "alternate location; a hit means the canonical path is wrong here" });
+    });
+  }
+  if (input.platform === "win32") {
+    steps.push({
+      id: "windows.appx-packages",
+      kind: "census",
+      path: join57(input.localAppData ?? join57(home2, "AppData", "Local"), "Packages"),
+      depth: 1,
+      maxEntries: CENSUS_MAX_ENTRIES,
+      note: "AppX package identities: an MSIX agent can virtualize its writes in here"
+    });
+  }
+  for (const profile of shellProfiles(input.platform)) {
+    steps.push({
+      id: `shell${profile}`,
+      kind: "stat",
+      path: join57(home2, profile),
+      note: "presence only: profile bodies can contain the user's own secrets"
+    });
+  }
+  steps.push(...binaryResolutionSteps(input));
+  steps.push(...agentBinaryProbes(input));
+  if (input.cliPath) {
+    steps.push({ id: "cli.version", kind: "exec", command: input.cliPath, args: ["--version"] }, { id: "cli.doctor", kind: "exec", command: input.cliPath, args: ["--json", "doctor", "-v"] }, { id: "cli.conversations", kind: "exec", command: input.cliPath, args: ["--json", "conversations", "status", "--days", "0"], note: "per-agent scan outcome, no conversation data" }, { id: "cli.stores", kind: "exec", command: input.cliPath, args: ["--json", "conversations", "stores"], note: "per-store contents and provenance, no conversation text" });
+  }
+  return steps;
+}
+function parentsWorthProbing(storePath4, sep5) {
+  const idx = storePath4.lastIndexOf(sep5);
+  if (idx <= 0)
+    return [];
+  const parent = storePath4.slice(0, idx);
+  const parentIdx = parent.lastIndexOf(sep5);
+  if (parentIdx <= 0)
+    return [];
+  return [parent];
+}
+function agentBinaryProbes(input) {
+  const finder = input.platform === "win32" ? "where.exe" : "which";
+  const args = (binary) => input.platform === "win32" ? [binary] : ["-a", binary];
+  const seen = new Set;
+  const steps = [];
+  for (const agent of getDetectableAgents()) {
+    const binary = agent.launch?.cli;
+    if (!binary || seen.has(binary))
+      continue;
+    seen.add(binary);
+    steps.push({
+      id: `agent-binary.${agent.slug}`,
+      kind: "exec",
+      command: finder,
+      args: args(binary),
+      note: `is ${agent.name}'s CLI on PATH, and where`
+    });
+  }
+  return steps;
+}
+function appDataRootFor(input, join57) {
+  const home2 = input.homeDir.replace(/[/\\]+$/, "");
+  if (input.platform === "darwin")
+    return join57(home2, "Library", "Application Support");
+  if (input.platform === "win32")
+    return input.appData ?? join57(home2, "AppData", "Roaming");
+  return join57(home2, ".config");
+}
+function shellProfiles(platform9) {
+  if (platform9 === "win32")
+    return [];
+  return [".zshrc", ".zprofile", ".bashrc", ".bash_profile", ".profile"];
+}
+function binaryResolutionSteps(input) {
+  const sep5 = input.sep ?? (input.platform === "win32" ? "\\" : "/");
+  const join57 = (...parts) => parts.join(sep5);
+  const home2 = input.homeDir.replace(/[/\\]+$/, "");
+  if (input.platform === "win32") {
+    return [
+      { id: "binaries.where", kind: "exec", command: "where.exe", args: ["runwork"], note: "every match, not just the first" },
+      { id: "binaries.runwork-bin", kind: "stat", path: join57(home2, ".runwork", "bin", "runwork.exe") },
+      { id: "binaries.user-path", kind: "exec", command: "reg.exe", args: ["query", "HKCU\\Environment", "/v", "Path"], note: "the PATH a NEW shell will inherit, not this one" }
+    ];
+  }
+  return [
+    { id: "binaries.which", kind: "exec", command: "which", args: ["-a", "runwork"], note: "every match, not just the first" },
+    { id: "binaries.runwork-bin", kind: "stat", path: join57(home2, ".runwork", "bin", "runwork") },
+    { id: "binaries.local-bin", kind: "stat", path: join57(home2, ".local", "bin", "runwork") },
+    ...input.platform === "darwin" ? [{ id: "binaries.usr-local-bin", kind: "stat", path: "/usr/local/bin/runwork" }] : []
+  ];
+}
+
+// src/debug/capture.ts
+var CAPTURE_FORMAT = 1;
+function summarizeBundle(jsonl) {
+  const summary = {
+    formatVersion: CAPTURE_FORMAT,
+    producer: null,
+    stepsPlanned: 0,
+    stepsRun: 0,
+    redactions: 0,
+    withheld: 0,
+    complete: false
+  };
+  for (const line of jsonl.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type === "plan") {
+      summary.formatVersion = record.format;
+      summary.producer = record.producer;
+      summary.stepsPlanned = record.steps.length;
+    } else if (record.type === "step") {
+      summary.stepsRun++;
+      summary.redactions += record.redactions ?? 0;
+      summary.withheld += record.withheld ?? 0;
+    } else if (record.type === "complete") {
+      summary.complete = true;
+    }
+  }
+  return summary;
+}
+async function sha256Hex(text2) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text2));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var NEVER_READ = [".credentials", "credentials.json", "auth.json", ".netrc", "id_rsa"];
+function isForbiddenPath(path4) {
+  const name = path4.split(/[/\\]/).pop()?.toLowerCase() ?? "";
+  return NEVER_READ.some((deny) => name === deny.toLowerCase());
+}
+var SECRET_KEY_NAMES = "token|secret|password|passwd|api[-_]?key|apikey|authorization|access[-_]?token|refresh[-_]?token|client[-_]?secret|private[-_]?key|access[-_]?key|credentials?";
+var SECRET_KEY_PATTERN = `[A-Za-z0-9_-]*?(?:${SECRET_KEY_NAMES})`;
+var QUOTED_VALUE = String.raw`"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'`;
+var SECRET_QUERY_PARAMS = "token|key|secret|password|api[-_]?key|apikey|access[-_]?token|sig|signature";
+function redactSecrets(text2) {
+  let redactions = 0;
+  const mark = () => {
+    redactions++;
+    return "<redacted>";
+  };
+  const out = text2.replace(new RegExp(`([?&](?:${SECRET_QUERY_PARAMS})=)[^&\\s"'\`]+`, "gi"), (_m, prefix) => `${prefix}${mark()}`).replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi, (_m, prefix) => `${prefix}${mark()}`).replace(new RegExp(`("?${SECRET_KEY_PATTERN}"?\\s*[:=]\\s*)(${QUOTED_VALUE}|[^\\s,}\\]&"']+)`, "gi"), (match, prefix, value) => {
+    if (value.includes("<redacted>"))
+      return match;
+    const quote = value.startsWith('"') ? '"' : value.startsWith("'") ? "'" : "";
+    return `${prefix}${quote}${mark()}${quote}`;
+  });
+  return { text: out, redactions };
+}
+var CONTENT_KEY_NAMES = "currentTitle|title|prompt|userMessages|summary|body|snippet";
+function redactUserContent(text2) {
+  let withheld = 0;
+  const out = text2.replace(new RegExp(`("?\\b(?:${CONTENT_KEY_NAMES})"?\\s*[:=]\\s*)(${QUOTED_VALUE})`, "gi"), (match, prefix, value) => {
+    if (value === '""' || value === "''")
+      return match;
+    withheld++;
+    const quote = value[0];
+    return `${prefix}${quote}<withheld>${quote}`;
+  });
+  return { text: out, withheld };
+}
+function redactEnvValue(value) {
+  if (value === null)
+    return null;
+  return value.replace(/(\w+:\/\/)[^/@\s]*@/g, "$1<redacted>@");
+}
+function classifyCaptureError(err) {
+  const e = err;
+  const code = e && typeof e === "object" && typeof e.code === "string" ? e.code : undefined;
+  const message = e instanceof Error ? e.message : String(err);
+  if (code === "ENOENT" || code === "ENOTDIR")
+    return { status: "missing", detail: code };
+  if (code === "EACCES" || code === "EPERM")
+    return { status: "denied", detail: code };
+  if (code === "ETIMEDOUT" || code === "TIMEOUT")
+    return { status: "timeout", detail: code };
+  if (code === "ESCOPE")
+    return { status: "skipped", detail: message };
+  return { status: "error", detail: code ? `${code}: ${message}` : message };
+}
+function stepTarget(step) {
+  switch (step.kind) {
+    case "file":
+    case "census":
+    case "stat":
+      return step.path;
+    case "env":
+      return step.names.join(",");
+    case "exec":
+      return [step.command, ...step.args].join(" ");
+  }
+}
+function withDeadline(work, ms) {
+  return new Promise((resolve5, reject) => {
+    const timer = setTimeout(() => reject(Object.assign(new Error("step deadline"), { code: "TIMEOUT" })), ms);
+    work.then((value) => {
+      clearTimeout(timer);
+      resolve5(value);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function runStep(port, step, deadlineMs) {
+  const startedMs = port.now();
+  const base = { type: "step", id: step.id, kind: step.kind, target: stepTarget(step) };
+  const done = (extra) => ({ ...base, status: "ok", durationMs: port.now() - startedMs, ...extra });
+  if ((step.kind === "file" || step.kind === "stat") && isForbiddenPath(step.path)) {
+    return { ...base, status: "skipped", detail: "excluded by policy", durationMs: 0 };
+  }
+  try {
+    switch (step.kind) {
+      case "file": {
+        const raw = await withDeadline(port.readText(step.path, step.maxBytes, step.tail === true), deadlineMs);
+        const secrets = redactSecrets(raw.text);
+        const content = redactUserContent(secrets.text);
+        return done({
+          text: content.text,
+          truncated: raw.truncated,
+          ...secrets.redactions > 0 ? { redactions: secrets.redactions } : {},
+          ...content.withheld > 0 ? { withheld: content.withheld } : {}
+        });
+      }
+      case "census": {
+        const entries = await withDeadline(port.listDir(step.path, step.depth, step.maxEntries), deadlineMs);
+        return done({ entries, entryCount: entries.length });
+      }
+      case "stat": {
+        const info = await withDeadline(port.stat(step.path), deadlineMs);
+        return done({ bytes: info.bytes, modifiedAt: info.modifiedAt });
+      }
+      case "env": {
+        const raw = port.env(step.names);
+        return done({
+          env: Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, redactEnvValue(v)]))
+        });
+      }
+      case "exec": {
+        const result = await withDeadline(port.exec(step.command, step.args), deadlineMs);
+        const out = redactSecrets(result.stdout);
+        const err = redactSecrets(result.stderr);
+        const redactions = out.redactions + err.redactions;
+        return done({
+          text: out.text,
+          exitCode: result.exitCode,
+          stderr: err.text,
+          ...redactions > 0 ? { redactions } : {}
+        });
+      }
+    }
+  } catch (err) {
+    const { status, detail } = classifyCaptureError(err);
+    return { ...base, status, detail, durationMs: port.now() - startedMs };
+  }
+}
+async function runCapture(port, producer, steps, opts = {}) {
+  const deadlineMs = opts.stepDeadlineMs ?? 1e4;
+  const startedMs = port.now();
+  await port.append({
+    type: "plan",
+    format: CAPTURE_FORMAT,
+    producer,
+    startedAt: new Date(startedMs).toISOString(),
+    steps: steps.map((s) => ({ id: s.id, kind: s.kind, ...s.note ? { note: s.note } : {} }))
+  });
+  let stepsRun = 0;
+  for (const step of steps) {
+    await port.append(await runStep(port, step, deadlineMs));
+    stepsRun++;
+  }
+  if (opts.claims) {
+    try {
+      for (const claim of await opts.claims())
+        await port.append(claim);
+    } catch (err) {
+      await port.append({
+        type: "claim",
+        id: "claims-failed",
+        producer,
+        value: { error: err instanceof Error ? err.message : String(err) }
+      });
+    }
+  }
+  await port.append({
+    type: "complete",
+    finishedAt: new Date(port.now()).toISOString(),
+    stepsPlanned: steps.length,
+    stepsRun,
+    durationMs: port.now() - startedMs
+  });
+  return { stepsRun };
+}
+
+// src/utils/machine-id.ts
+init_atomic_json();
+import { randomUUID } from "crypto";
+import { homedir as homedir35 } from "os";
+import { join as join57 } from "path";
+function machineIdPath() {
+  return join57(homedir35(), ".runwork", "machine.json");
+}
+function isValidId(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function getMachineId() {
+  const path4 = machineIdPath();
+  const existing = readJsonOrNull(path4);
+  if (existing && isValidId(existing.id))
+    return existing.id;
+  const record = { id: randomUUID(), createdAt: new Date().toISOString() };
+  try {
+    writeJsonAtomic(path4, record);
+  } catch {
+    return null;
+  }
+  const settled = readJsonOrNull(path4);
+  return settled && isValidId(settled.id) ? settled.id : record.id;
+}
+
+// src/commands/debug.ts
+init_store();
+init_client();
+init_resolve();
+
+// src/debug/node-port.ts
+init_subprocess();
+init_which();
+import { closeSync as closeSync6, fsyncSync, mkdirSync as mkdirSync29, openSync as openSync6, readSync as readSync4, readdirSync as readdirSync19, statSync as statSync13, writeSync } from "fs";
+import { dirname as dirname12, join as join58 } from "path";
+var EXEC_OUTPUT_MAX = 256 * 1024;
+var EXEC_TIMEOUT_MS = 20000;
+function truncate5(text2, maxBytes) {
+  return text2.length > maxBytes ? { text: text2.slice(0, maxBytes), truncated: true } : { text: text2, truncated: false };
+}
+function entryKind(path4) {
+  try {
+    const s = statSync13(path4);
+    return s.isDirectory() ? "dir" : s.isFile() ? "file" : "other";
+  } catch {
+    return "other";
+  }
+}
+function createNodeCapturePort(outputPath) {
+  mkdirSync29(dirname12(outputPath), { recursive: true });
+  const fd = openSync6(outputPath, "w");
+  return {
+    close: () => closeSync6(fd),
+    async append(record) {
+      writeSync(fd, JSON.stringify(record) + `
+`);
+      try {
+        fsyncSync(fd);
+      } catch {}
+    },
+    async listDir(path4, depth, maxEntries) {
+      const out = [];
+      const queue = [{ dir: path4, prefix: "", level: 0 }];
+      let first = true;
+      while (queue.length > 0 && out.length < maxEntries) {
+        const { dir, prefix, level } = queue.shift();
+        let names;
+        try {
+          names = readdirSync19(dir);
+        } catch (err) {
+          if (first)
+            throw err;
+          continue;
+        } finally {
+          first = false;
+        }
+        for (const name of names) {
+          if (out.length >= maxEntries)
+            break;
+          const full = join58(dir, name);
+          const kind = entryKind(full);
+          let bytes;
+          let modifiedAt;
+          try {
+            const s = statSync13(full);
+            bytes = s.size;
+            modifiedAt = new Date(s.mtimeMs).toISOString();
+          } catch {}
+          out.push({ name: prefix ? `${prefix}/${name}` : name, kind, ...bytes !== undefined ? { bytes } : {}, ...modifiedAt ? { modifiedAt } : {} });
+          if (kind === "dir" && level + 1 < depth) {
+            queue.push({ dir: full, prefix: prefix ? `${prefix}/${name}` : name, level: level + 1 });
+          }
+        }
+      }
+      return out;
+    },
+    async stat(path4) {
+      const s = statSync13(path4);
+      return {
+        bytes: s.size,
+        modifiedAt: new Date(s.mtimeMs).toISOString(),
+        kind: s.isDirectory() ? "dir" : s.isFile() ? "file" : "other"
+      };
+    },
+    async readText(path4, maxBytes, tail) {
+      const s = statSync13(path4);
+      const size = s.size;
+      const length = Math.min(size, maxBytes);
+      const start = tail && size > maxBytes ? size - maxBytes : 0;
+      const buffer = Buffer.alloc(length);
+      const handle = openSync6(path4, "r");
+      try {
+        readSync4(handle, buffer, 0, length, start);
+      } finally {
+        closeSync6(handle);
+      }
+      return { text: buffer.toString("utf-8"), truncated: size > length };
+    },
+    env(names) {
+      return Object.fromEntries(names.map((n) => [n, process.env[n] ?? null]));
+    },
+    async exec(command, args) {
+      const spec = toSpawnSpec(command, args);
+      const result = spawnSync(spec.command, spec.args, {
+        encoding: "utf-8",
+        timeout: EXEC_TIMEOUT_MS,
+        maxBuffer: EXEC_OUTPUT_MAX,
+        ...spec.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
+      });
+      if (result.error)
+        throw result.error;
+      return {
+        exitCode: result.status ?? -1,
+        stdout: truncate5(result.stdout ?? "", EXEC_OUTPUT_MAX).text,
+        stderr: truncate5(result.stderr ?? "", 8 * 1024).text
+      };
+    },
+    now: () => Date.now()
+  };
+}
+
+// src/commands/debug.ts
+init_transcript_sources();
+init_which();
+await init_detect();
+function defaultOutputPath(now) {
+  const stamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+  return join59(homedir36(), ".runwork", "debug", `runwork-debug-${stamp}.jsonl`);
+}
+async function cliClaims() {
+  const records = [];
+  records.push({
+    type: "claim",
+    id: "producer.process",
+    producer: "cli",
+    value: {
+      cliVersion: VERSION,
+      execPath: process.execPath,
+      argv0: process.argv[1] ?? null,
+      nodeVersion: process.version,
+      platform: platform9(),
+      osType: osType(),
+      release: release(),
+      arch: arch(),
+      cwd: process.cwd()
+    }
+  });
+  records.push({
+    type: "claim",
+    id: "cli.path-resolution",
+    producer: "cli",
+    derivedFrom: ["binaries.which", "binaries.where", "env"],
+    value: { pathResolved: whichBinary("runwork") }
+  });
+  const adapters = await detectAgents();
+  records.push({
+    type: "claim",
+    id: "agents.detected",
+    producer: "cli",
+    derivedFrom: ["transcripts.claude-code", "transcripts.codex", "transcripts.gemini", "transcripts.cowork"],
+    value: adapters.map((adapter2) => {
+      const sources = adapter2.transcriptSources?.() ?? [];
+      return {
+        slug: adapter2.slug,
+        name: adapter2.name,
+        hasListing: typeof adapter2.listSessions === "function",
+        hasDigests: typeof adapter2.readSessionDigests === "function",
+        transcriptSources: sources.map((s) => s.path),
+        readable: sources.length > 0 ? summarizeTranscriptSources(sources) : null
+      };
+    })
+  });
+  return records;
+}
+var debugCommand = new Command35("debug").description("Diagnostics for support");
+debugCommand.command("capture").description("Collect a diagnostic bundle to a file you can send to support").option("--out <path>", "Where to write the bundle (default: ~/.runwork/debug/)").option("--send", "Also send the bundle to Runwork support (requires sign-in)").option("--note <text>", "What went wrong, in your words. Included with --send").action(async (opts, command) => {
+  const json = command.optsWithGlobals().json === true || !process.stdout.isTTY;
+  const outputPath = typeof opts.out === "string" && opts.out ? opts.out : defaultOutputPath(new Date);
+  const cliPath = whichBinary("runwork");
+  const plan = buildCapturePlan({
+    platform: platform9(),
+    homeDir: homedir36(),
+    appData: process.env.APPDATA ?? null,
+    localAppData: process.env.LOCALAPPDATA ?? null,
+    cliPath
+  });
+  if (!json) {
+    console.log(bold(`
+Collecting diagnostics`));
+    console.log(dim(`  ${plan.length} checks, writing to ${outputPath}`));
+  }
+  const port = createNodeCapturePort(outputPath);
+  let stepsRun = 0;
+  try {
+    ({ stepsRun } = await runCapture(port, "cli", plan, { claims: cliClaims }));
+  } finally {
+    port.close();
+  }
+  const sent = opts.send === true ? await sendBundle(outputPath, typeof opts.note === "string" ? opts.note : undefined) : null;
+  if (json) {
+    jsonOut({ path: outputPath, stepsPlanned: plan.length, stepsRun, ...sent ? { sent } : {} });
+    return;
+  }
+  const counted = stepsRun === plan.length ? `${stepsRun}` : `${stepsRun} of ${plan.length}`;
+  console.log(green(`
+Done. ${counted} checks recorded.`));
+  console.log(`
+  ${cyan(outputPath)}
+`);
+  if (!cliPath) {
+    console.log(yellow("Note: no `runwork` was found on PATH, so the doctor report is not included.\n"));
+  }
+  if (!sent) {
+    console.log(dim("Send that file to support. It contains no credentials and no conversation text."));
+    console.log(dim("Or re-run with --send to upload it."));
+    return;
+  }
+  if (sent.ok) {
+    console.log(green(`Sent to Runwork support (report ${sent.id}).`));
+    console.log(dim(`It is kept until ${sent.expiresAt?.slice(0, 10)} and then deleted.`));
+  } else {
+    console.log(yellow(`Could not send: ${sent.error}`));
+    console.log(dim("The file above is saved and can be sent to support by hand."));
+  }
+});
+async function sendBundle(path4, note) {
+  try {
+    const content = readFileSync49(path4, "utf-8");
+    const summary = summarizeBundle(content);
+    const machineId = getMachineId();
+    if (!machineId)
+      return { ok: false, error: "could not identify this machine" };
+    const credentials = getCredentials();
+    if (!credentials)
+      return { ok: false, error: "not signed in; run `runwork login`" };
+    const api = new ApiClient(credentials);
+    const workspace = await resolveWorkspace2(api);
+    const result = await api.createDebugReport(workspace.workspaceId, {
+      machineId,
+      producer: "cli",
+      content,
+      sha256: await sha256Hex(content),
+      formatVersion: summary.formatVersion,
+      ...note ? { note } : {},
+      context: {
+        cliVersion: VERSION,
+        platform: platform9(),
+        release: release(),
+        stepsPlanned: summary.stepsPlanned,
+        stepsRun: summary.stepsRun,
+        redactions: summary.redactions,
+        withheld: summary.withheld,
+        complete: summary.complete
+      }
+    });
+    return { ok: true, id: result.id, expiresAt: result.expiresAt };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 // src/commands/share-convo.ts
 init_store();
 init_client();
 init_resolve();
-import { Command as Command35 } from "commander";
-import { readFileSync as readFileSync48, writeFileSync as writeFileSync33, existsSync as existsSync59, mkdtempSync as mkdtempSync4 } from "fs";
-import { join as join56 } from "path";
+import { Command as Command36 } from "commander";
+import { readFileSync as readFileSync50, writeFileSync as writeFileSync33, existsSync as existsSync60, mkdtempSync as mkdtempSync4 } from "fs";
+import { join as join60 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { createHash as createHash6 } from "crypto";
 
@@ -26634,13 +28349,13 @@ function resolveLocalSessionShare(opts, conversation) {
     process.exit(1);
   }
   const title = opts.title ?? conversation.title ?? conversation.project;
-  const markdown = renderTranscriptMarkdown(readFileSync48(conversation.transcriptPath, "utf8"), family, title);
+  const markdown = renderTranscriptMarkdown(readFileSync50(conversation.transcriptPath, "utf8"), family, title);
   if (!markdown) {
     console.error("Error: this conversation has no shareable content.");
     process.exit(1);
   }
-  const tempDir = mkdtempSync4(join56(tmpdir4(), "runwork-share-"));
-  const transcriptFile = join56(tempDir, "transcript.md");
+  const tempDir = mkdtempSync4(join60(tmpdir4(), "runwork-share-"));
+  const transcriptFile = join60(tempDir, "transcript.md");
   writeFileSync33(transcriptFile, markdown);
   opts.transcriptFile = transcriptFile;
   opts.nativeFile = opts.nativeFile ?? conversation.transcriptPath;
@@ -26657,7 +28372,7 @@ function nativeBundleFormatForAgent(slug) {
     return "codex-rollout";
   return null;
 }
-function sha256Hex(content) {
+function sha256Hex2(content) {
   return createHash6("sha256").update(content, "utf8").digest("hex");
 }
 function utf8ByteLength(content) {
@@ -26678,7 +28393,7 @@ async function runShareConvo(opts, command, isPersonalAlias = false) {
     console.error("Error: --transcript-file is required. Pass the path to the LLM-emitted markdown transcript.");
     process.exit(1);
   }
-  if (!existsSync59(opts.transcriptFile)) {
+  if (!existsSync60(opts.transcriptFile)) {
     console.error(`Error: transcript file does not exist: ${opts.transcriptFile}`);
     process.exit(1);
   }
@@ -26699,37 +28414,37 @@ async function runShareConvo(opts, command, isPersonalAlias = false) {
   const credentials = requireAuth();
   const client = new ApiClient(credentials);
   const { workspaceId } = await resolveWorkspace2(client, { workspace: opts.workspace });
-  const transcriptContent = readFileSync48(opts.transcriptFile, "utf8");
+  const transcriptContent = readFileSync50(opts.transcriptFile, "utf8");
   const bundles = [
     {
       format: "transcript",
       content: transcriptContent,
       sizeBytes: utf8ByteLength(transcriptContent),
-      sha256: sha256Hex(transcriptContent)
+      sha256: sha256Hex2(transcriptContent)
     }
   ];
   const detected = detectCurrentAgent();
   const sourceAgent = opts.sourceAgent ?? detected?.slug ?? "generic";
   let nativeFilePath = null;
   if (opts.nativeFile) {
-    if (!existsSync59(opts.nativeFile)) {
+    if (!existsSync60(opts.nativeFile)) {
       console.error(`Error: --native-file path does not exist: ${opts.nativeFile}`);
       process.exit(1);
     }
     nativeFilePath = opts.nativeFile;
-  } else if (detected?.sessionFilePath && existsSync59(detected.sessionFilePath)) {
+  } else if (detected?.sessionFilePath && existsSync60(detected.sessionFilePath)) {
     nativeFilePath = detected.sessionFilePath;
   }
   if (nativeFilePath) {
     const nativeFormat = nativeBundleFormatForAgent(sourceAgent);
     if (nativeFormat) {
       try {
-        const content = readFileSync48(nativeFilePath, "utf8");
+        const content = readFileSync50(nativeFilePath, "utf8");
         bundles.push({
           format: nativeFormat,
           content,
           sizeBytes: utf8ByteLength(content),
-          sha256: sha256Hex(content)
+          sha256: sha256Hex2(content)
         });
       } catch (err) {
         console.error(`Warning: could not read native file ${nativeFilePath}: ${err instanceof Error ? err.message : err}`);
@@ -26740,7 +28455,7 @@ async function runShareConvo(opts, command, isPersonalAlias = false) {
   let metadata = {};
   if (opts.metadataFile) {
     try {
-      metadata = JSON.parse(readFileSync48(opts.metadataFile, "utf8"));
+      metadata = JSON.parse(readFileSync50(opts.metadataFile, "utf8"));
     } catch (err) {
       console.error(`Error: --metadata-file is not valid JSON: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
@@ -26795,18 +28510,18 @@ Skipped: ${result.skipped.map((s) => `${s.identifier} (${s.reason})`).join(", ")
     process.exit(1);
   }
 }
-var shareConvoCommand = new Command35("share-convo").description("Share the current AI conversation with a teammate").option("--to <email>", "Recipient email (repeatable)", (value, prev = []) => [...prev, value], []).option("--transcript-file <path>", "Path to the LLM-emitted markdown transcript (required unless --session)").option("--session <key>", "Share a LOCAL conversation by registry key (transcript rendered mechanically)").option("--native-file <path>", "Path to the native session file (optional; auto-detected from env vars otherwise)").option("--source-agent <slug>", "Override host-agent detection (e.g. claude-code, codex, claude-desktop)").option("--title <string>", "Short title for the conversation (required)").option("--note <string>", "Optional personal note to recipients").option("--ttl-days <n>", "Days until expiration (1-30, default 7)").option("--metadata-json <json>", "Inline JSON object with workMode, openQuestions, suggestedNextStep, etc.").option("--metadata-file <path>", "Path to a JSON file with the same metadata fields").option("--workspace <name-or-id>", "Workspace name or ID").action((opts, command) => runShareConvo(opts, command, false));
+var shareConvoCommand = new Command36("share-convo").description("Share the current AI conversation with a teammate").option("--to <email>", "Recipient email (repeatable)", (value, prev = []) => [...prev, value], []).option("--transcript-file <path>", "Path to the LLM-emitted markdown transcript (required unless --session)").option("--session <key>", "Share a LOCAL conversation by registry key (transcript rendered mechanically)").option("--native-file <path>", "Path to the native session file (optional; auto-detected from env vars otherwise)").option("--source-agent <slug>", "Override host-agent detection (e.g. claude-code, codex, claude-desktop)").option("--title <string>", "Short title for the conversation (required)").option("--note <string>", "Optional personal note to recipients").option("--ttl-days <n>", "Days until expiration (1-30, default 7)").option("--metadata-json <json>", "Inline JSON object with workMode, openQuestions, suggestedNextStep, etc.").option("--metadata-file <path>", "Path to a JSON file with the same metadata fields").option("--workspace <name-or-id>", "Workspace name or ID").action((opts, command) => runShareConvo(opts, command, false));
 
 // src/commands/save-convo.ts
-import { Command as Command36 } from "commander";
-var saveConvoCommand = new Command36("save-convo").description("Save the current AI conversation as a personal checkpoint").option("--transcript-file <path>", "Path to the LLM-emitted markdown transcript (required)").option("--native-file <path>", "Path to the native session file (optional; auto-detected from env vars)").option("--source-agent <slug>", "Override host-agent detection").option("--title <string>", "Short title for the conversation (required)").option("--note <string>", "Optional note to your future self").option("--ttl-days <n>", "Days until expiration (1-30, default 7)").option("--metadata-json <json>", "Inline JSON object with workMode, openQuestions, etc.").option("--metadata-file <path>", "Path to a JSON file with metadata fields").option("--workspace <name-or-id>", "Workspace name or ID").action((opts, command) => runShareConvo({ ...opts, personal: true }, command, true));
+import { Command as Command37 } from "commander";
+var saveConvoCommand = new Command37("save-convo").description("Save the current AI conversation as a personal checkpoint").option("--transcript-file <path>", "Path to the LLM-emitted markdown transcript (required)").option("--native-file <path>", "Path to the native session file (optional; auto-detected from env vars)").option("--source-agent <slug>", "Override host-agent detection").option("--title <string>", "Short title for the conversation (required)").option("--note <string>", "Optional note to your future self").option("--ttl-days <n>", "Days until expiration (1-30, default 7)").option("--metadata-json <json>", "Inline JSON object with workMode, openQuestions, etc.").option("--metadata-file <path>", "Path to a JSON file with metadata fields").option("--workspace <name-or-id>", "Workspace name or ID").action((opts, command) => runShareConvo({ ...opts, personal: true }, command, true));
 
 // src/commands/inbox.ts
 init_store();
 init_client();
 init_resolve();
-import { Command as Command37 } from "commander";
-var inboxCommand = new Command37("inbox").description("List shared conversations visible to you").option("--filter <scope>", "Filter: all | received | sent | saved", "all").option("--limit <n>", "Max rows to return", "50").option("--workspace <name-or-id>", "Workspace name or ID").action(async (opts, command) => {
+import { Command as Command38 } from "commander";
+var inboxCommand = new Command38("inbox").description("List shared conversations visible to you").option("--filter <scope>", "Filter: all | received | sent | saved", "all").option("--limit <n>", "Max rows to return", "50").option("--workspace <name-or-id>", "Workspace name or ID").action(async (opts, command) => {
   const useJson = shouldOutputJson(command.optsWithGlobals().json);
   const scope = opts.filter === "received" || opts.filter === "sent" || opts.filter === "saved" ? opts.filter : "all";
   const limit = opts.limit ? parseInt(opts.limit, 10) : 50;
@@ -26848,10 +28563,10 @@ init_store();
 init_client();
 init_resolve();
 init_registry_data();
-import { Command as Command38 } from "commander";
-import { writeFileSync as writeFileSync34, mkdirSync as mkdirSync29, realpathSync } from "fs";
-import { homedir as homedir34 } from "os";
-import { join as join57 } from "path";
+import { Command as Command39 } from "commander";
+import { writeFileSync as writeFileSync34, mkdirSync as mkdirSync30, realpathSync } from "fs";
+import { homedir as homedir37 } from "os";
+import { join as join61 } from "path";
 import { spawn as spawn5 } from "child_process";
 init_registry();
 init_which();
@@ -26890,9 +28605,9 @@ function extractCodexUuid(rolloutContent) {
 }
 function placeClaudeJsonl(uuid, content, recipientCwd) {
   const encoded = encodeClaudeCodeCwd(recipientCwd);
-  const projectDir = join57(homedir34(), ".claude", "projects", encoded);
-  mkdirSync29(projectDir, { recursive: true });
-  const placedAt = join57(projectDir, `${uuid}.jsonl`);
+  const projectDir = join61(homedir37(), ".claude", "projects", encoded);
+  mkdirSync30(projectDir, { recursive: true });
+  const placedAt = join61(projectDir, `${uuid}.jsonl`);
   writeFileSync34(placedAt, content);
   return { placedAt, runFromCwd: recipientCwd };
 }
@@ -26901,10 +28616,10 @@ function placeCodexRollout(uuid, content) {
   const yyyy = String(now.getUTCFullYear());
   const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
   const dd = String(now.getUTCDate()).padStart(2, "0");
-  const dir = join57(homedir34(), ".codex", "sessions", yyyy, mm, dd);
-  mkdirSync29(dir, { recursive: true });
+  const dir = join61(homedir37(), ".codex", "sessions", yyyy, mm, dd);
+  mkdirSync30(dir, { recursive: true });
   const ts = now.toISOString().replace(/\.\d+Z$/, "").replace(/:/g, "-");
-  const placedAt = join57(dir, `rollout-${ts}-${uuid}.jsonl`);
+  const placedAt = join61(dir, `rollout-${ts}-${uuid}.jsonl`);
   writeFileSync34(placedAt, content);
   return { placedAt };
 }
@@ -26924,7 +28639,15 @@ function isAgentInstalled(agent) {
   }
   return false;
 }
-var resumeCommand2 = new Command38("resume").description("Resume a shared conversation locally in your agent of choice").argument("<share-id>", "The share ID (sc_*) returned by share-convo or save-convo").option("--agent <slug>", "Override target agent (e.g. claude-code, codex)").option("--into <path>", "Override target cwd (defaults to current $PWD)").option("--dry-run", "Print the resume command instead of executing it").option("--pick", "Show interactive picker (requires TTY) - not yet implemented").option("--workspace <name-or-id>", "Workspace name or ID").action(async (shareId, opts, command) => {
+function buildResumeCommand(template, uuid, resolvedCli, cliName) {
+  const argv = template.replace(/\{uuid\}/g, uuid).split(" ").filter(Boolean);
+  if (resolvedCli && cliName && argv[0] === cliName) {
+    argv[0] = resolvedCli;
+  }
+  const display = [argv[0]?.includes(" ") ? `"${argv[0]}"` : argv[0], ...argv.slice(1)].filter((part) => Boolean(part)).join(" ");
+  return { argv, display };
+}
+var resumeCommand2 = new Command39("resume").description("Resume a shared conversation locally in your agent of choice").argument("<share-id>", "The share ID (sc_*) returned by share-convo or save-convo").option("--agent <slug>", "Override target agent (e.g. claude-code, codex)").option("--into <path>", "Override target cwd (defaults to current $PWD)").option("--dry-run", "Print the resume command instead of executing it").option("--pick", "Show interactive picker (requires TTY) - not yet implemented").option("--workspace <name-or-id>", "Workspace name or ID").action(async (shareId, opts, command) => {
   const useJson = shouldOutputJson(command.optsWithGlobals().json);
   const credentials = requireAuth();
   const client = new ApiClient(credentials);
@@ -27018,12 +28741,8 @@ Bundle placed at: ${placement.placedAt}`);
     return;
   }
   if (cap2.mode === "cli-resume") {
-    let cmd = (cap2.cliResumeCommand ?? "").replace(/\{uuid\}/g, nativeUuid);
-    const resolvedCli = resolveAgentCliCommand(target.slug);
-    const cliName = getAgent(target.slug)?.launch?.cli;
-    if (resolvedCli && cliName && resolvedCli !== cliName && cmd.startsWith(`${cliName} `)) {
-      cmd = `"${resolvedCli}" ${cmd.slice(cliName.length + 1)}`;
-    }
+    const { argv, display } = buildResumeCommand(cap2.cliResumeCommand ?? "", nativeUuid, resolveAgentCliCommand(target.slug), getAgent(target.slug)?.launch?.cli);
+    const cmd = display;
     const detected = detectCurrentAgent();
     const insideSameAgent = detected && detected.slug === target.slug;
     const shouldPrintOnly = opts.dryRun || insideSameAgent;
@@ -27055,10 +28774,11 @@ Or ask the assistant to continue the conversation in THIS session by ` + `fetchi
       }
       return;
     }
-    const parts = cmd.split(" ");
-    const child = spawn5(parts[0], parts.slice(1), {
+    const spec = toSpawnSpec(argv[0], argv.slice(1));
+    const child = spawn5(spec.command, spec.args, {
       cwd: placement.runFromCwd ?? recipientCwd,
-      stdio: "inherit"
+      stdio: "inherit",
+      ...spec.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
     });
     child.on("exit", (code) => {
       process.exit(code ?? 0);
@@ -27154,7 +28874,7 @@ process.on("uncaughtException", (err) => {
   console.error(`Uncaught exception: ${formatError(err)}`);
   process.exit(1);
 });
-var program = new Command39;
+var program = new Command40;
 program.name("runwork").description("Runwork CLI - local development for Runwork apps").version(VERSION).option("--json", "Output as JSON (auto-enabled when stdout is not a TTY)");
 program.addCommand(infoCommand);
 program.addCommand(loginCommand);
@@ -27187,6 +28907,7 @@ program.addCommand(appsCommand);
 program.addCommand(membersCommand);
 program.addCommand(apiCommand);
 program.addCommand(doctorCommand);
+program.addCommand(debugCommand);
 program.addCommand(shareConvoCommand);
 program.addCommand(saveConvoCommand);
 program.addCommand(inboxCommand);