@phenx-inc/ctlsurf 0.17.2 → 0.17.4

package/out/main/index.js

@@ -29,6 +29,7 @@ const os = require("os");
 const https = require("https");
 const module$1 = require("module");
 const child_process = require("child_process");
+const string_decoder = require("string_decoder");
 const require$$1 = require("crypto");
 const require$$0$3 = require("events");
 const require$$2 = require("http");
@@ -38,6 +39,7 @@ const require$$0$2 = require("stream");
 const require$$7 = require("url");
 const require$$0 = require("zlib");
 const require$$0$1 = require("buffer");
+const cp = require("node:child_process");
 const NPM_PACKAGE = "@phenx-inc/ctlsurf";
 function compareSemver(a, b2) {
   const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
@@ -6261,6 +6263,8 @@ const POLL_INTERVAL_MS = 1e3;
 const DISCOVERY_SLACK_MS = 1e4;
 const READ_CHUNK_BYTES = 64 * 1024;
 const MAX_ENTRY_CHARS = 2e4;
+const MAX_READ_PER_POLL = 512 * 1024;
+const MAX_LINE_CHARS = 1024 * 1024;
 class TranscriptTailer {
   agentId;
   cwd;
@@ -6328,7 +6332,7 @@ class TranscriptTailer {
         try {
           const stat = fs.statSync(filePath);
           if (stat.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 string_decoder.StringDecoder("utf8"), discardingLine: false, scoped: this.agentId === "claude" });
           }
         } catch {
         }
@@ -6358,7 +6362,14 @@ class TranscriptTailer {
     } catch {
       return;
     }
-    if (size <= tail.offset) return;
+    if (size < tail.offset) {
+      tail.offset = 0;
+      tail.remainder = "";
+      tail.decoder = new string_decoder.StringDecoder("utf8");
+      tail.discardingLine = false;
+      tail.scoped = this.agentId === "claude";
+    }
+    if (size === tail.offset) return;
     let fd;
     try {
       fd = fs.openSync(filePath, "r");
@@ -6367,17 +6378,26 @@ class TranscriptTailer {
     }
     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);
@@ -6388,7 +6408,7 @@ class TranscriptTailer {
       }
     }
   }
