claude-maestro 0.1.16 → 0.1.18

package/out/main/index.js

@@ -70,6 +70,29 @@ async function worktreeInfo(folder) {
     return { isRepo: false, repoRoot: null, branch: null };
   }
 }
+async function listBranches(folder) {
+  try {
+    const [refs, head] = await Promise.all([
+      git(folder, ["for-each-ref", "refs/heads", "--sort=refname", "--format=%(refname:short)"]),
+      git(folder, ["rev-parse", "--abbrev-ref", "HEAD"])
+    ]);
+    if (refs.code !== 0) return { branches: [], current: null, defaultBranch: null };
+    const branches = refs.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    const current = head.code === 0 && head.stdout.trim() !== "HEAD" ? head.stdout.trim() : null;
+    let defaultBranch = null;
+    const originHead = await git(folder, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    if (originHead.code === 0) {
+      const name = originHead.stdout.trim().replace(/^origin\//, "");
+      if (branches.includes(name)) defaultBranch = name;
+    }
+    if (!defaultBranch) {
+      defaultBranch = ["main", "master"].find((b) => branches.includes(b)) ?? (current && branches.includes(current) ? current : branches[0] ?? null);
+    }
+    return { branches, current, defaultBranch };
+  } catch {
+    return { branches: [], current: null, defaultBranch: null };
+  }
+}
 async function gitInit(folder) {
   const init = await git(folder, ["init"]);
   if (init.code !== 0) return init;
@@ -697,21 +720,21 @@ class StatusDetector {
   }
 }
 const RING_BUFFER_BYTES = 2 * 1024 * 1024;
-const IS_WIN = process.platform === "win32";
-function which(name) {
-  const out = IS_WIN ? child_process.spawnSync("where.exe", [name], { encoding: "utf8" }) : child_process.spawnSync("which", ["-a", name], { encoding: "utf8" });
+const IS_WIN$1 = process.platform === "win32";
+function which$1(name) {
+  const out = IS_WIN$1 ? child_process.spawnSync("where.exe", [name], { encoding: "utf8" }) : child_process.spawnSync("which", ["-a", name], { encoding: "utf8" });
   if (out.status !== 0 || !out.stdout) return [];
   return out.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
 }
 const cache = /* @__PURE__ */ new Map();
 function resolveClaude() {
-  const candidates = which("claude");
-  const home = IS_WIN ? process.env.USERPROFILE : process.env.HOME;
+  const candidates = which$1("claude");
+  const home = IS_WIN$1 ? process.env.USERPROFILE : process.env.HOME;
   if (home) {
-    const localBin = path.join(home, ".local", "bin", IS_WIN ? "claude.exe" : "claude");
+    const localBin = path.join(home, ".local", "bin", IS_WIN$1 ? "claude.exe" : "claude");
     if (fs.existsSync(localBin)) candidates.push(localBin);
   }
-  if (!IS_WIN) {
+  if (!IS_WIN$1) {
     return candidates[0] ? { file: candidates[0], argsPrefix: [] } : null;
   }
   const exe = candidates.find((c) => c.toLowerCase().endsWith(".exe"));
@@ -721,19 +744,19 @@ function resolveClaude() {
   return null;
 }
 function resolvePowershell() {
-  const pwsh = which(IS_WIN ? "pwsh.exe" : "pwsh")[0] ?? which("pwsh")[0];
+  const pwsh = which$1(IS_WIN$1 ? "pwsh.exe" : "pwsh")[0] ?? which$1("pwsh")[0];
   if (pwsh) return { file: pwsh, argsPrefix: ["-NoLogo"] };
-  return IS_WIN ? { file: "powershell.exe", argsPrefix: ["-NoLogo"] } : null;
+  return IS_WIN$1 ? { file: "powershell.exe", argsPrefix: ["-NoLogo"] } : null;
 }
 function resolveCmd() {
-  return IS_WIN ? { file: process.env.ComSpec ?? "cmd.exe", argsPrefix: [] } : null;
+  return IS_WIN$1 ? { file: process.env.ComSpec ?? "cmd.exe", argsPrefix: [] } : null;
 }
 function resolveBash() {
-  if (!IS_WIN) {
-    const p = which("bash")[0] ?? (fs.existsSync("/bin/bash") ? "/bin/bash" : null);
+  if (!IS_WIN$1) {
+    const p = which$1("bash")[0] ?? (fs.existsSync("/bin/bash") ? "/bin/bash" : null);
     return p ? { file: p, argsPrefix: ["-i", "-l"] } : null;
   }
-  const onPath = which("bash.exe")[0] ?? which("bash")[0];
+  const onPath = which$1("bash.exe")[0] ?? which$1("bash")[0];
   if (onPath) return { file: onPath, argsPrefix: ["-i", "-l"] };
   const roots = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"]].filter(Boolean);
   for (const root2 of roots) {
@@ -745,8 +768,8 @@ function resolveBash() {
   return null;
 }
 function resolveZsh() {
-  if (IS_WIN) return null;
-  const p = which("zsh")[0] ?? (fs.existsSync("/bin/zsh") ? "/bin/zsh" : null);
+  if (IS_WIN$1) return null;
+  const p = which$1("zsh")[0] ?? (fs.existsSync("/bin/zsh") ? "/bin/zsh" : null);
   return p ? { file: p, argsPrefix: ["-i", "-l"] } : null;
 }
 function resolveKind(kind) {
@@ -774,17 +797,18 @@ function resolveKind(kind) {
 }
 const KIND_MISSING = {
   claude: "claude CLI not found on PATH.\r\nInstall it with: npm install -g @anthropic-ai/claude-code",
-  bash: IS_WIN ? "bash not found.\r\nInstall Git for Windows to get Git Bash." : "bash not found on PATH.",
+  bash: IS_WIN$1 ? "bash not found.\r\nInstall Git for Windows to get Git Bash." : "bash not found on PATH.",
   zsh: "zsh not found on PATH.",
   powershell: "PowerShell (pwsh) not found on PATH.",
   cmd: "cmd.exe is only available on Windows."
 };
 class PtySession {
-  constructor(config, folder, cb, sessionEnv = {}) {
+  constructor(config, folder, cb, sessionEnv = {}, dropEnv = []) {
     this.config = config;
     this.folder = folder;
     this.cb = cb;
     this.sessionEnv = sessionEnv;
+    this.dropEnv = dropEnv;
     this.detector = new StatusDetector(
       (s) => cb.onStatus(config.id, s),
       config.kind !== "claude"
@@ -796,6 +820,8 @@ class PtySession {
   attached = false;
   detector;
   exitCode = null;
+  /** Total chars of live process output this run (token-estimate feed). */
+  outputChars = 0;
   get pid() {
     return this.proc?.pid ?? null;
   }
@@ -826,6 +852,9 @@ class PtySession {
     for (const [k, v] of Object.entries(this.sessionEnv)) {
       if (k.trim()) env[k] = v;
     }
+    for (const k of this.dropEnv) {
+      if (!(k in this.sessionEnv)) delete env[k];
+    }
     try {
       this.proc = pty__namespace.spawn(cmd.file, args, {
         cols: 120,
@@ -905,6 +934,7 @@ class PtySession {
   handleData(data) {
     this.chunks.push(data);
     this.bufferedBytes += data.length;
+    this.outputChars += data.length;
     while (this.bufferedBytes > RING_BUFFER_BYTES && this.chunks.length > 1) {
       this.bufferedBytes -= this.chunks[0].length;
       this.chunks.shift();
@@ -1426,17 +1456,25 @@ class ConductorService {
    * `tagSessionId` focuses the turn on one session: the planner runs in that
    * repo, sees only that session's state, and defaults its actions to it. Null
    * (or an id that no longer exists) keeps the cross-repo conductor behaviour.
+   *
+   * `images` are files already saved by the conductor attach IPC; the planner
+   * is told to Read each one (its Read tool renders images), so a screenshot
+   * pasted into the chat is actually seen, not just mentioned.
    */
-  async send(text, tagSessionId = null) {
+  async send(text, tagSessionId = null, images = []) {
     const trimmed = text.trim();
-    if (!trimmed || this.busy) return;
+    const attached = (images ?? []).filter(
+      (i) => i && typeof i.path === "string" && fs.existsSync(i.path)
+    );
+    if (!trimmed && attached.length === 0 || this.busy) return;
     this.busy = true;
     const focusId = tagSessionId && this.sessions.getConfig(tagSessionId) ? tagSessionId : null;
     const userMsg = {
       id: crypto.randomUUID(),
       role: "user",
       text: trimmed,
-      at: Date.now()
+      at: Date.now(),
+      ...attached.length > 0 ? { images: attached } : {}
     };
     const assistantMsg = {
       id: crypto.randomUUID(),
@@ -1449,7 +1487,7 @@ class ConductorService {
     this.persistAndBroadcast();
     try {
       const snapshot = await this.buildSnapshot(focusId);
-      const prompt = this.buildPrompt(snapshot, userMsg.text, focusId);
+      const prompt = this.buildPrompt(snapshot, userMsg.text, focusId, attached);
       const cwd = this.plannerCwd(focusId);
       const out = await runHeadlessClaude({
         cwd,
@@ -1472,11 +1510,21 @@ class ConductorService {
       this.persistAndBroadcast();
     }
   }
-  /** Approve and run one proposed action. */
-  async approve(messageId, actionId) {
+  /**
+   * Approve and run one proposed action. For task-creating actions, `options`
+   * carries the approval card's choices (base branch, model, PR/auto-merge);
+   * they are applied to the created task and persisted as that repo's defaults
+   * for the next proposal.
+   */
+  async approve(messageId, actionId, options) {
     const action = this.findAction(messageId, actionId);
     if (!action || action.status !== "proposed") return;
-    await this.runAction(action);
+    if (options) this.saveTaskDefaults(action, options);
+    await this.runAction(action, options);
+  }
+  /** Persisted per-repo task-card defaults for a session, or null when none yet. */
+  getTaskDefaults(sessionId) {
+    return this.persistence.state.taskOptionDefaults?.[sessionId] ?? null;
   }
   /** Approve every non-destructive proposed action on a turn, in order. */
   async approveAll(messageId) {
@@ -1499,13 +1547,41 @@ class ConductorService {
   findAction(messageId, actionId) {
     return this.messages.find((m) => m.id === messageId)?.actions?.find((a) => a.id === actionId);
   }
+  /**
+   * The session whose repo a task-creating action targets — where the card's
+   * options apply and under which the per-repo defaults are stored.
+   */
+  taskTargetSessionId(action) {
+    const a = action.args;
+    if (action.kind === "create_worktree_task") return String(a.parentSessionId ?? "") || null;
+    if (action.kind === "author_feature") return String(a.sessionId ?? "") || null;
+    return null;
+  }
+  /** Remember the card's choices as the defaults for that repo's next proposal. */
+  saveTaskDefaults(action, options) {
+    const sessionId = this.taskTargetSessionId(action);
+    if (!sessionId) return;
+    const map = this.persistence.state.taskOptionDefaults ??= {};
+    map[sessionId] = options;
+    this.persistence.scheduleSave();
+  }
+  /**
+   * The effective task options for an action: the card's explicit choices when
+   * given, else the repo's persisted defaults (so Approve-all and re-approvals
+   * honour the last configuration), else none (the planner's args as-is).
+   */
+  taskOptionsFor(action, explicit) {
+    if (explicit) return explicit;
+    const sessionId = this.taskTargetSessionId(action);
+    return sessionId && this.persistence.state.taskOptionDefaults?.[sessionId] || void 0;
+  }
   /** Run one action by dispatching to the existing services; records the outcome. */
-  async runAction(action) {
+  async runAction(action, options) {
     action.status = "running";
     action.result = void 0;
     this.persistAndBroadcast();
     try {
-      action.result = await this.dispatch(action);
+      action.result = await this.dispatch(action, options);
       action.status = "done";
     } catch (err) {
       action.status = "error";
@@ -1514,7 +1590,7 @@ class ConductorService {
     this.persistAndBroadcast();
   }
   /** Map one approved action to a concrete service call; returns a result line. */
-  async dispatch(action) {
+  async dispatch(action, options) {
     const a = action.args;
     switch (action.kind) {
       case "create_session": {
@@ -1530,9 +1606,19 @@ class ConductorService {
       case "author_feature": {
         const session = this.requireSession(String(a.sessionId ?? ""));
         const feature = this.makeFeature(session.config.id, a);
+        const opts = a.implement ? this.taskOptionsFor(action, options) : void 0;
+        if (opts) {
+          if (opts.createPr) feature.completion = "pr";
+          if (opts.createPr || opts.autoMerge) feature.autoComplete = true;
+        }
         this.features.save(feature);
         if (a.implement) {
-          const task = await this.features.implement(feature.id);
+          const model = opts && opts.model !== "inherit" ? opts.model : void 0;
+          const task = await this.features.implement(
+            feature.id,
+            opts?.baseBranch.trim() || void 0,
+            model
+          );
           return `Drafted “${feature.title}” and spun a task to implement it (${task.config.name}).`;
         }
         return `Drafted feature “${feature.title}” with ${feature.specs.length} spec(s).`;
@@ -1547,13 +1633,24 @@ class ConductorService {
         const parent = this.requireSession(String(a.parentSessionId ?? ""));
         const branch = String(a.branch ?? "").trim();
         if (!branch) throw new Error("A branch name is required.");
+        const opts = this.taskOptionsFor(action, options);
+        const baseBranch = (opts?.baseBranch.trim() || String(a.baseBranch ?? "")).trim();
+        const model = opts && opts.model !== "inherit" ? opts.model : void 0;
         const task = await this.sessions.createWorktreeSession(parent.config.id, {
           name: a.name ? String(a.name) : branch,
           branch,
-          baseBranch: String(a.baseBranch ?? "").trim(),
-          initialPrompt: a.initialPrompt ? String(a.initialPrompt) : void 0
+          baseBranch,
+          initialPrompt: a.initialPrompt ? String(a.initialPrompt) : void 0,
+          ...opts?.createPr ? { completion: "pr" } : {},
+          ...opts && (opts.createPr || opts.autoMerge) ? { autoComplete: true } : {},
+          ...model ? { model } : {}
         });
-        return `Spun task “${task.config.name}” on branch ${branch}.`;
+        const extras = [
+          model ? `model ${model}` : "",
+          opts?.createPr ? "PR on completion" : "",
+          opts?.autoMerge ? "auto-merge when done" : ""
+        ].filter(Boolean);
+        return `Spun task “${task.config.name}” on branch ${branch}` + (extras.length ? ` (${extras.join(", ")})` : "") + ".";
       }
       case "queue_prompt": {
         const session = this.requireSession(String(a.sessionId ?? ""));
@@ -1685,11 +1782,12 @@ class ConductorService {
     return focusId ? { focusedSessionId: focusId, sessions } : { sessions };
   }
   /** Compose the full planner prompt: role, action catalog, snapshot, history, ask. */
-  buildPrompt(snapshot, latest, focusId) {
+  buildPrompt(snapshot, latest, focusId, images = []) {
     const focusName = focusId ? this.sessions.getConfig(focusId)?.name : void 0;
-    const history = this.messages.filter((m) => !m.pending && (m.text || m.actions && m.actions.length)).slice(-8 - 1, -1).map((m) => {
+    const history = this.messages.filter((m) => !m.pending && (m.text || m.images?.length || m.actions && m.actions.length)).slice(-8 - 1, -1).map((m) => {
       const acts = m.actions && m.actions.length ? ` [proposed: ${m.actions.map((a) => `${a.kind}(${a.status})`).join(", ")}]` : "";
-      return `${m.role.toUpperCase()}: ${m.text}${acts}`;
+      const imgs = m.images?.length ? ` [attached: ${m.images.map((i) => i.path).join(", ")}]` : "";
+      return `${m.role.toUpperCase()}: ${m.text}${imgs}${acts}`;
     }).join("\n");
     return [
       "You are the Conductor for Maestro, a desktop app that runs many Claude Code CLI",
@@ -1712,7 +1810,8 @@ class ConductorService {
 ${history}
 ` : "",
       `THE USER NOW SAYS:
-${latest}`,
+${latest || "(no text — see the attached images)"}`,
+      images.length ? "\nTHE USER ATTACHED IMAGE FILE(S) — e.g. screenshots to analyze. View each one with the Read tool (it renders images) using these ABSOLUTE paths, BEFORE answering:\n" + images.map((i) => `- ${i.path}`).join("\n") : "",
       "",
       "Respond with EXACTLY ONE JSON object and nothing else — no markdown fences, no prose",
       "around it — shaped like:",
@@ -1939,6 +2038,47 @@ function deleteArtifactFile(kind, name) {
   } catch {
   }
 }
+function listInstalled() {
+  const out = [];
+  if (fs.existsSync(SKILLS_DIR)) {
+    let dirs = [];
+    try {
+      dirs = fs.readdirSync(SKILLS_DIR);
+    } catch {
+      dirs = [];
+    }
+    for (const dir of dirs) {
+      const file = path.join(SKILLS_DIR, dir, "SKILL.md");
+      if (!fs.existsSync(file)) continue;
+      try {
+        const fm = parseFrontmatter(fs.readFileSync(file, "utf8"));
+        out.push({ kind: "skill", name: fm.name?.trim() || dir, description: fm.description ?? "", filePath: file });
+      } catch {
+        out.push({ kind: "skill", name: dir, description: "", filePath: file });
+      }
+    }
+  }
+  if (fs.existsSync(AGENTS_DIR)) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(AGENTS_DIR);
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const file = path.join(AGENTS_DIR, entry);
+      const base = entry.replace(/\.md$/, "");
+      try {
+        const fm = parseFrontmatter(fs.readFileSync(file, "utf8"));
+        out.push({ kind: "agent", name: fm.name?.trim() || base, description: fm.description ?? "", filePath: file });
+      } catch {
+        out.push({ kind: "agent", name: base, description: "", filePath: file });
+      }
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
 function scanAgents() {
   if (!fs.existsSync(AGENTS_DIR)) return [];
   let entries;
@@ -1966,6 +2106,7 @@ class FactoryStore {
   file = path.join(electron.app.getPath("userData"), "factory.json");
   timer = null;
   state = { ...EMPTY };
+  runs = [];
   /** Load the saved registry (best-effort; an empty registry on any error). */
   load() {
     try {
@@ -1975,19 +2116,30 @@ class FactoryStore {
         topics: Array.isArray(raw?.topics) ? raw.topics : [],
         lessons: Array.isArray(raw?.lessons) ? raw.lessons : []
       };
+      this.runs = Array.isArray(raw?.runs) ? raw.runs : [];
     } catch {
       this.state = { ...EMPTY };
+      this.runs = [];
     }
     return this.state;
   }
   get() {
     return this.state;
   }
+  /** The persisted run audit trail (call after load()). */
+  loadRuns() {
+    return this.runs;
+  }
   /** Replace the registry and schedule a save. */
   set(state) {
     this.state = state;
     this.scheduleSave();
   }
+  /** Replace the run audit trail and schedule a save. */
+  setRuns(runs) {
+    this.runs = runs;
+    this.scheduleSave();
+  }
   scheduleSave() {
     if (this.timer) clearTimeout(this.timer);
     this.timer = setTimeout(() => this.saveNow(), 500);
@@ -2000,7 +2152,7 @@ class FactoryStore {
     try {
       fs.mkdirSync(path.dirname(this.file), { recursive: true });
       const tmp = this.file + ".tmp";
-      fs.writeFileSync(tmp, JSON.stringify(this.state, null, 2), "utf8");
+      fs.writeFileSync(tmp, JSON.stringify({ ...this.state, runs: this.runs }, null, 2), "utf8");
       fs.renameSync(tmp, this.file);
     } catch (err) {
       console.error("Failed to persist factory registry:", err);
@@ -2024,14 +2176,17 @@ class FactoryService {
   constructor(getWin2) {
     this.getWin = getWin2;
     this.state = this.store.load();
+    this.runs = restoreRuns(this.store.loadRuns());
   }
   store = new FactoryStore();
   state;
   runs = [];
   sources = null;
-  /** The in-flight agent child, so dispose()/a new run can cancel it. */
+  /** The in-flight agent child, so dispose()/cancel() can kill it. */
   inFlight = null;
   busy = false;
+  /** Set by cancel(); the in-flight scan/author reports 'cancelled' instead of 'error'. */
+  cancelRequested = false;
   getState() {
     return this.state;
   }
@@ -2046,6 +2201,20 @@ class FactoryService {
     this.inFlight = null;
     this.store.saveNow();
   }
+  /** Cancel the in-flight scan/author agent, if any (the run reports 'cancelled'). */
+  cancel() {
+    if (!this.inFlight) return;
+    this.cancelRequested = true;
+    try {
+      this.inFlight.kill();
+    } catch {
+    }
+  }
+  /** Drop finished runs from the audit trail (a running one is kept). */
+  clearRuns() {
+    this.runs = this.runs.filter((r) => r.status === "running");
+    this.broadcastRuns();
+  }
   // ---------- source discovery (phase 0) ----------
   /**
    * Enumerate the MCP contexts the factory can mine. The connected claude.ai
@@ -2124,6 +2293,7 @@ class FactoryService {
     const source = sources.find((s) => s.server === serverKey);
     if (!source) throw new Error(`Unknown source: ${serverKey}`);
     this.busy = true;
+    this.cancelRequested = false;
     const run = {
       id: crypto.randomUUID(),
       source: source.server,
@@ -2155,9 +2325,9 @@ class FactoryService {
       run.status = "done";
       this.absorbTopics(parsed.newTopics, source.server);
     } catch (err) {
-      run.status = "error";
+      run.status = this.cancelRequested ? "cancelled" : "error";
       run.phase = "done";
-      run.summary = err.message || String(err);
+      run.summary = this.cancelRequested ? "Cancelled." : err.message || String(err);
     } finally {
       run.finishedAt = Date.now();
       this.inFlight = null;
@@ -2256,13 +2426,14 @@ Lessons learned (respect these):
     };
   }
   // ---------- author (phase 2) ----------
-  /** Approve a candidate: author its file content and write it to ~/.claude. */
+  /** Approve a candidate: author its file content and write it to ~/.claude. An errored candidate can be retried. */
   async approve(runId, candidateId) {
     const run = this.runs.find((r) => r.id === runId);
     const candidate = run?.candidates.find((c) => c.id === candidateId);
-    if (!run || !candidate || candidate.status !== "proposed") return;
+    if (!run || !candidate || candidate.status !== "proposed" && candidate.status !== "error") return;
     if (this.busy) return;
     this.busy = true;
+    this.cancelRequested = false;
     candidate.status = "authoring";
     candidate.result = void 0;
     this.broadcastRuns();
@@ -2294,8 +2465,13 @@ Lessons learned (respect these):
       candidate.filePath = filePath;
       candidate.result = `Wrote ${candidate.kind} to ${filePath}`;
     } catch (err) {
-      candidate.status = "error";
-      candidate.result = err.message || String(err);
+      if (this.cancelRequested) {
+        candidate.status = "proposed";
+        candidate.result = void 0;
+      } else {
+        candidate.status = "error";
+        candidate.result = err.message || String(err);
+      }
     } finally {
       this.inFlight = null;
       this.busy = false;
@@ -2303,12 +2479,13 @@ Lessons learned (respect these):
       this.broadcastState();
     }
   }
-  /** Approve every still-proposed candidate on a run, in order. */
+  /** Approve every still-proposed candidate on a run, in order (stops on cancel). */
   async approveAll(runId) {
     const run = this.runs.find((r) => r.id === runId);
     if (!run) return;
     for (const c of run.candidates) {
       if (c.status === "proposed") await this.approve(runId, c.id);
+      if (this.cancelRequested) break;
     }
   }
   reject(runId, candidateId) {
@@ -2425,13 +2602,64 @@ Lessons learned (respect these):
   deleteArtifact(id) {
     const artifact = this.state.artifacts.find((a) => a.id === id);
     if (!artifact) return;
-    deleteArtifactFile(artifact.kind, artifact.name);
+    if (!artifact.adopted) deleteArtifactFile(artifact.kind, artifact.name);
+    this.unregister(id);
+  }
+  /** Remove an artifact from the registry WITHOUT touching its file. */
+  unregister(id) {
+    const artifact = this.state.artifacts.find((a) => a.id === id);
+    if (!artifact) return;
     this.state.artifacts = this.state.artifacts.filter((a) => a.id !== id);
     for (const a of this.state.artifacts) {
       a.relatedArtifacts = a.relatedArtifacts.filter((n) => n !== artifact.name);
     }
     this.persist();
   }
+  /** Read a registered artifact's file content (null when the file is missing). */
+  readArtifact(id) {
+    const artifact = this.state.artifacts.find((a) => a.id === id);
+    if (!artifact) return null;
+    try {
+      return fs.readFileSync(artifact.filePath, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  /** Reveal a registered artifact's file in the OS file manager. */
+  revealArtifact(id) {
+    const artifact = this.state.artifacts.find((a) => a.id === id);
+    if (artifact && fs.existsSync(artifact.filePath)) electron.shell.showItemInFolder(artifact.filePath);
+  }
+  // ---------- registry↔disk audit (the lightweight validator) ----------
+  /** Reconcile the registry against ~/.claude on disk. */
+  audit() {
+    const missingFileIds = this.state.artifacts.filter((a) => !fs.existsSync(a.filePath)).map((a) => a.id);
+    const registered = new Set(this.state.artifacts.map((a) => `${a.kind}:${a.name}`));
+    const unregistered = listInstalled().filter((i) => !registered.has(`${i.kind}:${i.name}`));
+    return { missingFileIds, unregistered };
+  }
+  /** Adopt a pre-existing on-disk skill/agent into the registry (file is left as-is). */
+  adopt(kind, name) {
+    if (this.state.artifacts.some((a) => a.kind === kind && a.name === name)) return;
+    const installed = listInstalled().find((i) => i.kind === kind && i.name === name);
+    if (!installed) return;
+    const now = Date.now();
+    this.state.artifacts.push({
+      id: crypto.randomUUID(),
+      kind,
+      name,
+      filePath: installed.filePath,
+      description: installed.description,
+      topics: [],
+      keywords: [],
+      source: "adopted",
+      relatedArtifacts: [],
+      adopted: true,
+      createdAt: now,
+      updatedAt: now
+    });
+    this.persist();
+  }
   // ---------- backlog (topics-to-pursue) ----------
   absorbTopics(topics, source) {
     const have = new Set(this.state.topics.map((t) => t.title.toLowerCase()));
@@ -2495,9 +2723,27 @@ Lessons learned (respect these):
     this.getWin()?.webContents.send("factory:changed", this.state);
   }
   broadcastRuns() {
+    this.store.setRuns(this.runs);
     this.getWin()?.webContents.send("factory:runs", this.runs);
   }
 }
+function restoreRuns(runs) {
+  for (const run of runs) {
+    if (run.status === "running") {
+      run.status = "cancelled";
+      run.phase = "done";
+      run.finishedAt = run.finishedAt ?? Date.now();
+      run.summary = run.summary || "Interrupted — the app was closed mid-scan.";
+    }
+    for (const c of run.candidates) {
+      if (c.status === "authoring") {
+        c.status = "proposed";
+        c.result = void 0;
+      }
+    }
+  }
+  return runs;
+}
 function toStringArray(v) {
   if (!Array.isArray(v)) return [];
   return [...new Set(v.map((x) => String(x).trim()).filter(Boolean))];
@@ -2563,9 +2809,10 @@ class FeatureService {
    * Links the feature to the spawned session and flips it to 'implementing'.
    * Throws (with git's message) if the parent isn't a repo or the worktree fails.
    * `baseBranch` overrides which branch the task forks from and merges back
-   * into (used by auto-expand to keep its growth on a dedicated branch).
+   * into (used by auto-expand to keep its growth on a dedicated branch);
+   * `model` pins the task claude's model (used by the Conductor's approval card).
    */
-  async implement(featureId, baseBranch) {
+  async implement(featureId, baseBranch, model) {
     const feature = this.features.find((f) => f.id === featureId);
     if (!feature) throw new Error("Unknown feature");
     const parent = this.sessions.getConfig(feature.sessionId);
@@ -2580,7 +2827,8 @@ class FeatureService {
       initialPrompt: implementPrompt(feature),
       // Carry the feature's PR/merge preference onto the implementing task.
       completion: feature.completion,
-      autoComplete: feature.autoComplete
+      autoComplete: feature.autoComplete,
+      model
     });
     try {
       const specAbs = path.join(session.config.folder, specRelPath(feature));
@@ -3145,6 +3393,7 @@ class UsageService {
     return entries;
   }
 }
+const CONDUCTOR_ATTACH_SCOPE = "conductor";
 function tokenize(template) {
   const tokens = [];
   const re = /"([^"]*)"|(\S+)/g;
@@ -3152,7 +3401,7 @@ function tokenize(template) {
   while (m = re.exec(template)) tokens.push(m[1] ?? m[2]);
   return tokens;
 }
-function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpand, conductor, factory, getWin2) {
+function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpand, conductor, factory, tokenEff, getWin2) {
   const rootOf = (id) => {
     const config = sessions.getConfig(id);
     if (!config) throw new Error(`Unknown session: ${id}`);
@@ -3209,6 +3458,7 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     "git:fileDiff",
     (_e, sessionId, path2) => sessions.getGitFileDiff(sessionId, path2)
   );
+  electron.ipcMain.handle("git:branches", (_e, sessionId) => sessions.listBranches(sessionId));
   electron.ipcMain.handle(
     "checkpoint:create",
     (_e, sessionId, label) => sessions.createCheckpoint(sessionId, label)
@@ -3295,11 +3545,11 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
   electron.ipcMain.handle("conductor:list", () => conductor.list());
   electron.ipcMain.handle(
     "conductor:send",
-    (_e, text, tagSessionId) => conductor.send(text, tagSessionId ?? null)
+    (_e, text, tagSessionId, images) => conductor.send(text, tagSessionId ?? null, images ?? [])
   );
   electron.ipcMain.handle(
     "conductor:approve",
-    (_e, messageId, actionId) => conductor.approve(messageId, actionId)
+    (_e, messageId, actionId, options) => conductor.approve(messageId, actionId, options)
   );
   electron.ipcMain.handle(
     "conductor:approveAll",
@@ -3310,6 +3560,23 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     (_e, messageId, actionId) => conductor.reject(messageId, actionId)
   );
   electron.ipcMain.handle("conductor:clear", () => conductor.clear());
+  electron.ipcMain.handle(
+    "conductor:taskDefaults",
+    (_e, sessionId) => conductor.getTaskDefaults(sessionId)
+  );
+  electron.ipcMain.handle("conductor:attachClipboard", () => attachClipboardImage(CONDUCTOR_ATTACH_SCOPE));
+  electron.ipcMain.handle(
+    "conductor:attachFile",
+    (_e, srcPath) => attachImageFile(CONDUCTOR_ATTACH_SCOPE, srcPath)
+  );
+  electron.ipcMain.handle(
+    "conductor:attachData",
+    (_e, name, bytes) => attachImageData(CONDUCTOR_ATTACH_SCOPE, name, bytes)
+  );
+  electron.ipcMain.handle(
+    "conductor:attachDelete",
+    (_e, fileName) => deleteAttachment(CONDUCTOR_ATTACH_SCOPE, fileName)
+  );
   electron.ipcMain.handle("factory:listSources", (_e, refresh) => factory.listSources(refresh));
   electron.ipcMain.handle("factory:state", () => factory.getState());
   electron.ipcMain.handle("factory:runs", () => factory.listRuns());
@@ -3326,7 +3593,17 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     "factory:reject",
     (_e, runId, candidateId) => factory.reject(runId, candidateId)
   );
+  electron.ipcMain.handle("factory:cancel", () => factory.cancel());
+  electron.ipcMain.handle("factory:clearRuns", () => factory.clearRuns());
   electron.ipcMain.handle("factory:deleteArtifact", (_e, id) => factory.deleteArtifact(id));
+  electron.ipcMain.handle("factory:unregisterArtifact", (_e, id) => factory.unregister(id));
+  electron.ipcMain.handle("factory:readArtifact", (_e, id) => factory.readArtifact(id));
+  electron.ipcMain.handle("factory:revealArtifact", (_e, id) => factory.revealArtifact(id));
+  electron.ipcMain.handle("factory:audit", () => factory.audit());
+  electron.ipcMain.handle(
+    "factory:adopt",
+    (_e, kind, name) => factory.adopt(kind, name)
+  );
   electron.ipcMain.handle("factory:promoteTopic", (_e, id) => factory.promoteTopic(id));
   electron.ipcMain.handle("factory:dismissTopic", (_e, id) => factory.dismissTopic(id));
   electron.ipcMain.handle("factory:addLesson", (_e, text) => factory.addLesson(text));
@@ -3423,6 +3700,33 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     "attachments:delete",
     (_e, id, fileName) => deleteAttachment(id, fileName)
   );
+  electron.ipcMain.handle("tokenEff:status", (_e, sessionId) => tokenEff.status(sessionId));
+  electron.ipcMain.handle("tokenEff:saveGlobal", (_e, config) => {
+    tokenEff.saveGlobal(config);
+    getWin2()?.webContents.send("session:changed");
+  });
+  electron.ipcMain.handle(
+    "tokenEff:setRepoOverride",
+    (_e, sessionId, override) => {
+      tokenEff.setRepoOverride(sessionId, override);
+      getWin2()?.webContents.send("session:changed");
+    }
+  );
+  electron.ipcMain.handle(
+    "tokenEff:setSessionOverride",
+    (_e, sessionId, override) => {
+      tokenEff.setSessionOverride(sessionId, override);
+      getWin2()?.webContents.send("session:changed");
+    }
+  );
+  electron.ipcMain.handle(
+    "tokenEff:refreshRepoMap",
+    (_e, sessionId) => tokenEff.refreshRepoMap(sessionId)
+  );
+  electron.ipcMain.handle(
+    "tokenEff:detectTools",
+    (_e, refresh) => tokenEff.detectTools(refresh ?? false)
+  );
   const usage = new UsageService();
   electron.ipcMain.handle("usage:get", () => usage.snapshot());
   const usageLimits = new UsageLimitsService();
@@ -3461,6 +3765,17 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     getWin2()?.webContents.send("session:changed");
   });
 }
+const DEFAULT_TOKEN_EFFICIENCY = {
+  enabled: false,
+  outputCompression: true,
+  codeGraph: true,
+  truncationHooks: true,
+  promptCachingHints: true,
+  bashMaxOutputChars: 3e4,
+  mcpMaxOutputTokens: 25e3,
+  largeReadMaxKB: 256,
+  repoMapMaxFiles: 400
+};
 const DEFAULT_SETTINGS = {
   editorCommand: 'code "${path}"',
   scrollbackLines: 1e4,
@@ -3472,7 +3787,9 @@ const DEFAULT_SETTINGS = {
   backgroundOpacity: 0.3,
   watchdogEnabled: true,
   watchdogStallMinutes: 10,
-  watchdogUnansweredMinutes: 5
+  watchdogUnansweredMinutes: 5,
+  tokenEfficiency: DEFAULT_TOKEN_EFFICIENCY,
+  tokenEfficiencyRepoOverrides: {}
 };
 const DEFAULT_CATEGORIES = [
   {
@@ -3520,7 +3837,8 @@ const DEFAULT_STATE = {
   settings: DEFAULT_SETTINGS,
   categories: DEFAULT_CATEGORIES,
   actions: [],
-  features: []
+  features: [],
+  taskOptionDefaults: {}
 };
 function migrateSession(raw) {
   if (Array.isArray(raw.terminals) && raw.terminals.length > 0) {
@@ -3570,10 +3888,20 @@ class Persistence {
         ...DEFAULT_STATE,
         ...raw,
         window: { ...DEFAULT_STATE.window, ...raw.window ?? {} },
-        settings: { ...DEFAULT_SETTINGS, ...raw.settings ?? {} },
+        settings: {
+          ...DEFAULT_SETTINGS,
+          ...raw.settings ?? {},
+          // Nested object — merge so new fields gain their defaults on upgrade.
+          tokenEfficiency: {
+            ...DEFAULT_TOKEN_EFFICIENCY,
+            ...raw.settings?.tokenEfficiency ?? {}
+          },
+          tokenEfficiencyRepoOverrides: raw.settings?.tokenEfficiencyRepoOverrides ?? {}
+        },
         categories: Array.isArray(raw.categories) ? raw.categories : DEFAULT_CATEGORIES,
         actions: Array.isArray(raw.actions) ? raw.actions : [],
         features: Array.isArray(raw.features) ? raw.features : [],
+        taskOptionDefaults: raw.taskOptionDefaults && typeof raw.taskOptionDefaults === "object" ? raw.taskOptionDefaults : {},
         sessions: Array.isArray(raw.sessions) ? raw.sessions.map(migrateSession) : []
       };
     } catch {
@@ -3620,7 +3948,7 @@ const ALLOWED_TOOLS = [
   "Bash(gh pr diff:*)"
 ].join(",");
 const SEVERITIES = ["info", "warning", "critical"];
-function gitHead(folder) {
+function gitHead$1(folder) {
   return new Promise((resolve) => {
     child_process.execFile(
       "git",
@@ -3713,7 +4041,7 @@ class SentinelService {
     if (this.polling.has(session.id) || !fs.existsSync(session.folder)) return;
     this.polling.add(session.id);
     try {
-      const head = await gitHead(session.folder);
+      const head = await gitHead$1(session.folder);
       if (!head) return;
       const previous = this.heads.get(session.id);
       this.heads.set(session.id, head);
@@ -3876,14 +4204,14 @@ function parseAgentOutput(stdout) {
   if (!text) return { summary: "", findings: [], error: "The agent produced no output." };
   return { summary: text.slice(0, 500), findings: [] };
 }
-const SETTINGS_REL = ".claude/settings.local.json";
+const SETTINGS_REL$1 = ".claude/settings.local.json";
 const MCP_REL = ".mcp.json";
-function writeJsonAtomic(file, value) {
+function writeJsonAtomic$1(file, value) {
   const tmp = file + ".tmp";
   fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", "utf8");
   fs.renameSync(tmp, file);
 }
-function readJson(file) {
+function readJson$1(file) {
   if (!fs.existsSync(file)) return {};
   try {
     const v = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -3893,9 +4221,9 @@ function readJson(file) {
   }
 }
 function applySettings(folder, category, allSkillNames, allManagedServerNames) {
-  const file = path.join(folder, SETTINGS_REL);
+  const file = path.join(folder, SETTINGS_REL$1);
   const existed = fs.existsSync(file);
-  const settings = readJson(file);
+  const settings = readJson$1(file);
   const overrides = settings.skillOverrides && typeof settings.skillOverrides === "object" ? { ...settings.skillOverrides } : {};
   const enabled = new Set(category?.enabledSkills ?? []);
   for (const name of allSkillNames) {
@@ -3918,19 +4246,19 @@ function applySettings(folder, category, allSkillNames, allManagedServerNames) {
   else delete settings.enabledMcpjsonServers;
   if (!existed && Object.keys(settings).length === 0) return;
   fs.mkdirSync(path.join(folder, ".claude"), { recursive: true });
-  writeJsonAtomic(file, settings);
+  writeJsonAtomic$1(file, settings);
 }
 function applyMcp(folder, category, allManagedServerNames) {
   const file = path.join(folder, MCP_REL);
   const existed = fs.existsSync(file);
-  const root2 = readJson(file);
+  const root2 = readJson$1(file);
   const servers = root2.mcpServers && typeof root2.mcpServers === "object" ? { ...root2.mcpServers } : {};
   for (const name of allManagedServerNames) delete servers[name];
   if (category) for (const s of category.mcpServers) servers[s.name] = s.config;
   if (Object.keys(servers).length > 0) root2.mcpServers = servers;
   else delete root2.mcpServers;
   if (!existed && Object.keys(root2).length === 0) return;
-  writeJsonAtomic(file, root2);
+  writeJsonAtomic$1(file, root2);
 }
 function ensureGitExclude(folder) {
   const file = excludeFilePathSync(folder);
@@ -3943,7 +4271,7 @@ function ensureGitExclude(folder) {
     return;
   }
   const lines = new Set(current.split(/\r?\n/).map((l) => l.trim()));
-  const wanted = [SETTINGS_REL, MCP_REL].filter((p) => !lines.has(p));
+  const wanted = [SETTINGS_REL$1, MCP_REL].filter((p) => !lines.has(p));
   if (wanted.length === 0) return;
   try {
     fs.mkdirSync(infoDir, { recursive: true });
@@ -4092,9 +4420,10 @@ const STATUS_PRIORITY = [
   "exited"
 ];
 class SessionManager {
-  constructor(persistence2, fs2, getWin2) {
+  constructor(persistence2, fs2, tokenEff, getWin2) {
     this.persistence = persistence2;
     this.fs = fs2;
+    this.tokenEff = tokenEff;
     this.getWin = getWin2;
   }
   /** Keyed by terminal id, across all sessions. */
@@ -4153,6 +4482,7 @@ class SessionManager {
       skillNames,
       this.managedServerNames()
     );
+    this.tokenEff.apply(config);
   }
   sessionOfTerminal(terminalId) {
     return this.state.sessions.find((s) => s.terminals.some((t) => t.id === terminalId));
@@ -4199,6 +4529,7 @@ class SessionManager {
     }
     this.fs.stop(id);
     this.clearQueueTimer(id);
+    this.tokenEff.clearApplied(id);
     void deleteAllAttachments(id).catch(() => {
     });
     this.state.sessions = this.state.sessions.filter((s) => s.id !== id);
@@ -4248,6 +4579,12 @@ class SessionManager {
     if (!config) return { diff: "", binary: false, truncated: false };
     return gitFileDiff(config.folder, path2);
   }
+  /** Local branches + default branch of a session's repo (base-branch picker). */
+  async listBranches(sessionId) {
+    const config = this.getConfig(sessionId);
+    if (!config) return { branches: [], current: null, defaultBranch: null };
+    return listBranches(config.folder);
+  }
   /**
    * Initialize a git repository in a session's folder (so a non-repo session can
    * host parallel tasks). Returns the resulting git facts; throws git's message
@@ -4333,7 +4670,8 @@ class SessionManager {
       kind: "claude",
       title: "claude",
       order: 0,
-      claudeArgs: [],
+      // A model picked for the task pins its claude via --model; absent = CLI default.
+      claudeArgs: opts.model ? ["--model", opts.model] : [],
       startMode: "fresh"
     };
     const config = {
@@ -4619,10 +4957,26 @@ ${commit.output}` };
         event.url = pr.url;
         event.output = pr.output;
       } else {
-        const merge = await this.mergeWorktree(sessionId, true);
-        event.ok = merge.ok;
-        event.conflict = merge.conflict;
-        event.output = merge.output;
+        const baseDirty = await dirtyCount(wt.baseFolder) ?? 0;
+        const conflicts = baseDirty > 0 ? null : await mergeConflictFiles(wt.baseFolder, wt.branch, wt.baseBranch).catch(
+          () => null
+        );
+        if (baseDirty > 0) {
+          event.ok = false;
+          event.output = `Auto-merge skipped: the base working tree (${wt.baseFolder}) has ${baseDirty} uncommitted file(s). Commit or stash them, then merge the task from the sidebar.`;
+        } else if (conflicts && conflicts.length > 0) {
+          event.ok = false;
+          event.conflict = true;
+          event.output = `Auto-merge skipped: merging "${wt.branch}" into "${wt.baseBranch}" would conflict in:
+` + conflicts.map((f) => `  • ${f}`).join("\n") + `
+
+The base repo was left untouched — merge from the sidebar to resolve.`;
+        } else {
+          const merge = await this.mergeWorktree(sessionId, true);
+          event.ok = merge.ok;
+          event.conflict = merge.conflict;
+          event.output = merge.output;
+        }
       }
       const fresh = this.getConfig(sessionId);
       if (fresh?.worktree) {
@@ -4697,6 +5051,7 @@ ${err.message}`
     }
     this.clearQueueTimer(sessionId);
     this.clearAutoCompleteTimer(sessionId);
+    this.tokenEff.clearApplied(sessionId);
     this.worktreeWorked.delete(sessionId);
     this.autoCompleteInFlight.delete(sessionId);
     this.state.sessions = this.state.sessions.filter((s) => s.id !== sessionId);
@@ -5030,6 +5385,7 @@ ${err.message}`
     this.fs.stopAll();
   }
   spawnTerminal(config, terminal, mode, history) {
+    const te = terminal.kind === "claude" ? this.tokenEff.envFor(config) : { set: {}, drop: [] };
     const session = new PtySession(
       terminal,
       config.folder,
@@ -5044,11 +5400,13 @@ ${err.message}`
         // Snapshot lazily at write time — the store throttles to ~1 write/s.
         onOutput: (id) => this.scrollback.markDirty(id, () => session.tail(SCROLLBACK_MAX_BYTES))
       },
-      config.env ?? {}
+      { ...te.set, ...config.env ?? {} },
+      te.drop
     );
     if (history) session.seedHistory(history + SCROLLBACK_DIVIDER);
     this.ptys.set(terminal.id, session);
     session.spawn(mode);
+    if (terminal.kind === "claude") this.tokenEff.markApplied(config);
   }
   handleStatus(terminalId, status) {
     const win2 = this.getWin();
@@ -5147,7 +5505,8 @@ ${err.message}`
       lastOutputAt: pty2?.detector.lastOutput ?? 0,
       exitCode: pty2?.exitCode ?? null,
       statusSince,
-      watchdog: pty2?.alive ? this.watchdogAlert(terminal, status, statusSince) : null
+      watchdog: pty2?.alive ? this.watchdogAlert(terminal, status, statusSince) : null,
+      outputChars: pty2?.outputChars ?? 0
     };
   }
   /**
@@ -5187,6 +5546,817 @@ ${err.message}`
     this.getWin()?.webContents.send("session:changed");
   }
 }
+const OUTPUT_FILTER = String.raw`#!/usr/bin/env node
+// Maestro Token Efficiency — built-in output filter (auto-generated, do not edit).
+import { appendFileSync } from 'node:fs'
+
+function arg(name) {
+  const i = process.argv.indexOf(name)
+  return i >= 0 ? process.argv[i + 1] : null
+}
+const statsFile = arg('--stats')
+
+const HEAD_LINES = 120
+const TAIL_LINES = 80
+const KEEP_MAX = 60
+const KEEP_ERR = /\b(error|fail|failed|failure|exception|fatal|panic|traceback)\b/i
+const KEEP_WARN = /\b(warn|warning)\b/i
+
+function compress(raw) {
+  // Strip ANSI CSI/OSC sequences; keep only the final state of \r-redrawn lines.
+  const text = raw
+    .replace(/\x1b\[[0-9;?]*[ -\/]*[@-~]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+  const lines = []
+  for (const rawLine of text.split('\n')) {
+    const line = rawLine.includes('\r') ? rawLine.slice(rawLine.lastIndexOf('\r') + 1) : rawLine
+    lines.push(line.replace(/\s+$/, ''))
+  }
+  // Collapse runs of identical lines and squeeze blank-line runs.
+  const collapsed = []
+  let i = 0
+  while (i < lines.length) {
+    let j = i + 1
+    while (j < lines.length && lines[j] === lines[i]) j++
+    const n = j - i
+    if (lines[i].trim() === '') {
+      if (collapsed.length > 0 && collapsed[collapsed.length - 1] !== '') collapsed.push('')
+    } else if (n > 2) {
+      collapsed.push(lines[i] + '   [repeated ' + n + 'x]')
+    } else {
+      for (let k = 0; k < n; k++) collapsed.push(lines[i])
+    }
+    i = j
+  }
+  if (collapsed.length <= HEAD_LINES + TAIL_LINES + 20) return collapsed.join('\n')
+  const head = collapsed.slice(0, HEAD_LINES)
+  const tail = collapsed.slice(collapsed.length - TAIL_LINES)
+  const middle = collapsed.slice(HEAD_LINES, collapsed.length - TAIL_LINES)
+  // Errors outrank warnings for the keep budget — a wall of deprecation
+  // warnings must never crowd out the one failure line.
+  const errs = []
+  const warns = []
+  for (const line of middle) {
+    if (KEEP_ERR.test(line)) {
+      if (errs.length < KEEP_MAX) errs.push(line)
+    } else if (KEEP_WARN.test(line)) {
+      if (warns.length < KEEP_MAX) warns.push(line)
+    }
+  }
+  const kept = errs.concat(warns.slice(0, Math.max(0, KEEP_MAX - errs.length)))
+  const omitted = middle.length - kept.length
+  return head
+    .concat(
+      '',
+      '... ' + omitted + ' lines omitted by Maestro token filter' +
+        (kept.length ? ' (errors/warnings kept below)' : '') + ' ...',
+      ''
+    )
+    .concat(kept.length ? kept.concat('') : [])
+    .concat(tail)
+    .join('\n')
+}
+
+const chunks = []
+process.stdin.on('data', (c) => chunks.push(c))
+process.stdin.on('end', () => {
+  const raw = Buffer.concat(chunks).toString('utf8')
+  let out
+  try {
+    out = compress(raw)
+  } catch {
+    out = raw // never lose output to a filter bug
+  }
+  process.stdout.write(out)
+  if (statsFile) {
+    try {
+      appendFileSync(
+        statsFile,
+        JSON.stringify({ at: Date.now(), cwd: process.cwd(), kind: 'filter', orig: raw.length, out: out.length }) + '\n'
+      )
+    } catch {}
+  }
+})
+`;
+const BASH_COMPRESS = String.raw`#!/usr/bin/env node
+// Maestro Token Efficiency — Bash command compression hook (auto-generated, do not edit).
+import { appendFileSync, readFileSync } from 'node:fs'
+
+function arg(name) {
+  const i = process.argv.indexOf(name)
+  return i >= 0 ? process.argv[i + 1] : null
+}
+const statsFile = arg('--stats')
+const filter = arg('--filter')
+const rtk = arg('--rtk') === '1'
+
+let input
+try {
+  input = JSON.parse(readFileSync(0, 'utf8'))
+} catch {
+  process.exit(0)
+}
+if (!input || input.tool_name !== 'Bash' || !input.tool_input) process.exit(0)
+const command = String(input.tool_input.command || '').trim()
+if (!command) process.exit(0)
+
+// Already shaped/structured output — don't double-process.
+if (/[|<>]/.test(command)) process.exit(0)
+if (/\brtk\b/.test(command) || command.includes('output-filter.mjs')) process.exit(0)
+
+const NOISY = [
+  /^git (status|log|diff|show|fetch|pull|blame)\b/,
+  /^(npm|pnpm|yarn|bun) (install|ci|i)\b/,
+  /^(npm|pnpm|yarn|bun) (run )?(build|test|lint|typecheck|tsc)\b/,
+  /^npx (tsc|jest|vitest|eslint|playwright|mocha)\b/,
+  /^(cargo|go) (build|test|check|vet)\b/,
+  /^(mvn|gradle|gradlew|\.\/gradlew)\b/,
+  /^(pytest|tox|tsc|make)\b/,
+  /^dotnet (build|test|restore)\b/,
+  /^pip3? install\b/
+]
+if (!NOISY.some((re) => re.test(command))) process.exit(0)
+
+let updated = null
+let kind = null
+if (rtk && /^git /.test(command)) {
+  updated = 'rtk ' + command
+  kind = 'rtk'
+} else if (filter) {
+  updated =
+    'set -o pipefail; { ' + command + '; } 2>&1 | node "' + filter + '"' +
+    (statsFile ? ' --stats "' + statsFile + '"' : '')
+  kind = 'wrap'
+}
+if (!updated) process.exit(0)
+
+if (statsFile && kind === 'rtk') {
+  try {
+    appendFileSync(
+      statsFile,
+      JSON.stringify({ at: Date.now(), cwd: process.cwd(), kind: 'rtk' }) + '\n'
+    )
+  } catch {}
+}
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      permissionDecisionReason: 'Maestro token efficiency: noisy command output is compressed (' + kind + ')',
+      updatedInput: Object.assign({}, input.tool_input, { command: updated })
+    }
+  })
+)
+`;
+const READ_GUARD = String.raw`#!/usr/bin/env node
+// Maestro Token Efficiency — large-read guard hook (auto-generated, do not edit).
+import { appendFileSync, readFileSync, statSync } from 'node:fs'
+
+function arg(name) {
+  const i = process.argv.indexOf(name)
+  return i >= 0 ? process.argv[i + 1] : null
+}
+const statsFile = arg('--stats')
+const maxKB = Math.max(8, parseInt(arg('--max-kb') || '256', 10) || 256)
+
+let input
+try {
+  input = JSON.parse(readFileSync(0, 'utf8'))
+} catch {
+  process.exit(0)
+}
+if (!input || input.tool_name !== 'Read' || !input.tool_input) process.exit(0)
+const file = String(input.tool_input.file_path || '')
+if (!file) process.exit(0)
+// A targeted slice is deliberate — allow it.
+if (input.tool_input.offset || input.tool_input.limit) process.exit(0)
+
+const base = (file.split(/[\\/]/).pop() || '').toLowerCase()
+const norm = file.replace(/\\/g, '/').toLowerCase()
+const LOCKFILES = [
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'npm-shrinkwrap.json', 'bun.lock',
+  'cargo.lock', 'poetry.lock', 'pipfile.lock', 'uv.lock', 'composer.lock', 'gemfile.lock',
+  'go.sum', 'flake.lock'
+]
+const sink =
+  LOCKFILES.indexOf(base) >= 0 ||
+  /\/(node_modules|dist|build|out|target|\.venv|__pycache__|coverage)\//.test(norm) ||
+  /\.(log|jsonl|map)$/.test(base) ||
+  base.includes('.min.')
+if (!sink) process.exit(0)
+
+let size = 0
+try {
+  size = statSync(file).size
+} catch {
+  process.exit(0)
+}
+if (size <= maxKB * 1024) process.exit(0)
+
+if (statsFile) {
+  try {
+    appendFileSync(
+      statsFile,
+      JSON.stringify({ at: Date.now(), cwd: process.cwd(), kind: 'blocked-read', bytes: size }) + '\n'
+    )
+  } catch {}
+}
+const sizeKB = Math.round(size / 1024)
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason:
+        'Maestro token guard: "' + file + '" is ' + sizeKB + ' KB of low-signal content ' +
+        '(lockfile/log/build artifact). Reading it whole would waste a large amount of context. ' +
+        'Use Grep to find the specific entry you need, or Read with offset/limit for a targeted slice.'
+    }
+  })
+)
+`;
+const SESSION_CONTEXT = String.raw`#!/usr/bin/env node
+// Maestro Token Efficiency — repo-map session context hook (auto-generated, do not edit).
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+try {
+  const map = join(process.cwd(), '.claude', 'maestro-repo-map.md')
+  if (existsSync(map)) {
+    const text = readFileSync(map, 'utf8').trim()
+    if (text) {
+      process.stdout.write(
+        'Repo symbol map (generated by Maestro). Use it to jump straight to the right file/symbol ' +
+          'with Grep or a targeted Read instead of reading whole files:\n\n' + text + '\n'
+      )
+    }
+  }
+} catch {}
+`;
+const SCRIPT_FILES = {
+  outputFilter: "output-filter.mjs",
+  bashCompress: "bash-compress.mjs",
+  readGuard: "read-guard.mjs",
+  sessionContext: "session-context.mjs"
+};
+function ensureScripts(scriptsDir) {
+  fs.mkdirSync(scriptsDir, { recursive: true });
+  const sources = {
+    outputFilter: OUTPUT_FILTER,
+    bashCompress: BASH_COMPRESS,
+    readGuard: READ_GUARD,
+    sessionContext: SESSION_CONTEXT
+  };
+  const out = {};
+  for (const key of Object.keys(SCRIPT_FILES)) {
+    const path$1 = path.join(scriptsDir, SCRIPT_FILES[key]);
+    fs.writeFileSync(path$1, sources[key], "utf8");
+    out[key] = path$1;
+  }
+  return out;
+}
+const IS_WIN = process.platform === "win32";
+const REPO_MAP_REL = ".claude/maestro-repo-map.md";
+const SETTINGS_REL = ".claude/settings.local.json";
+const HEAD_POLL_MS = 6e4;
+const REPO_MAP_MAX_BYTES = 24 * 1024;
+const MAX_SYMBOLS_PER_FILE = 15;
+const MAP_FILE_MAX_BYTES = 512 * 1024;
+const STATS_ROTATE_BYTES = 2 * 1024 * 1024;
+const BLOCKED_READ_MAX_TOKENS = 5e4;
+const EXTRACTORS = [
+  {
+    exts: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    patterns: [
+      /^export\s+(?:default\s+)?(?:abstract\s+)?(?:async\s+)?(?:function\*?|class|interface|type|enum|const|let)\s+([A-Za-z_$][\w$]*)/gm,
+      /^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)/gm,
+      /^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/gm
+    ]
+  },
+  {
+    exts: [".py"],
+    patterns: [/^(?:async\s+)?def\s+(\w+)/gm, /^class\s+(\w+)/gm]
+  },
+  {
+    exts: [".java", ".cs", ".kt"],
+    patterns: [
+      /^\s*(?:public|protected|internal)?\s*(?:static\s+|final\s+|sealed\s+|abstract\s+|data\s+)*(?:class|interface|enum|record)\s+(\w+)/gm,
+      /^\s*(?:public|protected)\s+(?:static\s+)?[\w<>[\],.\s?]+?\s+(\w+)\s*\(/gm
+    ]
+  },
+  {
+    exts: [".go"],
+    patterns: [/^func\s+(?:\([^)]*\)\s+)?(\w+)/gm, /^type\s+(\w+)/gm]
+  },
+  {
+    exts: [".rs"],
+    patterns: [
+      /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)/gm,
+      /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:struct|enum|trait)\s+(\w+)/gm
+    ]
+  },
+  {
+    exts: [".rb"],
+    patterns: [/^\s*(?:def|class|module)\s+([\w.?!]+)/gm]
+  },
+  {
+    exts: [".php"],
+    patterns: [/function\s+(\w+)/gm, /^\s*(?:abstract\s+|final\s+)?class\s+(\w+)/gm]
+  }
+];
+const EXT_TO_PATTERNS = /* @__PURE__ */ new Map();
+for (const group of EXTRACTORS) for (const ext of group.exts) EXT_TO_PATTERNS.set(ext, group.patterns);
+function which(name) {
+  const out = IS_WIN ? child_process.spawnSync("where.exe", [name], { encoding: "utf8" }) : child_process.spawnSync("which", [name], { encoding: "utf8" });
+  if (out.status !== 0 || !out.stdout) return null;
+  return out.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean)[0] ?? null;
+}
+function readJson(file) {
+  if (!fs.existsSync(file)) return {};
+  try {
+    const v = JSON.parse(fs.readFileSync(file, "utf8"));
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+function writeJsonAtomic(file, value) {
+  const tmp = file + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, file);
+}
+function defined(o) {
+  const out = {};
+  if (!o) return out;
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function underFolder(path2, folder) {
+  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+  const a = norm(path2);
+  const b = norm(folder);
+  return a === b || a.startsWith(b + "/");
+}
+function gitHead(folder) {
+  return new Promise((resolve) => {
+    child_process.execFile(
+      "git",
+      ["rev-parse", "HEAD"],
+      { cwd: folder, windowsHide: true },
+      (err, stdout) => resolve(err ? null : stdout.trim() || null)
+    );
+  });
+}
+function ensureMapExcluded(folder) {
+  const file = excludeFilePathSync(folder);
+  if (!file) return;
+  try {
+    const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    const lines = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    if (lines.has(REPO_MAP_REL)) return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const suffix = current.length && !current.endsWith("\n") ? "\n" : "";
+    fs.writeFileSync(file, current + suffix + REPO_MAP_REL + "\n", "utf8");
+  } catch {
+  }
+}
+class TokenEfficiencyService {
+  constructor(persistence2) {
+    this.persistence = persistence2;
+    try {
+      fs.mkdirSync(this.baseDir, { recursive: true });
+      this.scripts = ensureScripts(path.join(this.baseDir, "scripts"));
+    } catch (err) {
+      console.error("Token efficiency: failed to write hook scripts", err);
+      this.scripts = null;
+    }
+  }
+  baseDir = path.join(electron.app.getPath("userData"), "token-efficiency");
+  statsFile = path.join(this.baseDir, "stats.jsonl");
+  scripts = null;
+  rtkPath;
+  // undefined = not probed yet
+  nodePath;
+  /** Effective config each session's claude was last spawned with. */
+  applied = /* @__PURE__ */ new Map();
+  /** Repo-map facts per repo folder (the folder the map was generated in). */
+  repoMaps = /* @__PURE__ */ new Map();
+  /** Last seen HEAD per session folder, for change-driven map refresh. */
+  lastHead = /* @__PURE__ */ new Map();
+  /** Folders with a map generation in flight (dedupe). */
+  generating = /* @__PURE__ */ new Set();
+  statsCache = null;
+  pollTimer = null;
+  /** Begin the git-change poll that keeps repo maps fresh. Idempotent. */
+  start() {
+    if (this.pollTimer) return;
+    this.pollTimer = setInterval(() => void this.pollGitChanges(), HEAD_POLL_MS);
+  }
+  dispose() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = null;
+  }
+  // ---------- config resolution ----------
+  /** The override key a session's repo resolves to (worktree tasks → base repo). */
+  repoKeyOf(config) {
+    return config.worktree?.baseFolder ?? config.folder;
+  }
+  /** Global ⊕ repo override ⊕ session override. */
+  resolveEffective(config) {
+    const settings = this.persistence.state.settings;
+    const repoOv = settings.tokenEfficiencyRepoOverrides[this.repoKeyOf(config)];
+    return {
+      ...settings.tokenEfficiency,
+      ...defined(repoOv),
+      ...defined(config.tokenEfficiency)
+    };
+  }
+  /** Probe for external tools (cached; `refresh` re-probes). */
+  detectTools(refresh = false) {
+    if (refresh || this.rtkPath === void 0) this.rtkPath = which("rtk");
+    if (refresh || this.nodePath === void 0) this.nodePath = which("node");
+    return {
+      rtk: { found: this.rtkPath !== null, path: this.rtkPath },
+      nodeFound: this.nodePath !== null
+    };
+  }
+  // ---------- materialization (runs before claude spawns) ----------
+  /**
+   * Materialize the session's effective config into its repo: write/remove our
+   * managed hook entries and kick a repo-map (re)generation. Idempotent and
+   * reversible — with the toolkit off every trace is removed again. Never
+   * throws (a failure must not block a session launch).
+   */
+  apply(config) {
+    if (!fs.existsSync(config.folder)) return;
+    const effective = this.resolveEffective(config);
+    try {
+      this.applyHooks(config.folder, effective);
+    } catch (err) {
+      console.error("Token efficiency: applying hooks failed for", config.folder, err);
+    }
+    if (effective.enabled && effective.codeGraph) {
+      void this.ensureRepoMap(config.folder, effective, false);
+    } else {
+      this.removeRepoMap(config.folder);
+    }
+  }
+  /** Env overlay for a claude spawn: variables to set and to drop. */
+  envFor(config) {
+    const effective = this.resolveEffective(config);
+    const set = {};
+    const drop = [];
+    if (!effective.enabled) return { set, drop };
+    if (effective.truncationHooks) {
+      set.BASH_MAX_OUTPUT_LENGTH = String(effective.bashMaxOutputChars);
+      set.MAX_MCP_OUTPUT_TOKENS = String(effective.mcpMaxOutputTokens);
+    }
+    if (effective.promptCachingHints) drop.push("DISABLE_PROMPT_CACHING");
+    return { set, drop };
+  }
+  /** Record what a session's claude was actually spawned with (for drift). */
+  markApplied(config) {
+    this.applied.set(config.id, this.resolveEffective(config));
+  }
+  clearApplied(sessionId) {
+    this.applied.delete(sessionId);
+  }
+  /**
+   * Rewrite our managed hook entries in the repo's settings.local.json. Ours
+   * are recognized by the scripts-dir path inside the command string; foreign
+   * hooks are preserved untouched (same managed-namespace contract as
+   * ContextProfile).
+   */
+  applyHooks(folder, effective) {
+    const file = path.join(folder, SETTINGS_REL);
+    const existed = fs.existsSync(file);
+    const settings = readJson(file);
+    const marker = this.scripts ? path.dirname(this.scripts.outputFilter) : null;
+    const hooks = settings.hooks && typeof settings.hooks === "object" ? { ...settings.hooks } : {};
+    const isOurs = (entry) => {
+      const hookList = entry?.hooks;
+      if (!Array.isArray(hookList) || !marker) return false;
+      return hookList.some((h) => {
+        const cmd = h?.command;
+        return typeof cmd === "string" && cmd.includes(marker);
+      });
+    };
+    for (const event of ["PreToolUse", "SessionStart"]) {
+      const entries = Array.isArray(hooks[event]) ? hooks[event].filter((e) => !isOurs(e)) : [];
+      if (entries.length > 0) hooks[event] = entries;
+      else delete hooks[event];
+    }
+    const active = effective.enabled && this.scripts && this.detectTools().nodeFound;
+    if (active && this.scripts) {
+      const node = "node";
+      const q = (p) => '"' + p + '"';
+      const pre = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+      if (effective.outputCompression) {
+        const rtkFlag = this.detectTools().rtk.found ? "1" : "0";
+        pre.push({
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: node + " " + q(this.scripts.bashCompress) + " --stats " + q(this.statsFile) + " --filter " + q(this.scripts.outputFilter) + " --rtk " + rtkFlag,
+              timeout: 10
+            }
+          ]
+        });
+      }
+      if (effective.truncationHooks) {
+        pre.push({
+          matcher: "Read",
+          hooks: [
+            {
+              type: "command",
+              command: node + " " + q(this.scripts.readGuard) + " --stats " + q(this.statsFile) + " --max-kb " + effective.largeReadMaxKB,
+              timeout: 10
+            }
+          ]
+        });
+      }
+      if (pre.length > 0) hooks.PreToolUse = pre;
+      if (effective.codeGraph) {
+        const start = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+        start.push({
+          hooks: [
+            { type: "command", command: node + " " + q(this.scripts.sessionContext), timeout: 10 }
+          ]
+        });
+        hooks.SessionStart = start;
+      }
+    }
+    if (Object.keys(hooks).length > 0) settings.hooks = hooks;
+    else delete settings.hooks;
+    if (!existed && Object.keys(settings).length === 0) return;
+    fs.mkdirSync(path.join(folder, ".claude"), { recursive: true });
+    writeJsonAtomic(file, settings);
+  }
+  // ---------- repo map (code graph) ----------
+  /**
+   * (Re)generate a session folder's repo map when missing or its HEAD moved
+   * (`force` regenerates regardless). The map is written into the repo for the
+   * SessionStart hook to pick up, and kept out of git via info/exclude.
+   */
+  async ensureRepoMap(folder, effective, force) {
+    if (this.generating.has(folder)) return this.repoMaps.get(folder) ?? null;
+    const mapPath = path.join(folder, REPO_MAP_REL);
+    const head = await gitHead(folder);
+    const known = this.repoMaps.get(folder);
+    if (!force && known && fs.existsSync(mapPath) && head && this.lastHead.get(folder) === head) {
+      return known;
+    }
+    this.generating.add(folder);
+    try {
+      const info = this.generateRepoMap(folder, effective.repoMapMaxFiles);
+      this.repoMaps.set(folder, info);
+      if (head) this.lastHead.set(folder, head);
+      ensureMapExcluded(folder);
+      return info;
+    } catch (err) {
+      console.error("Token efficiency: repo map generation failed for", folder, err);
+      return null;
+    } finally {
+      this.generating.delete(folder);
+    }
+  }
+  /** Delete a folder's generated map (used when the code graph is toggled off). */
+  removeRepoMap(folder) {
+    this.repoMaps.delete(folder);
+    this.lastHead.delete(folder);
+    try {
+      fs.rmSync(path.join(folder, REPO_MAP_REL), { force: true });
+    } catch {
+    }
+  }
+  /**
+   * Walk the repo and produce a compact aider-style "path: symbols" map.
+   * Regex extraction by design: dependency-free (no native tree-sitter) and
+   * fast enough to run synchronously on spawn (caps bound the work).
+   */
+  generateRepoMap(folder, maxFiles) {
+    const ignore = /* @__PURE__ */ new Set([
+      ...this.persistence.state.settings.ignoreNames,
+      ".git",
+      "vendor",
+      "coverage"
+    ]);
+    const files = [];
+    const walk = (dir, depth) => {
+      if (depth > 12 || files.length >= maxFiles) return;
+      let entries;
+      try {
+        entries = fs.readdirSync(dir);
+      } catch {
+        return;
+      }
+      const subdirs = [];
+      for (const entry of entries) {
+        if (files.length >= maxFiles) return;
+        if (ignore.has(entry) || entry.startsWith(".")) continue;
+        const path$1 = path.join(dir, entry);
+        let stat;
+        try {
+          stat = fs.statSync(path$1);
+        } catch {
+          continue;
+        }
+        if (stat.isDirectory()) {
+          subdirs.push(path$1);
+        } else if (stat.size <= MAP_FILE_MAX_BYTES) {
+          const ext = entry.slice(entry.lastIndexOf(".")).toLowerCase();
+          if (EXT_TO_PATTERNS.has(ext)) files.push(path$1);
+        }
+      }
+      for (const sub of subdirs) walk(sub, depth + 1);
+    };
+    walk(folder, 0);
+    const lines = [];
+    let totalSymbols = 0;
+    let bytes = 0;
+    for (const path$1 of files) {
+      let text;
+      try {
+        text = fs.readFileSync(path$1, "utf8");
+      } catch {
+        continue;
+      }
+      const ext = path$1.slice(path$1.lastIndexOf(".")).toLowerCase();
+      const patterns = EXT_TO_PATTERNS.get(ext) ?? [];
+      const symbols = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        let m;
+        while (m = pattern.exec(text)) {
+          const name = m[1];
+          if (name && !seen.has(name)) {
+            seen.add(name);
+            symbols.push(name);
+          }
+          if (seen.size > MAX_SYMBOLS_PER_FILE * 2) break;
+        }
+      }
+      if (symbols.length === 0) continue;
+      const shown = symbols.slice(0, MAX_SYMBOLS_PER_FILE);
+      const rel = path.relative(folder, path$1).replace(/\\/g, "/");
+      const line = rel + ": " + shown.join(", ") + (symbols.length > shown.length ? ", …" : "");
+      if (bytes + line.length > REPO_MAP_MAX_BYTES) break;
+      lines.push(line);
+      bytes += line.length + 1;
+      totalSymbols += shown.length;
+    }
+    const content = lines.join("\n") + "\n";
+    const mapPath = path.join(folder, REPO_MAP_REL);
+    fs.mkdirSync(path.dirname(mapPath), { recursive: true });
+    fs.writeFileSync(mapPath, content, "utf8");
+    return { generatedAt: Date.now(), files: lines.length, symbols: totalSymbols, bytes: content.length };
+  }
+  /** Refresh maps for sessions whose repo HEAD moved since the last poll. */
+  async pollGitChanges() {
+    for (const config of this.persistence.state.sessions) {
+      const effective = this.resolveEffective(config);
+      if (!effective.enabled || !effective.codeGraph) continue;
+      if (!fs.existsSync(config.folder)) continue;
+      const head = await gitHead(config.folder);
+      if (!head) continue;
+      const prev = this.lastHead.get(config.folder);
+      if (prev !== head) await this.ensureRepoMap(config.folder, effective, true);
+    }
+  }
+  // ---------- savings stats (logged by the hook scripts) ----------
+  loadStats() {
+    let stat;
+    try {
+      stat = fs.statSync(this.statsFile);
+    } catch {
+      return [];
+    }
+    if (this.statsCache && this.statsCache.mtimeMs === stat.mtimeMs && this.statsCache.size === stat.size) {
+      return this.statsCache.entries;
+    }
+    let raw;
+    try {
+      raw = fs.readFileSync(this.statsFile, "utf8");
+    } catch {
+      return [];
+    }
+    if (raw.length > STATS_ROTATE_BYTES) {
+      const tail2 = raw.slice(-1048576);
+      raw = tail2.slice(tail2.indexOf("\n") + 1);
+      try {
+        fs.writeFileSync(this.statsFile, raw, "utf8");
+      } catch {
+      }
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e && typeof e.cwd === "string" && typeof e.kind === "string") entries.push(e);
+      } catch {
+      }
+    }
+    try {
+      const fresh = fs.statSync(this.statsFile);
+      this.statsCache = { mtimeMs: fresh.mtimeMs, size: fresh.size, entries };
+    } catch {
+      this.statsCache = null;
+    }
+    return entries;
+  }
+  /** Savings attributed to one folder ('' aggregates everything). */
+  savingsFor(folder) {
+    const savings = {
+      savedTokens: 0,
+      rtkRewrites: 0,
+      filteredCommands: 0,
+      blockedReads: 0
+    };
+    for (const e of this.loadStats()) {
+      if (folder && !underFolder(e.cwd, folder)) continue;
+      if (e.kind === "filter") {
+        savings.filteredCommands++;
+        const saved = Math.max(0, (e.orig ?? 0) - (e.out ?? 0));
+        savings.savedTokens += Math.round(saved / 4);
+      } else if (e.kind === "rtk") {
+        savings.rtkRewrites++;
+      } else if (e.kind === "blocked-read") {
+        savings.blockedReads++;
+        savings.savedTokens += Math.min(Math.round((e.bytes ?? 0) / 4), BLOCKED_READ_MAX_TOKENS);
+      }
+    }
+    return savings;
+  }
+  // ---------- status & settings mutation (IPC surface) ----------
+  status(sessionId) {
+    const config = this.persistence.state.sessions.find((s) => s.id === sessionId);
+    if (!config) return null;
+    const settings = this.persistence.state.settings;
+    const effective = this.resolveEffective(config);
+    const applied = this.applied.get(sessionId) ?? null;
+    const tools = this.detectTools();
+    return {
+      effective,
+      repoOverride: settings.tokenEfficiencyRepoOverrides[this.repoKeyOf(config)] ?? null,
+      sessionOverride: config.tokenEfficiency ?? null,
+      rtk: tools.rtk,
+      nodeFound: tools.nodeFound,
+      applied,
+      pendingRestart: applied !== null && JSON.stringify(applied) !== JSON.stringify(effective),
+      repoMap: this.repoMaps.get(config.folder) ?? null,
+      savings: this.savingsFor(config.folder)
+    };
+  }
+  /** Persist the global config and re-materialize every session's repo. */
+  saveGlobal(config) {
+    this.persistence.state.settings.tokenEfficiency = config;
+    this.persistence.scheduleSave();
+    this.reapplyAll();
+  }
+  /** Set/clear the override for a session's repo, then re-materialize that repo. */
+  setRepoOverride(sessionId, override) {
+    const config = this.persistence.state.sessions.find((s) => s.id === sessionId);
+    if (!config) return;
+    const key = this.repoKeyOf(config);
+    const overrides = this.persistence.state.settings.tokenEfficiencyRepoOverrides;
+    const cleaned = defined(override);
+    if (override && Object.keys(cleaned).length > 0) overrides[key] = cleaned;
+    else delete overrides[key];
+    this.persistence.scheduleSave();
+    for (const s of this.persistence.state.sessions) {
+      if (this.repoKeyOf(s) === key && s.terminals.some((t) => t.kind === "claude")) this.apply(s);
+    }
+  }
+  /** Set/clear one session's own override, then re-materialize it. */
+  setSessionOverride(sessionId, override) {
+    const config = this.persistence.state.sessions.find((s) => s.id === sessionId);
+    if (!config) return;
+    const cleaned = defined(override);
+    config.tokenEfficiency = override && Object.keys(cleaned).length > 0 ? cleaned : null;
+    this.persistence.scheduleSave();
+    if (config.terminals.some((t) => t.kind === "claude")) this.apply(config);
+  }
+  /** Regenerate a session's repo map right now. */
+  async refreshRepoMap(sessionId) {
+    const config = this.persistence.state.sessions.find((s) => s.id === sessionId);
+    if (!config || !fs.existsSync(config.folder)) return null;
+    const effective = this.resolveEffective(config);
+    if (!effective.enabled || !effective.codeGraph) return null;
+    return this.ensureRepoMap(config.folder, effective, true);
+  }
+  /** Re-materialize every session that hosts a claude terminal. */
+  reapplyAll() {
+    for (const config of this.persistence.state.sessions) {
+      if (config.terminals.some((t) => t.kind === "claude")) this.apply(config);
+    }
+  }
+}
 let win = null;
 const getWin = () => win;
 const persistence = new Persistence();
@@ -5253,7 +6423,8 @@ if (!gotLock) {
       (sessionId, events) => getWin()?.webContents.send("fs:events", sessionId, events),
       () => persistence.state.settings.ignoreNames
     );
-    const sessions = new SessionManager(persistence, fsService, getWin);
+    const tokenEff = new TokenEfficiencyService(persistence);
+    const sessions = new SessionManager(persistence, fsService, tokenEff, getWin);
     const sentinels = new SentinelService(persistence, getWin);
     const features = new FeatureService(persistence, sessions);
     const autoExpand = new AutoExpandService(persistence, features, getWin);
@@ -5268,6 +6439,7 @@ if (!gotLock) {
       autoExpand,
       conductor,
       factory,
+      tokenEff,
       getWin
     );
     createWindow();
@@ -5275,10 +6447,12 @@ if (!gotLock) {
     sessions.startWatchdog();
     sentinels.start();
     autoExpand.start();
+    tokenEff.start();
     electron.app.on("activate", () => {
       if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
     });
     electron.app.on("before-quit", () => {
+      tokenEff.dispose();
       factory.dispose();
       conductor.dispose();
       autoExpand.dispose();