@phenx-inc/ctlsurf 0.17.2 → 0.17.4

package/out/headless/index.mjs

@@ -6386,15 +6386,15 @@ function redactSensitive(body) {
   }
   return null;
 }
-async function checkCredentialsFileSafety(path13, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
+async function checkCredentialsFileSafety(path17, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
   if (typeof process === "undefined" || process.platform === "win32")
     return;
-  const fs9 = await import("node:fs");
-  let resolved = path13;
+  const fs12 = await import("node:fs");
+  let resolved = path17;
   let st;
   try {
-    resolved = await fs9.promises.realpath(path13);
-    st = await fs9.promises.stat(resolved);
+    resolved = await fs12.promises.realpath(path17);
+    st = await fs12.promises.stat(resolved);
   } catch {
     return;
   }
@@ -6410,27 +6410,27 @@ async function checkCredentialsFileSafety(path13, onWarn = (m) => console.warn(`
   }
 }
 async function writeCredentialsFileAtomic(targetPath, data) {
-  const fs9 = await import("node:fs");
-  const path13 = await import("node:path");
-  const dir = path13.dirname(targetPath);
-  await fs9.promises.mkdir(dir, { recursive: true, mode: 448 });
+  const fs12 = await import("node:fs");
+  const path17 = await import("node:path");
+  const dir = path17.dirname(targetPath);
+  await fs12.promises.mkdir(dir, { recursive: true, mode: 448 });
   const tmpPath = `${targetPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    const fh = await fs9.promises.open(tmpPath, "w", 384);
+    const fh = await fs12.promises.open(tmpPath, "w", 384);
     try {
       await fh.writeFile(JSON.stringify(data, null, 2));
       await fh.sync();
     } finally {
       await fh.close();
     }
-    await fs9.promises.rename(tmpPath, targetPath);
+    await fs12.promises.rename(tmpPath, targetPath);
   } catch (err) {
-    await fs9.promises.unlink(tmpPath).catch(() => {
+    await fs12.promises.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
   try {
-    const dirFh = await fs9.promises.open(dir, "r");
+    const dirFh = await fs12.promises.open(dir, "r");
     try {
       await dirFh.sync();
     } finally {
@@ -6794,12 +6794,12 @@ var init_credentials = __esm({
         return null;
       }
       validateProfileName(profileName);
-      const fs9 = await import("node:fs");
-      const path13 = await import("node:path");
-      const configPath = path13.join(rootConfigPath, "configs", `${profileName}.json`);
+      const fs12 = await import("node:fs");
+      const path17 = await import("node:path");
+      const configPath = path17.join(rootConfigPath, "configs", `${profileName}.json`);
       let configRaw;
       try {
-        configRaw = await fs9.promises.readFile(configPath, "utf-8");
+        configRaw = await fs12.promises.readFile(configPath, "utf-8");
       } catch (err) {
         if (err?.code !== "ENOENT") {
           throw new Error(`failed to read config file ${configPath}: ${err}`);
@@ -6880,37 +6880,37 @@ var init_credentials = __esm({
         return null;
       }
       validateProfileName(profileName);
-      const path13 = await import("node:path");
-      return path13.join(rootConfigPath, "credentials", `${profileName}.json`);
+      const path17 = await import("node:path");
+      return path17.join(rootConfigPath, "credentials", `${profileName}.json`);
     };
     getRootConfigPath = async () => {
       if (!supportsLocalConfigFiles()) {
         return null;
       }
-      const path13 = await import("node:path");
+      const path17 = await import("node:path");
       const configDir = readEnv("ANTHROPIC_CONFIG_DIR");
       if (configDir) {
         return configDir;
       }
-      const os7 = getPlatformHeaders()["X-Stainless-OS"];
-      if (os7 === "Windows") {
+      const os8 = getPlatformHeaders()["X-Stainless-OS"];
+      if (os8 === "Windows") {
         const appData = readEnv("APPDATA");
         if (appData) {
-          return path13.join(appData, "Anthropic");
+          return path17.join(appData, "Anthropic");
         }
         const userProfile = readEnv("USERPROFILE");
         if (userProfile) {
-          return path13.join(userProfile, "AppData", "Roaming", "Anthropic");
+          return path17.join(userProfile, "AppData", "Roaming", "Anthropic");
         }
         return null;
       }
       const xdgConfigHome = readEnv("XDG_CONFIG_HOME");
       if (xdgConfigHome) {
-        return path13.join(xdgConfigHome, "anthropic");
+        return path17.join(xdgConfigHome, "anthropic");
       }
       const home = readEnv("HOME");
       if (home) {
-        return path13.join(home, ".config", "anthropic");
+        return path17.join(home, ".config", "anthropic");
       }
       return null;
     };
@@ -6927,11 +6927,11 @@ var init_credentials = __esm({
       if (profileName) {
         return profileName;
       }
-      const fs9 = await import("node:fs");
-      const path13 = await import("node:path");
-      const filePath = path13.join(rootConfigPath, "active_config");
+      const fs12 = await import("node:fs");
+      const path17 = await import("node:path");
+      const filePath = path17.join(rootConfigPath, "active_config");
       try {
-        return (await fs9.promises.readFile(filePath, "utf-8")).trim() || "default";
+        return (await fs12.promises.readFile(filePath, "utf-8")).trim() || "default";
       } catch (err) {
         if (err?.code !== "ENOENT") {
           throw new Error(`failed to read ${filePath}: ${err}`);
@@ -6943,21 +6943,21 @@ var init_credentials = __esm({
 });
 
 // node_modules/@anthropic-ai/sdk/lib/credentials/identity-token.mjs
-function identityTokenFromFile(path13) {
-  if (!path13) {
+function identityTokenFromFile(path17) {
+  if (!path17) {
     throw new AnthropicError("Identity token file path is empty");
   }
   return async () => {
-    const fs9 = await import("node:fs");
+    const fs12 = await import("node:fs");
     let content;
     try {
-      content = await fs9.promises.readFile(path13, "utf-8");
+      content = await fs12.promises.readFile(path17, "utf-8");
     } catch (err) {
-      throw new AnthropicError(`Failed to read identity token file at ${path13}: ${err}`);
+      throw new AnthropicError(`Failed to read identity token file at ${path17}: ${err}`);
     }
     const token = content.trim();
     if (!token) {
-      throw new AnthropicError(`Identity token file at ${path13} is empty`);
+      throw new AnthropicError(`Identity token file at ${path17} is empty`);
     }
     return token;
   };
@@ -7042,11 +7042,11 @@ var init_oidc_federation = __esm({
 // node_modules/@anthropic-ai/sdk/lib/credentials/user-oauth.mjs
 function userOAuthProvider(config) {
   return async (opts) => {
-    const fs9 = await import("node:fs");
+    const fs12 = await import("node:fs");
     await checkCredentialsFileSafety(config.credentialsPath, config.onSafetyWarning);
     let raw;
     try {
-      raw = await fs9.promises.readFile(config.credentialsPath, "utf-8");
+      raw = await fs12.promises.readFile(config.credentialsPath, "utf-8");
     } catch (err) {
       throw new WorkloadIdentityError(`Credentials file not found at ${config.credentialsPath}: ${err}`);
     }
@@ -7218,11 +7218,11 @@ function resolveIdentityTokenProvider(auth) {
 }
 function cachedExchangeProvider(exchange, credentialsPath, onCacheWriteError, onSafetyWarning) {
   return async (opts) => {
-    const fs9 = await import("node:fs");
+    const fs12 = await import("node:fs");
     await checkCredentialsFileSafety(credentialsPath, onSafetyWarning);
     let existing;
     try {
-      const raw = await fs9.promises.readFile(credentialsPath, "utf-8");
+      const raw = await fs12.promises.readFile(credentialsPath, "utf-8");
       existing = JSON.parse(raw);
       const token = existing?.["access_token"];
       if (token && !opts?.forceRefresh) {
@@ -8282,12 +8282,12 @@ var init_path = __esm({
   "node_modules/@anthropic-ai/sdk/internal/utils/path.mjs"() {
     init_error();
     EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-    createPathTagFunction = (pathEncoder = encodeURIPath) => function path13(statics, ...params) {
+    createPathTagFunction = (pathEncoder = encodeURIPath) => function path17(statics, ...params) {
       if (statics.length === 1)
         return statics[0];
       let postPath = false;
       const invalidSegments = [];
-      const path14 = statics.reduce((previousValue, currentValue, index) => {
+      const path18 = statics.reduce((previousValue, currentValue, index) => {
         if (/[?#]/.test(currentValue)) {
           postPath = true;
         }
@@ -8304,7 +8304,7 @@ var init_path = __esm({
         }
         return previousValue + currentValue + (index === params.length ? "" : encoded);
       }, "");
-      const pathOnly = path14.split(/[?#]/, 1)[0];
+      const pathOnly = path18.split(/[?#]/, 1)[0];
       const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
       let match;
       while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -8325,10 +8325,10 @@ var init_path = __esm({
         }, "");
         throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path14}
+${path18}
 ${underline}`);
       }
-      return path14;
+      return path18;
     };
     path5 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
   }
@@ -16818,9 +16818,9 @@ var init_client = __esm({
       makeStatusError(status, error, message, headers) {
         return APIError.generate(status, error, message, headers);
       }
-      buildURL(path13, query, defaultBaseURL) {
+      buildURL(path17, query, defaultBaseURL) {
         const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-        const url = isAbsoluteURL(path13) ? new URL(path13) : new URL(baseURL + (baseURL.endsWith("/") && path13.startsWith("/") ? path13.slice(1) : path13));
+        const url = isAbsoluteURL(path17) ? new URL(path17) : new URL(baseURL + (baseURL.endsWith("/") && path17.startsWith("/") ? path17.slice(1) : path17));
         const defaultQuery = this.defaultQuery();
         const pathQuery = Object.fromEntries(url.searchParams);
         if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
@@ -16892,24 +16892,24 @@ var init_client = __esm({
       backendMiddleware() {
         return [];
       }
-      get(path13, opts) {
-        return this.methodRequest("get", path13, opts);
+      get(path17, opts) {
+        return this.methodRequest("get", path17, opts);
       }
-      post(path13, opts) {
-        return this.methodRequest("post", path13, opts);
+      post(path17, opts) {
+        return this.methodRequest("post", path17, opts);
       }
-      patch(path13, opts) {
-        return this.methodRequest("patch", path13, opts);
+      patch(path17, opts) {
+        return this.methodRequest("patch", path17, opts);
       }
-      put(path13, opts) {
-        return this.methodRequest("put", path13, opts);
+      put(path17, opts) {
+        return this.methodRequest("put", path17, opts);
       }
-      delete(path13, opts) {
-        return this.methodRequest("delete", path13, opts);
+      delete(path17, opts) {
+        return this.methodRequest("delete", path17, opts);
       }
-      methodRequest(method, path13, opts) {
+      methodRequest(method, path17, opts) {
         return this.request(Promise.resolve(opts).then((opts2) => {
-          return { method, path: path13, ...opts2 };
+          return { method, path: path17, ...opts2 };
         }));
       }
       request(options, remainingRetries = null) {
@@ -17023,8 +17023,8 @@ var init_client = __esm({
         }));
         return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
       }
-      getAPIList(path13, Page2, opts) {
-        return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path13, ...opts2 })) : { method: "get", path: path13, ...opts });
+      getAPIList(path17, Page2, opts) {
+        return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path17, ...opts2 })) : { method: "get", path: path17, ...opts });
       }
       requestAPIList(Page2, options) {
         const request = this.makeRequest(options, null, void 0);
@@ -17140,14 +17140,14 @@ var init_client = __esm({
       }
       async buildRequest(inputOptions, { retryCount = 0 } = {}) {
         const options = { ...inputOptions };
-        const { method, path: path13, query, defaultBaseURL } = options;
+        const { method, path: path17, query, defaultBaseURL } = options;
         if (this._authState.resolution) {
           await this._authState.resolution;
         }
         if (!this._baseURLIsExplicit && this._authState.baseURL && this.baseURL !== this._authState.baseURL) {
           this.baseURL = this._authState.baseURL;
         }
-        const url = this.buildURL(path13, query, defaultBaseURL);
+        const url = this.buildURL(path17, query, defaultBaseURL);
         if ("timeout" in options)
           validatePositiveInteger("timeout", options.timeout);
         options.timeout = options.timeout ?? this.timeout;
@@ -17285,22 +17285,89 @@ var init_sdk = __esm({
   }
 });
 
+// scripts/check-work-map-gpu.cjs
+var require_check_work_map_gpu = __commonJS({
+  "scripts/check-work-map-gpu.cjs"(exports, module) {
+    function initialCapability3({ desktop = false, platform = process.platform, arch = process.arch } = {}) {
+      if (!desktop) return { state: "unavailable", reason: "Work map is available only in the desktop app." };
+      if (platform !== "darwin" || arch !== "arm64") return { state: "unavailable", reason: "Work map currently requires an Apple Silicon Mac with Metal GPU support." };
+      return { state: "checking", reason: "Checking Apple GPU availability\u2026" };
+    }
+    function appleGpuFromReport(report) {
+      if (!Array.isArray(report?.SPDisplaysDataType)) return null;
+      return report.SPDisplaysDataType.find((gpu) => {
+        const apple = gpu.spdisplays_vendor === "sppci_vendor_Apple" || /^Apple M\d/i.test(gpu.sppci_model || gpu._name || "");
+        const metal = String(gpu.spdisplays_metal || gpu.spdisplays_metalsupport || gpu.spdisplays_mtlgpufamilysupport || "");
+        return apple && /supported|metal/i.test(metal) && !/unsupported|not.supported|unavailable/i.test(metal);
+      }) || null;
+    }
+    function usableElectronGpu(info) {
+      if (info?.auxAttributes?.softwareRendering === true) return false;
+      return Array.isArray(info?.gpuDevice) && info.gpuDevice.some((gpu) => gpu.active === true && (gpu.vendorId === 4203 || /Apple/i.test(gpu.deviceString || gpu.vendorString || "")));
+    }
+    function readGpuReport() {
+      return new Promise((resolve4, reject) => {
+        const { execFile: execFile3 } = __require("node:child_process");
+        execFile3("/usr/sbin/system_profiler", ["SPDisplaysDataType", "-json"], { timeout: 5e3, maxBuffer: 1024 * 1024 }, (error, output) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          try {
+            resolve4(JSON.parse(output));
+          } catch (error2) {
+            reject(error2);
+          }
+        });
+      });
+    }
+    async function detectCapability(options = {}) {
+      const initial = initialCapability3(options);
+      if (initial.state !== "checking") return initial;
+      try {
+        const gpu = appleGpuFromReport(await (options.readGpuReport || readGpuReport)());
+        if (!gpu) return { state: "unavailable", reason: "No Apple GPU with Metal support was detected." };
+        if (options.verifyGpu) {
+          let timer;
+          const usable = await Promise.race([
+            options.verifyGpu(),
+            new Promise((resolve4) => {
+              timer = setTimeout(() => resolve4(false), 5e3);
+            })
+          ]).finally(() => clearTimeout(timer));
+          if (!usable) return { state: "unavailable", reason: "The Apple GPU is unavailable to the desktop app." };
+        }
+        return { state: "available", reason: null, gpuName: String(gpu.sppci_model || gpu._name || "Apple GPU") };
+      } catch {
+        return { state: "unavailable", reason: "Apple GPU availability could not be verified. Work map is disabled for this launch." };
+      }
+    }
+    module.exports = { initialCapability: initialCapability3, appleGpuFromReport, usableElectronGpu, detectCapability };
+    if (__require.main === module) {
+      detectCapability({ desktop: true }).then((capability) => {
+        console.log(capability.state === "available" ? `[ctlsurf] Work map hardware detected: ${capability.gpuName}. The desktop app checks GPU access again at startup.` : `[ctlsurf] ${capability.reason} Other app features remain available.`);
+      }).catch(() => {
+      });
+    }
+  }
+});
+
 // node_modules/electron/index.js
 var require_electron = __commonJS({
   "node_modules/electron/index.js"(exports, module) {
-    var fs9 = __require("fs");
-    var path13 = __require("path");
-    var pathFile = path13.join(__dirname, "path.txt");
+    var fs12 = __require("fs");
+    var path17 = __require("path");
+    var pathFile = path17.join(__dirname, "path.txt");
     function getElectronPath() {
       let executablePath;
-      if (fs9.existsSync(pathFile)) {
-        executablePath = fs9.readFileSync(pathFile, "utf-8");
+      if (fs12.existsSync(pathFile)) {
+        executablePath = fs12.readFileSync(pathFile, "utf-8");
       }
       if (process.env.ELECTRON_OVERRIDE_DIST_PATH) {
-        return path13.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
+        return path17.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
       }
       if (executablePath) {
-        return path13.join(__dirname, "dist", executablePath);
+        return path17.join(__dirname, "dist", executablePath);
       } else {
         throw new Error("Electron failed to install correctly, please delete node_modules/electron and try installing again");
       }
@@ -17314,7 +17381,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.17.2",
+      version: "0.17.4",
       description: "Agent-agnostic terminal and desktop app for ctlsurf \u2014 run Claude Code, Codex, or any coding agent with live session logging and remote control",
       main: "out/main/index.js",
       bin: {
@@ -17333,6 +17400,8 @@ var require_package = __commonJS({
         "THIRD-PARTY-NOTICES.md"
       ],
       scripts: {
+        "test:workmap": "node scripts/test-work-map-capability.cjs && node scripts/test-work-map.cjs",
+        "test:workmap:ui": "electron scripts/test-work-map-ui.cjs",
         dev: "electron-vite dev",
         "dev:terminal": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --external:ws --sourcemap && node out/headless/index.mjs",
         build: "electron-vite build && npm run build:headless",
@@ -17340,7 +17409,7 @@ var require_package = __commonJS({
         prepublishOnly: "npm run build",
         preview: "electron-vite preview",
         package: "electron-builder",
-        postinstall: "node-gyp rebuild --directory=node_modules/node-pty 2>/dev/null || true"
+        postinstall: "node scripts/postinstall.cjs"
       },
       keywords: [
         "ctlsurf",
@@ -17417,9 +17486,9 @@ function log(...args) {
 }
 
 // src/main/orchestrator.ts
-import path10 from "path";
-import fs7 from "fs";
-import os4 from "os";
+import path14 from "path";
+import fs10 from "fs";
+import os5 from "os";
 
 // src/main/pty.ts
 import { createRequire } from "module";
@@ -17568,8 +17637,8 @@ var CtlsurfApi = class {
     }
     return h;
   }
-  async request(method, path13, body) {
-    const url = `${this.baseUrl}${path13}`;
+  async request(method, path17, body) {
+    const url = `${this.baseUrl}${path17}`;
     const opts = {
       method,
       headers: this.headers()
@@ -17580,7 +17649,7 @@ var CtlsurfApi = class {
     const res = await fetch(url, opts);
     if (!res.ok) {
       const text = await res.text();
-      throw new Error(`ctlsurf API ${method} ${path13}: ${res.status} ${text}`);
+      throw new Error(`ctlsurf API ${method} ${path17}: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -17968,6 +18037,7 @@ ${str.slice(str.length - MAX_LOG_CHARS)}`;
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { StringDecoder } from "string_decoder";
 function supportsTranscriptLogging(agentId) {
   return agentId === "claude" || agentId === "codex";
 }
@@ -17975,6 +18045,8 @@ var POLL_INTERVAL_MS = 1e3;
 var DISCOVERY_SLACK_MS = 1e4;
 var READ_CHUNK_BYTES = 64 * 1024;
 var MAX_ENTRY_CHARS = 2e4;
+var MAX_READ_PER_POLL = 512 * 1024;
+var MAX_LINE_CHARS = 1024 * 1024;
 var TranscriptTailer = class {
   agentId;
   cwd;
@@ -18042,7 +18114,7 @@ var TranscriptTailer = class {
         try {
           const stat2 = fs.statSync(filePath);
           if (stat2.mtimeMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
-            this.files.set(filePath, { offset: 0, remainder: "", excluded: false });
+            this.files.set(filePath, { offset: 0, remainder: "", excluded: false, decoder: new StringDecoder("utf8"), discardingLine: false, scoped: this.agentId === "claude" });
           }
         } catch {
         }
@@ -18072,7 +18144,14 @@ var TranscriptTailer = class {
     } catch {
       return;
     }
-    if (size <= tail.offset) return;
+    if (size < tail.offset) {
+      tail.offset = 0;
+      tail.remainder = "";
+      tail.decoder = new StringDecoder("utf8");
+      tail.discardingLine = false;
+      tail.scoped = this.agentId === "claude";
+    }
+    if (size === tail.offset) return;
     let fd;
     try {
       fd = fs.openSync(filePath, "r");
@@ -18081,17 +18160,26 @@ var TranscriptTailer = class {
     }
     try {
       const buf = Buffer.alloc(READ_CHUNK_BYTES);
-      while (tail.offset < size && !tail.excluded) {
-        const bytesRead = fs.readSync(fd, buf, 0, READ_CHUNK_BYTES, tail.offset);
+      const end = Math.min(size, tail.offset + MAX_READ_PER_POLL);
+      while (tail.offset < end && !tail.excluded) {
+        const bytesRead = fs.readSync(fd, buf, 0, Math.min(READ_CHUNK_BYTES, end - tail.offset), tail.offset);
         if (bytesRead <= 0) break;
         tail.offset += bytesRead;
-        tail.remainder += buf.toString("utf-8", 0, bytesRead);
+        tail.remainder += tail.decoder.write(buf.subarray(0, bytesRead));
         const lines = tail.remainder.split("\n");
         tail.remainder = lines.pop() || "";
         for (const line of lines) {
-          this.handleLine(line, tail);
+          if (tail.discardingLine) {
+            tail.discardingLine = false;
+            continue;
+          }
+          if (line.length <= MAX_LINE_CHARS) this.handleLine(line, tail, filePath);
           if (tail.excluded) break;
         }
+        if (tail.remainder.length > MAX_LINE_CHARS) {
+          tail.remainder = "";
+          tail.discardingLine = true;
+        }
       }
     } catch (err) {
       console.error(`[transcripts] Read error for ${filePath}:`, err);
@@ -18102,7 +18190,7 @@ var TranscriptTailer = class {
       }
     }
   }
-  handleLine(line, tail) {
+  handleLine(line, tail, filePath) {
     const trimmed = line.trim();
     if (!trimmed) return;
     let obj;
@@ -18111,16 +18199,18 @@ var TranscriptTailer = class {
     } catch {
       return;
     }
+    const entry = this.agentId === "claude" ? this.parseClaudeLine(obj) : this.parseCodexLine(obj, tail);
+    if (tail.excluded || !tail.scoped || obj?.isSidechain || obj?.isMeta) return;
+    if (this.agentId === "claude" && typeof obj?.cwd === "string" && stripTrailingSep(obj.cwd) !== this.cwd) return;
     if (this.rawSink) {
       const rawMs = typeof obj?.timestamp === "string" ? Date.parse(obj.timestamp) : NaN;
-      if (!Number.isFinite(rawMs) || rawMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
+      if (obj?.type === "session_meta" || !Number.isFinite(rawMs) || rawMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
         try {
-          this.rawSink(obj);
+          this.rawSink(obj, { filePath, sinceMs: this.sinceMs });
         } catch {
         }
       }
     }
-    const entry = this.agentId === "claude" ? this.parseClaudeLine(obj) : this.parseCodexLine(obj, tail);
     if (!entry) return;
     const ms = Date.parse(entry.ts);
     if (Number.isFinite(ms) && ms < this.sinceMs - DISCOVERY_SLACK_MS) return;
@@ -18149,9 +18239,10 @@ var TranscriptTailer = class {
     const payload = obj.payload;
     if (obj.type === "session_meta") {
       const metaCwd = payload?.cwd;
-      if (typeof metaCwd === "string" && stripTrailingSep(metaCwd) !== this.cwd) {
+      if (typeof metaCwd !== "string" || stripTrailingSep(metaCwd) !== this.cwd) {
         tail.excluded = true;
       }
+      tail.scoped = !tail.excluded;
       return null;
     }
     if (obj.type !== "event_msg" || !payload || typeof payload !== "object") return null;
@@ -19848,7 +19939,7 @@ Your previous output was invalid (${lastError}). Return valid JSON matching the
     }
   }
   buildUser(window2) {
-    const compact = window2.map((e) => {
+    const compact2 = window2.map((e) => {
       const out = { id: e.id, ts: e.ts, type: e.type };
       if (e.text) out.text = truncateForTier1(e.text);
       if (e.tool) out.tool = e.tool;
@@ -19868,7 +19959,7 @@ Your previous output was invalid (${lastError}). Return valid JSON matching the
 ${JSON.stringify(state)}
 
 WINDOW (${window2.length} events):
-${compact.join("\n")}`;
+${compact2.join("\n")}`;
   }
   parse(text, windowIds) {
     const parsed = JSON.parse(text);
@@ -20682,8 +20773,799 @@ function extractToolResultText(content) {
   return content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
 }
 
+// src/main/workMap/workMap.ts
+var import_check_work_map_gpu = __toESM(require_check_work_map_gpu());
+import path13 from "path";
+import fs9 from "fs";
+import os4 from "os";
+
+// src/main/workMap/clef.ts
+import { spawn as spawn2 } from "child_process";
+import fs7 from "fs";
+import path10 from "path";
+function validateDecisions(value, req) {
+  const answers = value?.answers;
+  if (!answers || Object.keys(answers).sort().join() !== Object.keys(req.questions).sort().join()) throw new Error("Clef returned an invalid decision schema");
+  for (const [key, q] of Object.entries(req.questions)) {
+    const a = answers[key];
+    const allowed = Object.keys(q.criteria).sort();
+    if (!a || !allowed.includes(a.choice) || !a.probabilities || Object.keys(a.probabilities).sort().join() !== allowed.join()) throw new Error("Clef returned an unknown branch or activity");
+    const values = Object.values(a.probabilities);
+    if (values.some((p) => typeof p !== "number" || !Number.isFinite(p) || p < 0 || p > 1) || Math.abs(values.reduce((s, p) => s + p, 0) - 1) > 2e-3 || a.probabilities[a.choice] < Math.max(...values) - 1e-6) throw new Error("Clef returned invalid probabilities");
+  }
+  return answers;
+}
+var ClefWorker = class {
+  constructor(scriptPath, onChange) {
+    this.scriptPath = scriptPath;
+    this.onChange = onChange;
+  }
+  state = "idle";
+  error = null;
+  child = null;
+  ready = null;
+  rejectReady = null;
+  pending = null;
+  seq = 0;
+  generation = 0;
+  idle = null;
+  loadTimeout = null;
+  requestTimeout = null;
+  stopping = Promise.resolve();
+  change(state, error = null) {
+    this.state = state;
+    this.error = error;
+    this.onChange();
+  }
+  async predict(settings, request) {
+    const generation = this.generation;
+    try {
+      await this.start(settings, generation);
+      if (!this.child || generation !== this.generation) throw new Error("Clef process stopped");
+      if (this.pending) throw new Error("Clef is already processing a batch");
+      if (this.idle) clearTimeout(this.idle);
+      this.change("thinking");
+      const response = await new Promise((resolve4, reject) => {
+        this.pending = { id: ++this.seq, resolve: resolve4, reject };
+        this.requestTimeout = setTimeout(() => this.fail("Clef timed out; turn the map off and on to retry."), 2e4);
+        this.child.stdin.write(JSON.stringify({ id: this.seq, request }) + "\n", (err) => {
+          if (err) this.fail(`Clef input failed: ${err.message}`);
+        });
+      });
+      const answers = validateDecisions(response, request);
+      this.change("ready");
+      this.armIdle();
+      return answers;
+    } catch (err) {
+      if (generation === this.generation) this.fail(err instanceof Error ? err.message : String(err));
+      throw err;
+    }
+  }
+  async start(settings, generation) {
+    await this.stopping;
+    if (generation !== this.generation) throw new Error("Clef process stopped");
+    if (this.ready) return this.ready;
+    if (process.platform !== "darwin" || process.arch !== "arm64") throw new Error("Local Clef-Flash requires an Apple Silicon Mac. Choose Rules on this machine.");
+    if (!fs7.existsSync(settings.pythonPath) || !fs7.existsSync(path10.join(settings.modelPath, "clef_mlx.py"))) {
+      throw new Error("Clef runtime not found. Open Local model setup and select the Python executable and downloaded Clef-Flash folder.");
+    }
+    this.change("loading");
+    const child = spawn2(settings.pythonPath, ["-u", this.scriptPath, settings.modelPath], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, HF_HUB_OFFLINE: "1", TRANSFORMERS_OFFLINE: "1", PYTHONDONTWRITEBYTECODE: "1" }
+    });
+    this.child = child;
+    let buffer = "";
+    let stderr = "";
+    this.ready = new Promise((resolve4, reject) => {
+      this.rejectReady = reject;
+      this.loadTimeout = setTimeout(() => this.fail("Clef did not load within 60 seconds."), 6e4);
+      child.stdout.on("data", (chunk) => {
+        if (this.child !== child) return;
+        buffer += String(chunk);
+        if (buffer.length > 128e3) {
+          this.fail("Clef response exceeded its output budget");
+          return;
+        }
+        let newline;
+        while ((newline = buffer.indexOf("\n")) >= 0) {
+          const line = buffer.slice(0, newline);
+          buffer = buffer.slice(newline + 1);
+          let msg;
+          try {
+            msg = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (msg.ready) {
+            if (this.loadTimeout) clearTimeout(this.loadTimeout);
+            this.rejectReady = null;
+            this.change("ready");
+            resolve4();
+          } else if (msg.error) {
+            this.fail(String(msg.error));
+          } else if (msg.id === this.pending?.id) {
+            if (this.requestTimeout) clearTimeout(this.requestTimeout);
+            const pending = this.pending;
+            this.pending = null;
+            pending?.resolve(msg);
+          }
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr = (stderr + String(chunk)).slice(-1e3);
+      });
+      child.on("error", (err) => {
+        if (this.child === child) this.fail(`Cannot start Clef: ${err.message}`);
+      });
+      child.on("exit", () => {
+        if (this.child === child) this.fail(`Clef stopped unexpectedly. ${stderr.slice(-300)}`);
+      });
+    });
+    return this.ready;
+  }
+  armIdle() {
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = setTimeout(() => this.stop(), 6e4);
+    this.idle.unref();
+  }
+  fail(message) {
+    this.stop(message);
+    this.change("error", message.slice(0, 600));
+  }
+  stop(reason = "Clef stopped") {
+    ++this.generation;
+    for (const timer of [this.idle, this.loadTimeout, this.requestTimeout]) if (timer) clearTimeout(timer);
+    this.idle = this.loadTimeout = this.requestTimeout = null;
+    this.rejectReady?.(new Error(reason));
+    this.rejectReady = null;
+    this.pending?.reject(new Error(reason));
+    this.pending = null;
+    this.ready = null;
+    const child = this.child;
+    this.child = null;
+    if (child) {
+      this.stopping = new Promise((resolve4) => child.once("close", () => resolve4()));
+      child.kill("SIGKILL");
+    }
+    this.change("idle");
+  }
+};
+
+// src/main/workMap/normalize.ts
+import { createHash } from "crypto";
+import path11 from "path";
+var textOf = (value) => {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((b) => b?.text || "").filter(Boolean).join("\n");
+  return "";
+};
+var compact = (value) => {
+  if (typeof value === "string") return value.slice(0, 1800);
+  try {
+    return JSON.stringify(value ?? {}).slice(0, 1800);
+  } catch {
+    return "";
+  }
+};
+var noise = (text) => /^\s*(?:<environment_context>|<user_instructions>|<permissions instructions>|<system-reminder>|<local-command|<command-|<task-notification>|<turn_aborted>|# AGENTS\.md)/i.test(text);
+var summaryText = (value) => {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.map((part) => typeof part === "string" ? part : part?.type === "summary_text" ? part.text || "" : "").filter(Boolean).join("\n\n");
+};
+function codexThinking(raw) {
+  const p = raw?.payload;
+  if (raw?.type === "response_item" && p?.type === "reasoning") {
+    const text = summaryText(p.summary);
+    return { text, key: p.id || text };
+  }
+  if (raw?.type === "event_msg" && p?.type === "agent_reasoning") {
+    const text = typeof p.text === "string" ? p.text : "";
+    return { text, key: p.id || text };
+  }
+  const item = raw?.type === "event_msg" && p?.type === "item_completed" ? p.item : raw?.method === "item/completed" ? raw.params?.item : null;
+  if (item?.type === "Reasoning" || item?.type === "reasoning") {
+    const text = summaryText(item.summary_text ?? item.summaryText ?? item.summary);
+    return { text, key: item.id || text };
+  }
+  return null;
+}
+function mapThinkingStatus(raw, agent) {
+  if (agent === "claude") {
+    if (raw?.type !== "assistant" || !Array.isArray(raw.message?.content)) return null;
+    const blocks = raw.message.content.filter((b) => b?.type === "thinking" || b?.type === "redacted_thinking");
+    if (!blocks.length) return null;
+    return blocks.some((b) => b.type === "thinking" && typeof b.thinking === "string" && b.thinking.trim()) ? "available" : "unavailable";
+  }
+  const thinking = codexThinking(raw);
+  return thinking ? thinking.text.trim() ? "available" : "unavailable" : null;
+}
+function normalizeMapEvents(raw, file, agent, includeFullSource = false) {
+  if (!raw || typeof raw !== "object" || raw.isSidechain || raw.isMeta) return [];
+  const ts = typeof raw.timestamp === "string" ? raw.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  const source = path11.basename(file);
+  const events = [];
+  const add = (kind, text, key, extra = {}) => {
+    if (!text.trim() || (kind === "prompt" || kind === "message") && noise(text)) return;
+    const hash = createHash("sha256").update(`${file}:${key}:${kind}`).digest("hex").slice(0, 20);
+    const bounded = kind === "thinking" && text.length > 1800 ? `${text.slice(0, 300)}
+\u2026
+${text.slice(-1490)}` : text.trim().slice(0, 1800);
+    const segments = kind === "thinking" || kind === "message" ? decisionCandidates(text) : void 0;
+    events.push({
+      id: hash,
+      ts,
+      kind,
+      text: bounded,
+      source,
+      ...extra,
+      ...segments?.length ? { segments } : {},
+      ...includeFullSource && (kind === "thinking" || kind === "message") ? { fullText: text.trim() } : {}
+    });
+  };
+  if (agent === "claude") {
+    if (raw.type !== "user" && raw.type !== "assistant") return [];
+    const blocks = raw.message?.content;
+    const key = raw.uuid || raw.message?.id || `${ts}:${compact(blocks)}`;
+    if (typeof blocks === "string") add(raw.type === "user" ? "prompt" : "message", blocks, key);
+    else if (Array.isArray(blocks)) blocks.forEach((b, i) => {
+      if (b.type === "text") add(raw.type === "user" ? "prompt" : "message", b.text || "", `${key}:${i}`);
+      if (raw.type === "assistant" && b.type === "thinking" && typeof b.thinking === "string") add("thinking", b.thinking, `${key}:${i}`);
+      if (b.type === "tool_use") add("tool", compact(b.input?.command ?? b.input?.file_path ?? b.input), b.id, { tool: b.name, toolId: b.id, status: "running" });
+      if (b.type === "tool_result") add("result", textOf(b.content) || "Tool completed", b.tool_use_id, {
+        toolId: b.tool_use_id,
+        status: b.is_error === true ? "failed" : "succeeded"
+      });
+    });
+    return events;
+  }
+  const thinking = codexThinking(raw);
+  if (thinking) {
+    add("thinking", thinking.text, `reasoning:${thinking.key}`);
+    return events;
+  }
+  const p = raw.payload;
+  if (!p) return [];
+  if (raw.type === "event_msg") {
+    if (p.type === "user_message" || p.type === "agent_message") {
+      add(p.type === "user_message" ? "prompt" : "message", textOf(p.message), `${ts}:${p.type}:${textOf(p.message)}`);
+    }
+    const item = p.type === "item_completed" ? p.item : null;
+    if (item?.type === "CommandExecution") {
+      const status = item.status === "failed" || typeof item.exit_code === "number" && item.exit_code !== 0 ? "failed" : item.status === "completed" && item.exit_code === 0 ? "succeeded" : "unknown";
+      const command = Array.isArray(item.command) ? item.command.length >= 3 && /^-(?:l?c|cl)$/.test(item.command[1]) ? item.command.slice(2).join(" ") : item.command.join(" ") : compact(item.command);
+      add("tool", command, item.id, { tool: "shell", toolId: item.id, status: "running" });
+      add("result", item.aggregated_output || `Command ended (${item.exit_code ?? item.status})`, item.id, { toolId: item.id, status });
+    }
+    if (item?.type === "FileChange") {
+      add("tool", Object.keys(item.changes || {}).join("\n"), item.id, { tool: "apply_patch", toolId: item.id, status: "unknown" });
+    }
+  }
+  if (raw.type !== "response_item") return events;
+  if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+    const text = Array.isArray(p.content) ? p.content.filter((b) => ["input_text", "output_text"].includes(b.type)).map((b) => b.text).join("\n") : "";
+    add(p.role === "user" ? "prompt" : "message", text, p.id || `${ts}:${p.role}:${text}`);
+  }
+  if (p.type === "function_call" || p.type === "custom_tool_call") {
+    if (/^(?:functions\.)?exec$/.test(p.name)) return events;
+    let input = p.arguments ?? p.input;
+    try {
+      const obj = JSON.parse(input);
+      input = obj.cmd ?? obj.command ?? obj.file_path ?? obj;
+    } catch {
+    }
+    add("tool", compact(input), p.call_id, { tool: p.name, toolId: p.call_id, status: "running" });
+  }
+  if (p.type === "function_call_output" || p.type === "custom_tool_call_output") {
+    const output = textOf(p.output) || compact(p.output);
+    const exit = output.match(/(?:Process exited with code|exit_code["']?\s*:)\s*(-?\d+)/i);
+    const status = p.is_error === true ? "failed" : exit ? Number(exit[1]) === 0 ? "succeeded" : "failed" : "unknown";
+    add("result", output, p.call_id, { toolId: p.call_id, status });
+  }
+  return events;
+}
+function activityFor(e) {
+  if (e.kind === "thinking") return "thinking";
+  if (e.kind === "prompt") return "planning";
+  if (e.kind === "message") return /\b(will|next|plan|investigat|checking)\b/i.test(e.text) ? "planning" : "reporting";
+  if (/edit|write|apply_patch|filechange/i.test(e.tool || "")) return "editing";
+  if (/\b(?:pytest|vitest|jest|tsc|unittest|npm (?:run )?(?:test|build)|cargo test|go test|node\s+\S*test[-_.])\b/i.test(e.text)) return "testing";
+  return "investigating";
+}
+function shortLabel(text, limit2 = 72) {
+  const line = text.replace(/```[\s\S]*?```/g, "").replace(/^[\s#>*-]+/gm, "").replace(/\s+/g, " ").trim();
+  return line.length > limit2 ? `${line.slice(0, limit2 - 1).trimEnd()}\u2026` : line || "Current work";
+}
+function topicFor(e) {
+  if (e.kind === "thinking") return "Reasoning & decisions";
+  const paths = e.text.match(/(?:[\w.@-]+\/)+[\w.@-]+\.(?:tsx?|jsx?|py|json|css|md|rs|go|sh|cjs|mjs)\b/g);
+  if (paths?.length) return shortLabel(paths[0].split("/").slice(-2).join("/"), 48);
+  if (activityFor(e) === "testing") return "Build & tests";
+  if (e.kind === "message") return "Approach & findings";
+  return shortLabel(e.tool || "Investigation", 48);
+}
+function decisionCandidates(text) {
+  const parts = text.split(/\n+|(?<=[.!?])\s+|,\s+(?=(?:so|because|since|rather|instead)\b)/i).map((s) => s.replace(/^[\s#>*-]+/, "").replace(/\*\*/g, "").trim()).filter((s) => s.length >= 15);
+  const score = (s) => (intentFor(s) !== "context" ? 10 : 0) + (/\b(?:choose|decid|instead|suspect|likely|next|prefer)\w*\b/i.test(s) ? 5 : 0) + (/\b(?:because|since|so|avoid|tradeoff|due to|constraint|means)\b/i.test(s) ? 8 : 0);
+  return [...new Set(parts)].map((text2, index) => ({ text: text2.slice(0, 320), index, score: score(text2) })).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, 6).map((p) => p.text);
+}
+function intentFor(text) {
+  if (/\b(?:suspect|hypothesis|likely|probably|perhaps|maybe|might|could be|seems)\b/i.test(text)) return "hypothesis";
+  if (/\b(?:alternative|option|versus|weigh|either|could (?:use|try))\b/i.test(text)) return "alternative";
+  if (/\b(?:choose|decided?|prefer|instead|use .+ rather than|let['’]s use)\b/i.test(text)) return "decision";
+  if (/\b(?:building|implementing|keeping) (?:it |this )?(?:as|with|in)\b/i.test(text)) return "decision";
+  if (/\b(?:I['’]ll|I will|we should|need to|next|going to|plan to|first (?:check|test|inspect|read))\b/i.test(text)) return "next_step";
+  return "context";
+}
+
+// src/main/workMap/tree.ts
+var ACTIVITIES = {
+  investigating: "Reading files, searching, inspecting or diagnosing",
+  editing: "Changing files, code, dependencies or configuration",
+  testing: "Running tests, builds or validation",
+  planning: "Discussing the approach or deciding what to do next",
+  reporting: "Explaining findings or summarizing completed work"
+};
+var INTENTS = {
+  decision: "A stated choice of approach or rejection of another approach",
+  hypothesis: "An unverified explanation or suspicion to investigate",
+  alternative: "Weighing different possible approaches without choosing yet",
+  next_step: "A stated next action or check to perform",
+  context: "General narration with no clear choice, hypothesis or next step"
+};
+var MAP_NODE_LIMIT = 240;
+var WorkMapTree = class {
+  nodes = [];
+  dropped = 0;
+  goal = null;
+  seq = 0;
+  seen = /* @__PURE__ */ new Set();
+  tools = /* @__PURE__ */ new Map();
+  lastText = null;
+  contextId;
+  ingest(e) {
+    if (this.seen.has(e.id)) return null;
+    this.seen.add(e.id);
+    if (this.seen.size > 1200) this.seen.delete(this.seen.values().next().value);
+    if (e.kind === "result") {
+      const id = this.tools.get(`${e.source}:${e.toolId}`);
+      const node2 = this.nodes.find((n) => n.id === id);
+      if (node2) {
+        node2.status = e.status || "unknown";
+        node2.evidence = [node2.evidence[0], e];
+      }
+      return null;
+    }
+    if (e.kind === "prompt" || e.kind === "message" || e.kind === "thinking") {
+      const key = `${e.source}:${e.kind}:${e.text}`;
+      const time = Date.parse(e.ts);
+      if (this.lastText?.key === key && Math.abs(time - this.lastText.time) < 3e3) return null;
+      this.lastText = { key, time };
+    }
+    if (e.kind === "prompt") {
+      this.contextId = void 0;
+      this.goal = this.add({ parentId: null, kind: "goal", title: shortLabel(e.text, 110), activity: "planning", status: "unknown", ts: e.ts, evidence: [e] }).id;
+      this.trim();
+      return null;
+    }
+    if (!this.goal) this.goal = this.add({ parentId: null, kind: "goal", title: "Session work", activity: "planning", status: "unknown", ts: e.ts, evidence: [] }).id;
+    const topic = topicFor(e);
+    const branch = this.branch(this.goal, topic, e.ts);
+    const activity = activityFor(e);
+    const statement = e.kind === "thinking" || e.kind === "message" ? e.segments?.[0] || decisionCandidates(e.text)[0] || e.text : e.text;
+    const title = e.kind === "tool" ? `${e.tool || "Tool"} \xB7 ${shortLabel(e.text, 65)}` : shortLabel(statement, 110);
+    const intent = e.kind === "thinking" || e.kind === "message" ? intentFor(statement) : void 0;
+    const node = this.add({
+      parentId: branch.id,
+      kind: "step",
+      title,
+      activity,
+      status: e.status || "unknown",
+      ts: e.ts,
+      evidence: [e],
+      placement: "rules",
+      intent,
+      ...intent && intent !== "context" ? { focus: { text: statement } } : {},
+      ...e.kind === "tool" && this.contextId ? { contextId: this.contextId } : {}
+    });
+    if (e.kind === "thinking" || e.kind === "message") this.contextId = node.id;
+    if (e.toolId) this.tools.set(`${e.source}:${e.toolId}`, node.id);
+    this.trim();
+    return node.id;
+  }
+  end() {
+    for (const n of this.nodes) if (n.status === "running") n.status = "interrupted";
+  }
+  request(ids) {
+    const nodes = ids.map((id) => this.nodes.find((n) => n.id === id && n.kind === "step")).filter((n) => !!n);
+    if (!nodes.length) return null;
+    const parent = this.nodes.find((n) => n.id === nodes[0].parentId);
+    if (!parent?.parentId) return null;
+    const goalId = parent.parentId;
+    const sameGoal = nodes.filter((n) => this.nodes.find((b) => b.id === n.parentId)?.parentId === goalId);
+    const isIntent = (n) => n?.evidence[0]?.kind === "thinking" || n?.evidence[0]?.kind === "message";
+    const selected = sameGoal.slice(0, isIntent(sameGoal[0]) || isIntent(sameGoal[1]) ? 1 : 2);
+    const goal = this.nodes.find((n) => n.id === goalId);
+    const branches = this.nodes.filter((n) => n.kind === "branch" && n.parentId === goalId).slice(-4);
+    const criteria = Object.fromEntries(branches.map((n) => [n.id, n.title.slice(0, 48)]));
+    criteria.new_topic = "A different work topic; create a new branch";
+    const questions = {};
+    const statements = {};
+    const reasons = {};
+    selected.forEach((node, i) => {
+      questions[`branch_${i}`] = { type: "choice", instructions: `Which work topic does event_${i} belong to? Use the goal and stated reasoning, not incidental file paths.`, criteria };
+      if (isIntent(node)) {
+        const candidates = node.evidence[0].segments || decisionCandidates(node.evidence[0].text);
+        statements[node.id] = candidates.length ? candidates : [node.evidence[0].text.slice(0, 220)];
+        questions[`statement_${i}`] = {
+          type: "choice",
+          instructions: `Which excerpt best captures the agent's choice, hypothesis or next check in event_${i}?`,
+          criteria: Object.fromEntries(statements[node.id].map((s, j) => [`s${j}`, s]))
+        };
+        questions[`intent_${i}`] = { type: "choice", instructions: `What does the selected excerpt express? A tentative explanation is not an established decision.`, criteria: INTENTS };
+        reasons[node.id] = candidates.filter((s) => /\b(?:because|since|so|avoid|tradeoff|due to|constraint|rather|instead)\b/i.test(s)).slice(0, 3);
+        if (reasons[node.id].length) questions[`reason_${i}`] = {
+          type: "choice",
+          instructions: "Which excerpt states why the agent chose its approach? Choose none if no supporting reason is stated.",
+          criteria: { ...Object.fromEntries(reasons[node.id].map((s, j) => [`r${j}`, s])), none: "No supporting reason stated" }
+        };
+      } else {
+        questions[`activity_${i}`] = { type: "choice", instructions: `What activity does event_${i} show?`, criteria: ACTIVITIES };
+      }
+    });
+    return {
+      ids: selected.map((n) => n.id),
+      goalId,
+      statements,
+      reasons,
+      request: {
+        model: "clef-flash",
+        state: JSON.stringify({ goal: goal.title, events: selected.map((n, i) => ({
+          id: `event_${i}`,
+          kind: n.evidence[0]?.kind,
+          tool: n.evidence[0]?.tool,
+          text: n.evidence[0]?.text.slice(0, 450),
+          preceding_intent: this.nodes.find((c) => c.id === n.contextId)?.evidence[0]?.text.slice(-400),
+          current_topic: this.nodes.find((b) => b.id === n.parentId)?.title
+        })) }),
+        questions
+      }
+    };
+  }
+  apply(job, answers) {
+    job.ids.forEach((id, i) => {
+      const node = this.nodes.find((n) => n.id === id);
+      if (!node || !this.nodes.some((n) => n.id === job.goalId)) return;
+      const decision = answers[`branch_${i}`];
+      const textSource = node.evidence[0]?.kind === "thinking" || node.evidence[0]?.kind === "message";
+      if (textSource) {
+        const choice = answers[`statement_${i}`]?.choice;
+        const statement = job.statements[node.id]?.[Number(choice?.slice(1))];
+        if (statement) node.title = shortLabel(statement, 110);
+        const statedIntent = intentFor(statement || "");
+        node.intent = statedIntent !== "context" ? statedIntent : answers[`intent_${i}`]?.choice;
+        const reasonChoice = answers[`reason_${i}`]?.choice;
+        const reason = reasonChoice && reasonChoice !== "none" ? job.reasons[node.id]?.[Number(reasonChoice.slice(1))] : void 0;
+        node.focus = statement ? { text: statement, ...reason && reason !== statement ? { reason } : {} } : void 0;
+      }
+      const topic = topicFor(node.evidence[0]);
+      const newTitle = shortLabel(node.evidence[0].kind === "thinking" ? node.title : node.evidence[0].text, 48);
+      const target = decision.choice === "new_topic" ? this.branch(job.goalId, newTitle === topic ? `${node.activity} \xB7 ${topic}` : newTitle, node.ts) : this.nodes.find((n) => n.id === decision.choice && n.kind === "branch" && n.parentId === job.goalId);
+      if (!target) return;
+      node.parentId = target.id;
+      node.activity = node.evidence[0]?.kind === "thinking" ? "thinking" : textSource ? node.intent === "context" ? "reporting" : "planning" : answers[`activity_${i}`].choice;
+      node.placement = "clef-flash";
+      node.confidence = decision.probabilities[decision.choice];
+    });
+    this.removeEmptyBranches();
+    this.trim();
+  }
+  add(node) {
+    const result = { ...node, id: `map_${++this.seq}` };
+    this.nodes.push(result);
+    return result;
+  }
+  branch(goal, title, ts) {
+    return this.nodes.find((n) => n.kind === "branch" && n.parentId === goal && n.title === title) || this.add({ parentId: goal, kind: "branch", title, activity: "planning", status: "unknown", ts, evidence: [] });
+  }
+  removeEmptyBranches() {
+    const parents = new Set(this.nodes.map((n) => n.parentId));
+    this.nodes = this.nodes.filter((n) => n.kind !== "branch" || parents.has(n.id));
+  }
+  trim() {
+    while (this.nodes.length > MAP_NODE_LIMIT) {
+      const oldGoal = this.nodes.find((n) => n.kind === "goal" && n.id !== this.goal);
+      if (oldGoal) {
+        const removed = /* @__PURE__ */ new Set([oldGoal.id, ...this.nodes.filter((n) => n.parentId === oldGoal.id).map((n) => n.id)]);
+        const before = this.nodes.length;
+        this.nodes = this.nodes.filter((n) => !removed.has(n.id) && !removed.has(n.parentId || ""));
+        this.dropped += before - this.nodes.length;
+      } else {
+        const oldest = this.nodes.findIndex((n) => n.kind === "step");
+        if (oldest < 0) break;
+        this.nodes.splice(oldest, 1);
+        this.dropped++;
+        this.removeEmptyBranches();
+      }
+    }
+    const retained = new Set(this.nodes.map((n) => n.id));
+    if (this.contextId && !retained.has(this.contextId)) this.contextId = void 0;
+    for (const [key, id] of this.tools) if (!retained.has(id)) this.tools.delete(key);
+  }
+};
+
+// src/main/workMap/source.ts
+import fs8 from "fs";
+import path12 from "path";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+async function readMapSource(file, agent, eventId) {
+  const decoder = new StringDecoder2("utf8");
+  let remainder = "";
+  let discard = false;
+  const stream = fs8.createReadStream(file, { highWaterMark: 64 * 1024 });
+  for await (const chunk of stream) {
+    remainder += decoder.write(chunk);
+    const lines = remainder.split("\n");
+    remainder = lines.pop() || "";
+    for (const line of lines) {
+      if (discard) {
+        discard = false;
+        continue;
+      }
+      if (line.length > 1024 * 1024) continue;
+      let raw;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const event = normalizeMapEvents(raw, file, agent, true).find((e) => e.id === eventId);
+      if (event?.fullText !== void 0) return { text: event.fullText, source: path12.basename(file) };
+    }
+    if (remainder.length > 1024 * 1024) {
+      remainder = "";
+      discard = true;
+    }
+  }
+  return null;
+}
+
+// src/main/workMap/workMap.ts
+var WorkMap = class {
+  constructor(appRoot, onUpdate, roots = {}, capability = (0, import_check_work_map_gpu.initialCapability)()) {
+    this.onUpdate = onUpdate;
+    this.roots = roots;
+    this.capability = capability;
+    const cache = path13.join(appRoot, "experiments/live-map/.cache");
+    const prepared = path13.join(os4.homedir(), ".ctlsurf/clef-flash");
+    const pilotPython = path13.join(cache, "envs/clef-flash/bin/python");
+    this.settings = {
+      enabled: false,
+      engine: "clef-flash",
+      pythonPath: process.env.CTLSURF_CLEF_PYTHON || (fs9.existsSync(pilotPython) ? pilotPython : path13.join(prepared, "env/bin/python")),
+      modelPath: process.env.CTLSURF_CLEF_MODEL || (fs9.existsSync(pilotPython) ? path13.join(cache, "models/clef-flash") : path13.join(prepared, "model"))
+    };
+    this.clef = new ClefWorker(path13.join(appRoot, "scripts/work-map-clef.py"), () => this.publish());
+  }
+  tabs = /* @__PURE__ */ new Map();
+  owners = /* @__PURE__ */ new Map();
+  settings;
+  clef;
+  revision = 0;
+  epoch = 0;
+  timer = null;
+  publishing = null;
+  working = false;
+  round = 0;
+  configure(value) {
+    ++this.epoch;
+    const previous = this.settings;
+    this.settings = {
+      enabled: this.capability.state === "available" && (typeof value.enabled === "boolean" ? value.enabled : previous.enabled),
+      engine: value.engine === "rules" || value.engine === "clef-flash" ? value.engine : previous.engine,
+      pythonPath: typeof value.pythonPath === "string" && value.pythonPath.trim() ? value.pythonPath.trim() : previous.pythonPath,
+      modelPath: typeof value.modelPath === "string" && value.modelPath.trim() ? value.modelPath.trim() : previous.modelPath
+    };
+    this.clef.stop();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    for (const tab of this.tabs.values()) {
+      tab.pending.clear();
+      if (this.settings.enabled && !tab.ended) this.start(tab);
+      else {
+        tab.tailer?.stop();
+        tab.tailer = null;
+        tab.tree.end();
+      }
+      if (this.settings.enabled && this.settings.engine === "clef-flash") {
+        tab.tree.nodes.filter((n) => n.kind === "step" && n.placement !== "clef-flash").slice(-24).forEach((n) => tab.pending.add(n.id));
+      }
+    }
+    this.publish();
+    this.schedule();
+    return { ...this.settings };
+  }
+  attach(tabId, agentId, agentName, cwd) {
+    this.remove(tabId);
+    const tab = { agentId, agentName, cwd, tree: new WorkMapTree(), tailer: null, ended: false, state: "idle", source: null, ignored: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Set(), thinkingStatus: "waiting", sources: /* @__PURE__ */ new Map() };
+    this.tabs.set(tabId, tab);
+    if (this.settings.enabled) this.start(tab);
+    this.publish();
+  }
+  getCapability() {
+    return { ...this.capability };
+  }
+  setCapability(capability) {
+    this.capability = { ...capability };
+    if (capability.state !== "available") this.configure({ enabled: false });
+    this.publish();
+  }
+  end(tabId) {
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.ended = true;
+    tab.tailer?.stop();
+    tab.tailer = null;
+    tab.pending.clear();
+    tab.tree.end();
+    for (const [source, owner] of this.owners) if (owner === tabId) this.owners.delete(source);
+    if (![...this.tabs.values()].some((t) => !t.ended)) this.clef.stop();
+    this.publish();
+  }
+  remove(tabId) {
+    this.end(tabId);
+    this.tabs.delete(tabId);
+    for (const [source, owner] of this.owners) if (owner === tabId) this.owners.delete(source);
+  }
+  clear(tabId) {
+    const tab = this.tabs.get(tabId);
+    if (tab) {
+      tab.tree = new WorkMapTree();
+      tab.pending.clear();
+    }
+    this.publish();
+  }
+  noteState(tabId, state) {
+    const tab = this.tabs.get(tabId);
+    if (tab && tab.state !== state) {
+      tab.state = state;
+      this.publish();
+    }
+  }
+  snapshot(tabId) {
+    const tab = this.tabs.get(tabId);
+    return {
+      revision: ++this.revision,
+      tabId,
+      agentName: tab?.agentName || null,
+      supported: !!tab && supportsTranscriptLogging(tab.agentId),
+      ended: !!tab?.ended,
+      state: tab?.state || "idle",
+      settings: { ...this.settings },
+      runtime: !this.settings.enabled ? "off" : this.settings.engine === "rules" ? "ready" : this.clef.state,
+      error: this.settings.engine === "clef-flash" ? this.clef.error : null,
+      nodes: tab?.tree.nodes || [],
+      dropped: tab?.tree.dropped || 0,
+      thinkingStatus: tab?.thinkingStatus || "waiting",
+      capability: this.getCapability()
+    };
+  }
+  async getSource(tabId, eventId) {
+    const tab = this.tabs.get(tabId);
+    const event = tab?.tree.nodes.flatMap((n) => n.evidence).find((e) => e.id === eventId && (e.kind === "thinking" || e.kind === "message"));
+    const file = event && tab?.sources.get(event.source);
+    if (!event || !file || !tab) return null;
+    return readMapSource(file, tab.agentId, event.id);
+  }
+  start(tab) {
+    if (tab.tailer || !supportsTranscriptLogging(tab.agentId)) return;
+    tab.tailer = new TranscriptTailer({
+      ...this.roots,
+      agentId: tab.agentId,
+      cwd: tab.cwd,
+      sink: () => {
+      },
+      rawSink: (raw, source) => {
+        if (!source || !this.settings.enabled || tab.ended) return;
+        const file = source.filePath;
+        if (tab.ignored.has(file)) return;
+        if (raw.type === "session_meta") {
+          const meta = raw.payload || {};
+          if (meta.thread_source && meta.thread_source !== "user" || meta.source && typeof meta.source === "object" || meta.agent_path && meta.agent_path !== "/root") {
+            tab.ignored.add(file);
+            return;
+          }
+        }
+        const tabId = [...this.tabs].find(([, candidate]) => candidate === tab)?.[0];
+        if (!tabId) return;
+        if (this.owners.has(file) && this.owners.get(file) !== tabId) return;
+        if (tab.source && tab.source !== file) {
+          if (raw.type !== "session_meta" || Date.parse(raw.payload?.timestamp || raw.timestamp) < source.sinceMs) return;
+          this.owners.delete(tab.source);
+        }
+        tab.source = file;
+        this.owners.set(file, tabId);
+        const thinking = mapThinkingStatus(raw, tab.agentId);
+        const statusChanged = thinking !== null && thinking !== tab.thinkingStatus && (thinking === "available" || tab.thinkingStatus === "waiting");
+        if (statusChanged) tab.thinkingStatus = thinking;
+        const events = normalizeMapEvents(raw, file, tab.agentId);
+        for (const e of events) {
+          tab.sources.set(e.source, file);
+          const id = tab.tree.ingest(e);
+          if (id && this.settings.engine === "clef-flash") {
+            tab.pending.add(id);
+            if (tab.pending.size > 24) tab.pending.delete(tab.pending.values().next().value);
+          }
+        }
+        const retainedSources = new Set(tab.tree.nodes.flatMap((n) => n.evidence.map((e) => e.source)));
+        for (const name of tab.sources.keys()) if (!retainedSources.has(name)) tab.sources.delete(name);
+        if (events.length || statusChanged) {
+          this.publish();
+          this.schedule();
+        }
+      }
+    });
+    tab.tailer.start();
+  }
+  schedule() {
+    if (this.timer || this.working || !this.settings.enabled || this.settings.engine !== "clef-flash" || this.clef.state === "error") return;
+    if (![...this.tabs.values()].some((t) => t.pending.size)) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.infer();
+    }, 1e3);
+  }
+  async infer() {
+    const candidates = [...this.tabs].filter(([, t]) => t.pending.size && !t.ended);
+    const candidate = candidates[this.round++ % candidates.length];
+    if (!candidate || !this.settings.enabled || this.settings.engine !== "clef-flash") return;
+    const [tabId, tab] = candidate;
+    const tree = tab.tree;
+    const ids = [...tab.pending].slice(0, 2);
+    const job = tree.request(ids);
+    const consumed = job?.ids || ids;
+    consumed.forEach((id) => tab.pending.delete(id));
+    if (!job) {
+      this.schedule();
+      return;
+    }
+    const epoch = this.epoch;
+    this.working = true;
+    try {
+      const answers = await this.clef.predict(this.settings, job.request);
+      if (epoch === this.epoch && this.tabs.get(tabId) === tab && !tab.ended && tab.tree === tree) tree.apply(job, answers);
+    } catch {
+    } finally {
+      this.working = false;
+      this.publish();
+      this.schedule();
+    }
+  }
+  publish() {
+    if (this.publishing) return;
+    this.publishing = setTimeout(() => {
+      this.publishing = null;
+      for (const tabId of this.tabs.keys()) this.onUpdate(this.snapshot(tabId));
+    }, 120);
+  }
+  shutdown() {
+    this.settings.enabled = false;
+    ++this.epoch;
+    for (const tab of this.tabs.values()) tab.tailer?.stop();
+    this.clef.stop();
+    if (this.timer) clearTimeout(this.timer);
+    if (this.publishing) clearTimeout(this.publishing);
+    this.timer = this.publishing = null;
+    this.tabs.clear();
+    this.owners.clear();
+  }
+};
+
 // src/main/orchestrator.ts
+var import_check_work_map_gpu2 = __toESM(require_check_work_map_gpu());
 var DEFAULT_IDLE_TIMEOUT_MIN = 15;
+var OBSERVER_ON_HOLD = true;
 var DEFAULT_PROFILES = {
   production: {
     name: "Production",
@@ -20706,6 +21588,7 @@ var Orchestrator = class {
   timeTracker = new TimeTracker(this.ctlsurfApi);
   ticketStore = new TicketStore(this.ctlsurfApi);
   observer;
+  workMap;
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -20725,19 +21608,24 @@ var Orchestrator = class {
   // until the next remote spawn for that target consumes them — never persisted.
   pendingSshPasswords = /* @__PURE__ */ new Map();
   pendingSshPasswordTimers = /* @__PURE__ */ new Map();
-  constructor(settingsDir, events) {
+  constructor(settingsDir, events, options) {
     this.settingsDir = settingsDir;
     this.events = events;
+    this.workMap = new WorkMap(options?.appRoot || process.cwd(), (snapshot) => this.events.onWorkMapUpdate?.(snapshot), {}, (0, import_check_work_map_gpu2.initialCapability)({ desktop: options?.desktop === true }));
     this.observer = new Observer({
       settingsDir,
       api: this.ctlsurfApi,
-      getSettings: () => this.settings.observer || {},
+      getSettings: () => ({
+        ...this.settings.observer,
+        enabled: !OBSERVER_ON_HOLD && !!this.settings.observer?.enabled
+      }),
       onUpdate: (item) => this.events.onObserverUpdate?.(item),
       onActivity: (reviewing) => this.events.onObserverActivity?.(reviewing)
     });
     this.stateMonitor = new AgentStateMonitor(({ tabId, state, anyAwaiting }) => {
       this.events.onAgentStateChange?.(tabId, state, anyAwaiting);
       this.observer.noteAgentState(tabId, state);
+      this.workMap.noteState(tabId, state);
     });
     this.stateMonitor.start();
     this.workerWs = new WorkerWsClient({
@@ -20809,13 +21697,24 @@ var Orchestrator = class {
     this.saveSettings();
     this.restartActiveChatLogging();
   }
+  configureWorkMap(data) {
+    const capability = this.workMap.getCapability();
+    if (data.enabled && capability.state !== "available") throw new Error(capability.reason || "Work map is unavailable on this machine.");
+    this.settings.workMap = this.workMap.configure(data);
+    this.saveSettings();
+  }
+  setWorkMapCapability(capability) {
+    this.workMap.setCapability(capability);
+    this.workMap.configure({ ...this.settings.workMap, enabled: capability.state === "available" && !!this.settings.workMap?.enabled });
+    this.events.onWorkMapCapability?.(capability);
+  }
   // ─── Observer settings ──────────────────────────
   /** Summary for the settings UI — never echoes the API key back. */
   getObserverSettingsSummary() {
     const o = this.settings.observer || {};
     const keySource = o.anthropicApiKey ? "settings" : process.env.ANTHROPIC_API_KEY ? "env" : null;
     return {
-      enabled: !!o.enabled,
+      enabled: !OBSERVER_ON_HOLD && !!o.enabled,
       hasApiKey: keySource !== null,
       keySource,
       dailyCapUsd: o.dailyCapUsd ?? OBSERVER_DEFAULTS.dailyCapUsd
@@ -20934,13 +21833,13 @@ var Orchestrator = class {
   }
   loadSettings() {
     try {
-      fs7.mkdirSync(this.settingsDir, { recursive: true });
+      fs10.mkdirSync(this.settingsDir, { recursive: true });
     } catch {
     }
-    const settingsPath = path10.join(this.settingsDir, "settings.json");
+    const settingsPath = path14.join(this.settingsDir, "settings.json");
     try {
-      if (fs7.existsSync(settingsPath)) {
-        const raw = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
+      if (fs10.existsSync(settingsPath)) {
+        const raw = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
         if (!raw.profiles) {
           this.settings = {
             activeProfile: "production",
@@ -20975,12 +21874,13 @@ var Orchestrator = class {
     }
     this.applyProfile(this.getActiveProfile());
     this.bridge.setLoggingEnabled(!!this.settings.logChat);
+    this.workMap.configure({ ...this.settings.workMap, enabled: !!this.events.onWorkMapUpdate && !!this.settings.workMap?.enabled });
   }
   saveSettings() {
-    const settingsPath = path10.join(this.settingsDir, "settings.json");
+    const settingsPath = path14.join(this.settingsDir, "settings.json");
     try {
-      fs7.mkdirSync(this.settingsDir, { recursive: true });
-      fs7.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
+      fs10.mkdirSync(this.settingsDir, { recursive: true });
+      fs10.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
     } catch (err) {
       log("[settings] Failed to save:", err.message);
     }
@@ -21121,6 +22021,7 @@ var Orchestrator = class {
       this.tabs.delete(tabId);
       this.stateMonitor.removeTab(tabId);
       void this.observer.endTab(tabId, existing.projectRootPath);
+      this.workMap.remove(tabId);
       existing.ptyManager.kill();
       await this.timeTracker.endSession(tabId);
     }
@@ -21135,6 +22036,7 @@ var Orchestrator = class {
     const tab = { ptyManager, agent, cwd, termStreamBuffer: "", termStreamTimer: null };
     this.tabs.set(tabId, tab);
     this.stateMonitor.trackTab(tabId, agent.id, cwd);
+    this.workMap.attach(tabId, agent.id, agent.name, cwd);
     if (isRemoteAgent(agent)) {
       const target = agent.args[1];
       const pw = target ? this.consumePendingSshPassword(target) : void 0;
@@ -21156,6 +22058,7 @@ var Orchestrator = class {
       if (this.tabs.get(tabId) !== tab) return;
       this.events.onPtyExit(tabId, exitCode);
       const observerEnd = this.observer.endTab(tabId, tab.projectRootPath);
+      this.workMap.end(tabId);
       await this.timeTracker.endSession(tabId);
       void observerEnd;
       if (this.tabs.get(tabId) !== tab) return;
@@ -21207,6 +22110,7 @@ var Orchestrator = class {
   }
   async killTab(tabId) {
     const tab = this.tabs.get(tabId);
+    this.workMap.remove(tabId);
     if (!tab) return;
     if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);
     await this.timeTracker.endSession(tabId);
@@ -21338,7 +22242,7 @@ var Orchestrator = class {
     }
     this.stopNoProjectPolling();
     this.workerWs.connect({
-      machine: os4.hostname(),
+      machine: os5.hostname(),
       cwd,
       agent: agent.name
     });
@@ -21407,6 +22311,7 @@ var Orchestrator = class {
   }
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
+    this.workMap.shutdown();
     this.stopNoProjectPolling();
     this.stopChatLogging();
     this.stateMonitor.stop();
@@ -21422,18 +22327,18 @@ var Orchestrator = class {
 };
 
 // src/main/settingsDir.ts
-import path11 from "path";
-import os5 from "os";
+import path15 from "path";
+import os6 from "os";
 function getSettingsDir(useElectron) {
   if (useElectron) {
     const { app } = require_electron();
     return app.getPath("userData");
   }
   if (process.platform === "darwin") {
-    return path11.join(os5.homedir(), "Library", "Application Support", "ctlsurf-worker");
+    return path15.join(os6.homedir(), "Library", "Application Support", "ctlsurf-worker");
   }
-  return path11.join(
-    process.env.XDG_CONFIG_HOME || path11.join(os5.homedir(), ".config"),
+  return path15.join(
+    process.env.XDG_CONFIG_HOME || path15.join(os6.homedir(), ".config"),
     "ctlsurf-worker"
   );
 }
@@ -21737,9 +22642,9 @@ var Tui = class {
 
 // src/main/monitor.ts
 import { execFile as execFile2 } from "child_process";
-import fs8 from "fs";
-import os6 from "os";
-import path12 from "path";
+import fs11 from "fs";
+import os7 from "os";
+import path16 from "path";
 var FAST_MS = 3e3;
 var SLOW_MS = 1e4;
 var IDLE_STOP_MS = 12e4;
@@ -21764,7 +22669,7 @@ function run(cmd, args, opts = {}) {
   });
 }
 function serviceFor(agent) {
-  const cmd = isRemoteAgent(agent) ? agent.args.slice(2).join(" ") : path12.basename(agent.command);
+  const cmd = isRemoteAgent(agent) ? agent.args.slice(2).join(" ") : path16.basename(agent.command);
   if (/\bcodex\b/.test(cmd)) return "codex";
   if (/\bclaude\b/.test(cmd)) return "claude";
   return null;
@@ -21772,7 +22677,7 @@ function serviceFor(agent) {
 function cpuTimes() {
   let idle = 0;
   let total = 0;
-  for (const c of os6.cpus()) {
+  for (const c of os7.cpus()) {
     const t = c.times;
     idle += t.idle;
     total += t.user + t.nice + t.sys + t.idle + t.irq;
@@ -21780,8 +22685,8 @@ function cpuTimes() {
   return { idle, total };
 }
 async function memory() {
-  const total = os6.totalmem();
-  let avail = os6.freemem();
+  const total = os7.totalmem();
+  let avail = os7.freemem();
   try {
     if (process.platform === "darwin") {
       const out = await run("vm_stat", []);
@@ -21789,7 +22694,7 @@ async function memory() {
       const pages = (name) => Number(new RegExp(`Pages ${name}:\\s+(\\d+)`).exec(out)?.[1] ?? 0);
       avail = (pages("free") + pages("inactive") + pages("speculative")) * page;
     } else if (process.platform === "linux") {
-      const m = /MemAvailable:\s+(\d+) kB/.exec(await fs8.promises.readFile("/proc/meminfo", "utf-8"));
+      const m = /MemAvailable:\s+(\d+) kB/.exec(await fs11.promises.readFile("/proc/meminfo", "utf-8"));
       if (m) avail = Number(m[1]) * 1024;
     }
   } catch {
@@ -21798,9 +22703,9 @@ async function memory() {
   return { total, used: total - avail, pct: round(100 * (total - avail) / total) };
 }
 async function diskUsage() {
-  if (typeof fs8.promises.statfs !== "function") return null;
+  if (typeof fs11.promises.statfs !== "function") return null;
   try {
-    const s = await fs8.promises.statfs(os6.homedir());
+    const s = await fs11.promises.statfs(os7.homedir());
     return { total: s.blocks * s.bsize, free: s.bavail * s.bsize };
   } catch {
     return null;
@@ -21888,7 +22793,7 @@ async function claudeUsage() {
     const out = await run(
       "claude",
       ["-p", "/usage", "--output-format", "json", "--no-session-persistence"],
-      { cwd: os6.tmpdir(), timeout: 4e4 }
+      { cwd: os7.tmpdir(), timeout: 4e4 }
     );
     text = String(JSON.parse(out || "{}").result ?? "");
   } catch (err) {
@@ -21924,7 +22829,7 @@ function codexWindow(minutes) {
   return { label: s, short: s };
 }
 async function readTail(file, bytes) {
-  const fh = await fs8.promises.open(file, "r");
+  const fh = await fs11.promises.open(file, "r");
   try {
     const { size } = await fh.stat();
     const start = Math.max(0, size - bytes);
@@ -21936,7 +22841,7 @@ async function readTail(file, bytes) {
   }
 }
 async function codexSessionFiles(root, limit2) {
-  const sortedDirs = async (dir) => (await fs8.promises.readdir(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => path12.join(dir, d.name)).sort().reverse();
+  const sortedDirs = async (dir) => (await fs11.promises.readdir(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => path16.join(dir, d.name)).sort().reverse();
   const days = [];
   for (const y of await sortedDirs(root)) {
     for (const m of await sortedDirs(y)) {
@@ -21947,20 +22852,20 @@ async function codexSessionFiles(root, limit2) {
   }
   const files = [];
   for (const day of days.slice(0, 14)) {
-    for (const name of await fs8.promises.readdir(day).catch(() => [])) {
+    for (const name of await fs11.promises.readdir(day).catch(() => [])) {
       if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
-      const file = path12.join(day, name);
+      const file = path16.join(day, name);
       try {
-        files.push({ file, mtime: (await fs8.promises.stat(file)).mtimeMs });
+        files.push({ file, mtime: (await fs11.promises.stat(file)).mtimeMs });
       } catch {
       }
     }
   }
   return files.sort((a, b) => b.mtime - a.mtime).slice(0, limit2).map((f) => f.file);
 }
-async function codexUsage(home = os6.homedir()) {
+async function codexUsage(home = os7.homedir()) {
   const source = "your most recent Codex session";
-  for (const file of await codexSessionFiles(path12.join(home, ".codex", "sessions"), 5)) {
+  for (const file of await codexSessionFiles(path16.join(home, ".codex", "sessions"), 5)) {
     let lines;
     try {
       lines = (await readTail(file, CODEX_TAIL_BYTES)).split("\n");
@@ -21985,7 +22890,7 @@ async function codexUsage(home = os6.homedir()) {
         windows.push({ label, short, pct: Number(w.used_percent), resets });
       }
       if (windows.length) {
-        const ts = new Date((await fs8.promises.stat(file)).mtimeMs).toISOString();
+        const ts = new Date((await fs11.promises.stat(file)).mtimeMs).toISOString();
         return { ok: true, windows, plan: rl.plan_type ?? null, source, ts };
       }
     }
@@ -22055,7 +22960,7 @@ var ResourceMonitor = class {
       this.machine = {
         ok: true,
         ts: now(),
-        cpu: { pct: cpuPct, cores: os6.cpus().length, load: os6.loadavg().map((x) => round(x, 2)) },
+        cpu: { pct: cpuPct, cores: os7.cpus().length, load: os7.loadavg().map((x) => round(x, 2)) },
         mem,
         disk,
         gpu
@@ -22093,7 +22998,7 @@ var ResourceMonitor = class {
     return {
       machine: {
         ...this.machine,
-        label: process.platform === "darwin" ? "This Mac" : os6.hostname(),
+        label: process.platform === "darwin" ? "This Mac" : os7.hostname(),
         history: [...this.history]
       },
       agents: this.agents,