-  handleLine(line, tail) {
+  handleLine(line, tail, filePath) {
     const trimmed = line.trim();
     if (!trimmed) return;
     let obj;
@@ -6397,16 +6417,18 @@ class TranscriptTailer {
     } 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$2(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;
@@ -6435,9 +6457,10 @@ class TranscriptTailer {
     const payload = obj.payload;
     if (obj.type === "session_meta") {
       const metaCwd = payload?.cwd;
-      if (typeof metaCwd === "string" && stripTrailingSep$2(metaCwd) !== this.cwd) {
+      if (typeof metaCwd !== "string" || stripTrailingSep$2(metaCwd) !== this.cwd) {
         tail.excluded = true;
       }
+      tail.scoped = !tail.excluded;
       return null;
     }
     if (obj.type !== "event_msg" || !payload || typeof payload !== "object") return null;
@@ -12014,7 +12037,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;
@@ -12034,7 +12057,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);
@@ -22756,6 +22779,842 @@ function extractToolResultText(content) {
   if (!Array.isArray(content)) return "";
   return content.filter((b2) => b2?.type === "text" && typeof b2.text === "string").map((b2) => b2.text).join("\n");
 }
+var checkWorkMapGpu = { exports: {} };
+var hasRequiredCheckWorkMapGpu;
+function requireCheckWorkMapGpu() {
+  if (hasRequiredCheckWorkMapGpu) return checkWorkMapGpu.exports;
+  hasRequiredCheckWorkMapGpu = 1;
+  (function(module2) {
+    function initialCapability({ 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…" };
+    }
+    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((resolve, reject) => {
+        const { execFile } = cp;
+        execFile("/usr/sbin/system_profiler", ["SPDisplaysDataType", "-json"], { timeout: 5e3, maxBuffer: 1024 * 1024 }, (error, output) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          try {
+            resolve(JSON.parse(output));
+          } catch (error2) {
+            reject(error2);
+          }
+        });
+      });
+    }
+    async function detectCapability(options = {}) {
+      const initial = initialCapability(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((resolve) => {
+              timer = setTimeout(() => resolve(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." };
+      }
+    }
+    module2.exports = { initialCapability, appleGpuFromReport, usableElectronGpu, detectCapability };
+    if (require.main === module2) {
+      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(() => {
+      });
+    }
+  })(checkWorkMapGpu);
+  return checkWorkMapGpu.exports;
+}
+var checkWorkMapGpuExports = requireCheckWorkMapGpu();
+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((p2) => typeof p2 !== "number" || !Number.isFinite(p2) || p2 < 0 || p2 > 1) || Math.abs(values.reduce((s, p2) => s + p2, 0) - 1) > 2e-3 || a.probabilities[a.choice] < Math.max(...values) - 1e-6) throw new Error("Clef returned invalid probabilities");
+  }
+  return answers;
+}
+class ClefWorker {
+  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((resolve, reject) => {
+        this.pending = { id: ++this.seq, resolve, 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 (!fs.existsSync(settings.pythonPath) || !fs.existsSync(path$1.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 = child_process.spawn(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((resolve, 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");
+            resolve();
+          } 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((resolve) => child.once("close", () => resolve()));
+      child.kill("SIGKILL");
+    }
+    this.change("idle");
+  }
+}
+const textOf = (value) => {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((b2) => b2?.text || "").filter(Boolean).join("\n");
+  return "";
+};
+const compact = (value) => {
+  if (typeof value === "string") return value.slice(0, 1800);
+  try {
+    return JSON.stringify(value ?? {}).slice(0, 1800);
+  } catch {
+    return "";
+  }
+};
+const noise = (text) => /^\s*(?:<environment_context>|<user_instructions>|<permissions instructions>|<system-reminder>|<local-command|<command-|<task-notification>|<turn_aborted>|# AGENTS\.md)/i.test(text);
+const 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 p2 = raw?.payload;
+  if (raw?.type === "response_item" && p2?.type === "reasoning") {
+    const text = summaryText(p2.summary);
+    return { text, key: p2.id || text };
+  }
+  if (raw?.type === "event_msg" && p2?.type === "agent_reasoning") {
+    const text = typeof p2.text === "string" ? p2.text : "";
+    return { text, key: p2.id || text };
+  }
+  const item = raw?.type === "event_msg" && p2?.type === "item_completed" ? p2.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((b2) => b2?.type === "thinking" || b2?.type === "redacted_thinking");
+    if (!blocks.length) return null;
+    return blocks.some((b2) => b2.type === "thinking" && typeof b2.thinking === "string" && b2.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 = path$1.basename(file);
+  const events = [];
+  const add = (kind, text, key, extra = {}) => {
+    if (!text.trim() || (kind === "prompt" || kind === "message") && noise(text)) return;
+    const hash = require$$1.createHash("sha256").update(`${file}:${key}:${kind}`).digest("hex").slice(0, 20);
+    const bounded = kind === "thinking" && text.length > 1800 ? `${text.slice(0, 300)}
+…
+${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((b2, i) => {
+      if (b2.type === "text") add(raw.type === "user" ? "prompt" : "message", b2.text || "", `${key}:${i}`);
+      if (raw.type === "assistant" && b2.type === "thinking" && typeof b2.thinking === "string") add("thinking", b2.thinking, `${key}:${i}`);
+      if (b2.type === "tool_use") add("tool", compact(b2.input?.command ?? b2.input?.file_path ?? b2.input), b2.id, { tool: b2.name, toolId: b2.id, status: "running" });
+      if (b2.type === "tool_result") add("result", textOf(b2.content) || "Tool completed", b2.tool_use_id, {
+        toolId: b2.tool_use_id,
+        status: b2.is_error === true ? "failed" : "succeeded"
+      });
+    });
+    return events;
+  }
+  const thinking = codexThinking(raw);
+  if (thinking) {
+    add("thinking", thinking.text, `reasoning:${thinking.key}`);
+    return events;
+  }
+  const p2 = raw.payload;
+  if (!p2) return [];
+  if (raw.type === "event_msg") {
+    if (p2.type === "user_message" || p2.type === "agent_message") {
+      add(p2.type === "user_message" ? "prompt" : "message", textOf(p2.message), `${ts}:${p2.type}:${textOf(p2.message)}`);
+    }
+    const item = p2.type === "item_completed" ? p2.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 (p2.type === "message" && (p2.role === "user" || p2.role === "assistant")) {
+    const text = Array.isArray(p2.content) ? p2.content.filter((b2) => ["input_text", "output_text"].includes(b2.type)).map((b2) => b2.text).join("\n") : "";
+    add(p2.role === "user" ? "prompt" : "message", text, p2.id || `${ts}:${p2.role}:${text}`);
+  }
+  if (p2.type === "function_call" || p2.type === "custom_tool_call") {
+    if (/^(?:functions\.)?exec$/.test(p2.name)) return events;
+    let input = p2.arguments ?? p2.input;
+    try {
+      const obj = JSON.parse(input);
+      input = obj.cmd ?? obj.command ?? obj.file_path ?? obj;
+    } catch {
+    }
+    add("tool", compact(input), p2.call_id, { tool: p2.name, toolId: p2.call_id, status: "running" });
+  }
+  if (p2.type === "function_call_output" || p2.type === "custom_tool_call_output") {
+    const output = textOf(p2.output) || compact(p2.output);
+    const exit = output.match(/(?:Process exited with code|exit_code["']?\s*:)\s*(-?\d+)/i);
+    const status = p2.is_error === true ? "failed" : exit ? Number(exit[1]) === 0 ? "succeeded" : "failed" : "unknown";
+    add("result", output, p2.call_id, { toolId: p2.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()}…` : 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, b2) => b2.score - a.score || a.index - b2.index).slice(0, 6).map((p2) => p2.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";
+}
+const 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"
+};
+const 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"
+};
+const MAP_NODE_LIMIT = 240;
+class WorkMapTree {
+  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"} · ${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((b2) => b2.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((b2) => b2.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} · ${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);
+  }
+}
+async function readMapSource(file, agent, eventId) {
+  const decoder = new string_decoder.StringDecoder("utf8");
+  let remainder = "";
+  let discard = false;
+  const stream2 = fs.createReadStream(file, { highWaterMark: 64 * 1024 });
+  for await (const chunk of stream2) {
+    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: path$1.basename(file) };
+    }
+    if (remainder.length > 1024 * 1024) {
+      remainder = "";
+      discard = true;
+    }
+  }
+  return null;
+}
+class WorkMap {
+  constructor(appRoot, onUpdate, roots = {}, capability = checkWorkMapGpuExports.initialCapability()) {
+    this.onUpdate = onUpdate;
+    this.roots = roots;
+    this.capability = capability;
+    const cache = path$1.join(appRoot, "experiments/live-map/.cache");
+    const prepared = path$1.join(os.homedir(), ".ctlsurf/clef-flash");
+    const pilotPython = path$1.join(cache, "envs/clef-flash/bin/python");
+    this.settings = {
+      enabled: false,
+      engine: "clef-flash",
+      pythonPath: process.env.CTLSURF_CLEF_PYTHON || (fs.existsSync(pilotPython) ? pilotPython : path$1.join(prepared, "env/bin/python")),
+      modelPath: process.env.CTLSURF_CLEF_MODEL || (fs.existsSync(pilotPython) ? path$1.join(cache, "models/clef-flash") : path$1.join(prepared, "model"))
+    };
+    this.clef = new ClefWorker(path$1.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();
+  }
+}
 const DEFAULT_IDLE_TIMEOUT_MIN = 15;
 const DEFAULT_PROFILES = {
   production: {
@@ -22779,6 +23638,7 @@ class Orchestrator {
   timeTracker = new TimeTracker(this.ctlsurfApi);
   ticketStore = new TicketStore(this.ctlsurfApi);
   observer;
+  workMap;
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -22798,19 +23658,24 @@ class Orchestrator {
   // 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), {}, checkWorkMapGpuExports.initialCapability({ desktop: options?.desktop === true }));
     this.observer = new Observer({
       settingsDir,
       api: this.ctlsurfApi,
-      getSettings: () => this.settings.observer || {},
+      getSettings: () => ({
+        ...this.settings.observer,
+        enabled: false
+      }),
       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({
@@ -22882,13 +23747,24 @@ class Orchestrator {
     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: false,
       hasApiKey: keySource !== null,
       keySource,
       dailyCapUsd: o.dailyCapUsd ?? OBSERVER_DEFAULTS.dailyCapUsd
@@ -23048,6 +23924,7 @@ class Orchestrator {
     }
     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 = path$1.join(this.settingsDir, "settings.json");
@@ -23194,6 +24071,7 @@ class Orchestrator {
       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);
     }
@@ -23208,6 +24086,7 @@ class Orchestrator {
     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;
@@ -23229,6 +24108,7 @@ class Orchestrator {
       if (this.tabs.get(tabId) !== tab) return;
       this.events.onPtyExit(tabId, exitCode);
       this.observer.endTab(tabId, tab.projectRootPath);
+      this.workMap.end(tabId);
       await this.timeTracker.endSession(tabId);
       if (this.tabs.get(tabId) !== tab) return;
       if (tabId === this.activeTabId) {
@@ -23279,6 +24159,7 @@ class Orchestrator {
   }
   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);
@@ -23479,6 +24360,7 @@ class Orchestrator {
   }
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
+    this.workMap.shutdown();
     this.stopNoProjectPolling();
     this.stopChatLogging();
     this.stateMonitor.stop();
@@ -24024,6 +24906,8 @@ const orchestrator = new Orchestrator(
     onAgentMessage: (text) => mainWindow?.webContents.send("agent:message", text),
     onObserverUpdate: (item) => mainWindow?.webContents.send("observer:update", item),
     onObserverActivity: (reviewing) => mainWindow?.webContents.send("observer:activity", reviewing),
+    onWorkMapUpdate: (snapshot) => mainWindow?.webContents.send("workmap:update", snapshot),
+    onWorkMapCapability: (capability) => mainWindow?.webContents.send("workmap:capability", capability),
     onAgentStateChange: (tabId, state, anyAwaiting) => {
       log(`[agent-state] tab=${tabId} state=${state} anyAwaiting=${anyAwaiting}`);
       mainWindow?.webContents.send("agent:state", tabId, state, anyAwaiting);
@@ -24033,8 +24917,13 @@ const orchestrator = new Orchestrator(
       mainWindow?.webContents.send("app:cwdChanged");
       updateProjectBadge(orchestrator.getActiveTabProjectPath() || orchestrator.cwd);
     }
-  }
+  },
+  { appRoot: workMapRoot(), desktop: true }
 );
+function workMapRoot() {
+  const resources = process.resourcesPath;
+  return fs.existsSync(path$1.join(resources, "scripts", "work-map-clef.py")) ? resources : electron.app.getAppPath();
+}
 function createWindow() {
   const saved = orchestrator.settingsData;
   if (saved.themeSource === "light" || saved.themeSource === "dark" || saved.themeSource === "system") {
@@ -24379,6 +25268,30 @@ electron.ipcMain.handle("speak:set", (_event, enabled) => {
   orchestrator.setSpeakReplies(!!enabled);
   return { enabled: orchestrator.speakRepliesEnabled };
 });
+electron.ipcMain.handle("workmap:get", (_event, tabId) => orchestrator.workMap.snapshot(String(tabId)));
+electron.ipcMain.handle("workmap:capability", () => orchestrator.workMap.getCapability());
+electron.ipcMain.handle("workmap:source", (_event, tabId, eventId) => orchestrator.workMap.getSource(String(tabId), String(eventId)));
+electron.ipcMain.handle("workmap:set", (_event, tabId, data) => {
+  if (!data || typeof data !== "object") throw new Error("Invalid work map settings");
+  const input = data;
+  const clean = {
+    ...orchestrator.workMap.snapshot(String(tabId)).settings
+  };
+  if (typeof input.enabled === "boolean") clean.enabled = input.enabled;
+  if (input.engine === "rules" || input.engine === "clef-flash") clean.engine = input.engine;
+  for (const key of ["pythonPath", "modelPath"]) {
+    if (typeof input[key] === "string") {
+      if (input[key].length > 4096 || !path$1.isAbsolute(input[key])) throw new Error("Model paths must be absolute local paths");
+      clean[key] = input[key];
+    }
+  }
+  orchestrator.configureWorkMap(clean);
+  return orchestrator.workMap.snapshot(String(tabId));
+});
+electron.ipcMain.handle("workmap:clear", (_event, tabId) => {
+  orchestrator.workMap.clear(String(tabId));
+  return orchestrator.workMap.snapshot(String(tabId));
+});
 electron.ipcMain.handle("observer:get", () => orchestrator.getObserverSettingsSummary());
 electron.ipcMain.handle("observer:set", (_event, data) => {
   orchestrator.saveObserverSettings(data);
@@ -24449,6 +25362,9 @@ electron.app.whenReady().then(() => {
   }
   orchestrator.loadSettings();
   createWindow();
+  void checkWorkMapGpuExports.detectCapability({ desktop: true, verifyGpu: async () => checkWorkMapGpuExports.usableElectronGpu(await electron.app.getGPUInfo("complete")) }).then((capability) => {
+    if (!shutdownStarted) orchestrator.setWorkMapCapability(capability);
+  });
   setTimeout(() => {
     void checkForUpdate();
   }, 3e3);