claude-maestro 0.1.17 → 0.1.19

package/out/main/index.js

@@ -1,10 +1,10 @@
 "use strict";
 const electron = require("electron");
 const path = require("path");
-const crypto = require("crypto");
 const fs = require("fs");
-const child_process = require("child_process");
 const os = require("os");
+const crypto = require("crypto");
+const child_process = require("child_process");
 const pty = require("node-pty");
 const chokidar = require("chokidar");
 const promises = require("fs/promises");
@@ -25,6 +25,278 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 const pty__namespace = /* @__PURE__ */ _interopNamespaceDefault(pty);
+const USER_AGENTS_DIR = path.join(os.homedir(), ".claude", "agents");
+const WATCH_DEBOUNCE_MS = 400;
+class AgentRegistryService {
+  constructor(persistence2, getWin2) {
+    this.persistence = persistence2;
+    this.getWin = getWin2;
+  }
+  watchers = /* @__PURE__ */ new Map();
+  debounce = null;
+  /** Paths the renderer may read/reveal — everything the last snapshot listed. */
+  knownPaths = /* @__PURE__ */ new Set();
+  disposed = false;
+  dispose() {
+    this.disposed = true;
+    if (this.debounce) clearTimeout(this.debounce);
+    for (const w of this.watchers.values()) w.close();
+    this.watchers.clear();
+  }
+  registryPath() {
+    return this.persistence.state.settings.agentRegistryPath.trim();
+  }
+  /** Unique session repo folders (project-local agents may live in each). */
+  projectDirs() {
+    return [...new Set(this.persistence.state.sessions.map((s) => s.folder).filter(Boolean))];
+  }
+  /** Build a fresh snapshot and re-arm the watchers for the dirs it covers. */
+  snapshot() {
+    const registryPath = this.registryPath();
+    const registry = readRegistry(registryPath);
+    const agents = scanAgentsDir(USER_AGENTS_DIR, "user", null);
+    for (const dir of this.projectDirs()) {
+      agents.push(...scanAgentsDir(path.join(dir, ".claude", "agents"), "project", dir));
+    }
+    agents.sort((a, b) => a.name.localeCompare(b.name));
+    const byName = /* @__PURE__ */ new Map();
+    for (const e of registry.entries) byName.set(e.name.toLowerCase(), e);
+    const matched = /* @__PURE__ */ new Set();
+    for (const agent of agents) {
+      const entry = byName.get(agent.name.toLowerCase());
+      if (entry) {
+        agent.registry = entry;
+        matched.add(entry);
+      }
+    }
+    const missing = registry.entries.filter((e) => e.fileMissing && !matched.has(e));
+    const registryDir = path.dirname(registryPath);
+    const snapshot = {
+      agents,
+      missing,
+      registryPath,
+      registryError: registry.error,
+      registryVersion: registry.version,
+      registryUpdated: registry.updated,
+      factoryRunning: fs.existsSync(path.join(registryDir, ".factory.lock"))
+    };
+    this.knownPaths = /* @__PURE__ */ new Set();
+    for (const a of agents) this.knownPaths.add(a.filePath);
+    for (const e of registry.entries) if (e.filePath) this.knownPaths.add(e.filePath);
+    this.armWatchers(registryDir);
+    return snapshot;
+  }
+  /** Re-snapshot now and push it to the renderer (manual refresh / settings change). */
+  refresh() {
+    const snapshot = this.snapshot();
+    this.getWin()?.webContents.send("agents:changed", snapshot);
+    return snapshot;
+  }
+  /** Read an agent file the last snapshot listed (null when unknown/unreadable). */
+  readAgentFile(filePath) {
+    if (this.knownPaths.size === 0) this.snapshot();
+    if (!this.knownPaths.has(filePath)) return null;
+    try {
+      return fs.readFileSync(filePath, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  /** Reveal an agent file from the last snapshot in the OS file manager. */
+  revealAgentFile(filePath) {
+    if (this.knownPaths.has(filePath) && fs.existsSync(filePath)) electron.shell.showItemInFolder(filePath);
+  }
+  // ---------- file watching ----------
+  /**
+   * Watch the user agents dir, every project agents dir and the registry dir
+   * (the latter covers registry.json writes AND .factory.lock create/delete).
+   * Idempotent: only the delta of dirs is (un)watched.
+   */
+  armWatchers(registryDir) {
+    if (this.disposed) return;
+    const wanted = /* @__PURE__ */ new Set();
+    if (fs.existsSync(USER_AGENTS_DIR)) wanted.add(USER_AGENTS_DIR);
+    if (fs.existsSync(registryDir)) wanted.add(registryDir);
+    for (const dir of this.projectDirs()) {
+      const agentsDir = path.join(dir, ".claude", "agents");
+      if (fs.existsSync(agentsDir)) wanted.add(agentsDir);
+    }
+    for (const [dir, watcher] of this.watchers) {
+      if (!wanted.has(dir)) {
+        watcher.close();
+        this.watchers.delete(dir);
+      }
+    }
+    for (const dir of wanted) {
+      if (this.watchers.has(dir)) continue;
+      try {
+        const watcher = fs.watch(dir, () => this.scheduleRefresh());
+        watcher.on("error", () => {
+          watcher.close();
+          this.watchers.delete(dir);
+        });
+        this.watchers.set(dir, watcher);
+      } catch {
+      }
+    }
+  }
+  scheduleRefresh() {
+    if (this.disposed) return;
+    if (this.debounce) clearTimeout(this.debounce);
+    this.debounce = setTimeout(() => {
+      this.debounce = null;
+      this.refresh();
+    }, WATCH_DEBOUNCE_MS);
+  }
+}
+function parseAgentFrontmatter(md) {
+  const m = /^?---\r?\n([\s\S]*?)\r?\n---/.exec(md);
+  if (!m) return {};
+  const out = {};
+  const lines = m[1].split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(lines[i]);
+    if (!kv) continue;
+    const key = kv[1];
+    let value = kv[2].trim();
+    if (value === "|" || value === ">" || value === "|-" || value === ">-") {
+      const block = [];
+      while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1])) {
+        block.push(lines[++i].trim());
+      }
+      value = block.join(" ").trim();
+    } else if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "name") out.name = value;
+    else if (key === "description") out.description = value;
+    else if (key === "model") out.model = value;
+  }
+  return out;
+}
+function scanAgentsDir(dir, scope, projectDir) {
+  if (!fs.existsSync(dir)) return [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = path.join(dir, entry);
+    const base = entry.replace(/\.md$/, "");
+    let fm = {};
+    try {
+      fm = parseAgentFrontmatter(fs.readFileSync(filePath, "utf8"));
+    } catch {
+    }
+    out.push({
+      name: fm.name?.trim() || base,
+      description: fm.description ?? "",
+      model: fm.model?.trim() || null,
+      scope,
+      projectDir,
+      filePath,
+      registry: null
+    });
+  }
+  return out;
+}
+function readRegistry(registryPath) {
+  if (!registryPath) return { entries: [], error: "No registry path configured.", version: null, updated: null };
+  if (!fs.existsSync(registryPath)) {
+    return { entries: [], error: `Registry not found: ${registryPath}`, version: null, updated: null };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(registryPath, "utf8"));
+  } catch (err) {
+    return {
+      entries: [],
+      error: `Registry unreadable: ${err.message || String(err)}`,
+      version: null,
+      updated: null
+    };
+  }
+  const root2 = parsed ?? {};
+  const meta = root2._meta ?? {};
+  const rawAgents = Array.isArray(root2.agents) ? root2.agents : [];
+  const entries = [];
+  for (const raw of rawAgents) {
+    if (!raw || typeof raw !== "object") continue;
+    const entry = parseEntry(raw, registryPath);
+    if (entry) entries.push(entry);
+  }
+  return {
+    entries,
+    error: null,
+    version: typeof meta.version === "string" ? meta.version : null,
+    updated: typeof meta.last_updated === "string" ? meta.last_updated : null
+  };
+}
+function parseEntry(r, registryPath) {
+  const name = String(r.name ?? "").trim();
+  if (!name) return null;
+  const filePath = resolveEntryPath(r.file_path, registryPath);
+  return {
+    name,
+    filePath,
+    type: optString(r.type),
+    status: optString(r.status),
+    archetype: optString(r.archetype),
+    model: optString(r.model),
+    scope: optString(r.scope),
+    description: String(r.description ?? "").trim(),
+    topics: toStringArray$1(r.topics),
+    keywords: toStringArray$1(r.keywords),
+    relatedAgents: toStringArray$1(r.related_agents),
+    confluencePages: [
+      .../* @__PURE__ */ new Set([...toStringArray$1(r.confluence_source), ...toStringArray$1(r.confluence_pages)])
+    ],
+    sourceVerified: r.source_verified === true,
+    githubRepos: toGithubRepos(r.github_repos),
+    githubVerified: r.github_verified === true,
+    knowledgeNotes: toStringArray$1(r.knowledge_note),
+    factoryMade: typeof r.factory_made === "boolean" ? r.factory_made : null,
+    created: optString(r.created),
+    lastUpdated: optString(r.last_updated),
+    fileMissing: filePath !== null && !fs.existsSync(filePath)
+  };
+}
+function resolveEntryPath(raw, registryPath) {
+  const fp = String(raw ?? "").trim();
+  if (!fp) return null;
+  if (path.isAbsolute(fp)) return fp;
+  const registryDir = path.dirname(registryPath);
+  const fromRepoRoot = path.resolve(path.dirname(registryDir), fp);
+  if (fs.existsSync(fromRepoRoot)) return fromRepoRoot;
+  const fromRegistryDir = path.resolve(registryDir, fp);
+  return fs.existsSync(fromRegistryDir) ? fromRegistryDir : fromRepoRoot;
+}
+function optString(v) {
+  if (typeof v !== "string") return null;
+  const s = v.trim();
+  return s || null;
+}
+function toStringArray$1(v) {
+  if (typeof v === "string") return v.trim() ? [v.trim()] : [];
+  if (!Array.isArray(v)) return [];
+  return [...new Set(v.map((x) => String(x).trim()).filter(Boolean))];
+}
+function toGithubRepos(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const raw of v) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    const repo = String(r.repo ?? "").trim();
+    if (!repo) continue;
+    out.push({ repo, ref: optString(r.ref), paths: toStringArray$1(r.paths) });
+  }
+  return out;
+}
 function git(cwd, args, env) {
   return new Promise((resolve2, reject) => {
     child_process.execFile(
@@ -70,6 +342,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 +992,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 +1016,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 +1040,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 +1069,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 +1092,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 +1124,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 +1206,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();
@@ -1005,7 +1307,7 @@ function extractJson(text) {
     return null;
   }
 }
-const TICK_MS$1 = 3e4;
+const TICK_MS$2 = 3e4;
 const AGENT_TIMEOUT_MS = 5 * 6e4;
 const MAX_RUNS_PER_SESSION$1 = 30;
 const IDEA_COUNT = 4;
@@ -1034,7 +1336,7 @@ class AutoExpandService {
   runs = /* @__PURE__ */ new Map();
   start() {
     if (this.timer) return;
-    this.timer = setInterval(() => this.tick(), TICK_MS$1);
+    this.timer = setInterval(() => this.tick(), TICK_MS$2);
     this.tick();
   }
   dispose() {
@@ -1401,6 +1703,14 @@ class ConductorService {
   /** The in-flight planner child, so dispose()/a new turn can cancel it. */
   inFlight = null;
   busy = false;
+  /** Observer fired after each completed (non-error) turn — wired to the Factory's
+   *  self-growth detector in index.ts. A post-construction setter avoids a
+   *  constructor cycle (conductor is built before the factory). */
+  turnCompleteCb = null;
+  /** Register an observer notified after each successful turn (e.g. the Factory). */
+  onTurnComplete(cb) {
+    this.turnCompleteCb = cb;
+  }
   list() {
     return this.messages;
   }
@@ -1426,17 +1736,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 +1767,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,
@@ -1470,13 +1788,29 @@ class ConductorService {
       this.inFlight = null;
       this.busy = false;
       this.persistAndBroadcast();
+      if (!assistantMsg.error) {
+        try {
+          this.turnCompleteCb?.(this.messages);
+        } catch {
+        }
+      }
     }
   }
-  /** 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 +1833,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 +1876,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 +1892,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 +1919,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 +2068,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 +2096,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 +2324,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;
@@ -1961,11 +2387,21 @@ function scanAgents() {
   }
   return out.sort((a, b) => a.name.localeCompare(b.name));
 }
-const EMPTY = { artifacts: [], topics: [], lessons: [] };
+const EMPTY = { artifacts: [], topics: [], lessons: [], suggestions: [] };
+const EMPTY_GROWTH = {
+  lastScannedAt: {},
+  lastAutoProposeAt: 0,
+  lastDetectAt: 0,
+  turnsSinceDetect: 0,
+  judgeDay: "",
+  judgeCallsToday: 0
+};
 class FactoryStore {
   file = path.join(electron.app.getPath("userData"), "factory.json");
   timer = null;
   state = { ...EMPTY };
+  runs = [];
+  growth = { ...EMPTY_GROWTH };
   /** Load the saved registry (best-effort; an empty registry on any error). */
   load() {
     try {
@@ -1973,21 +2409,48 @@ class FactoryStore {
       this.state = {
         artifacts: Array.isArray(raw?.artifacts) ? raw.artifacts : [],
         topics: Array.isArray(raw?.topics) ? raw.topics : [],
-        lessons: Array.isArray(raw?.lessons) ? raw.lessons : []
+        lessons: Array.isArray(raw?.lessons) ? raw.lessons : [],
+        // Back-compat: older factory.json files have no `suggestions` key.
+        suggestions: Array.isArray(raw?.suggestions) ? raw.suggestions : []
       };
+      this.runs = Array.isArray(raw?.runs) ? raw.runs : [];
+      this.growth = raw?.growth && typeof raw.growth === "object" ? { ...EMPTY_GROWTH, ...raw.growth } : { ...EMPTY_GROWTH };
+      if (!this.growth.lastScannedAt || typeof this.growth.lastScannedAt !== "object" || Array.isArray(this.growth.lastScannedAt)) {
+        this.growth.lastScannedAt = {};
+      }
     } catch {
       this.state = { ...EMPTY };
+      this.runs = [];
+      this.growth = { ...EMPTY_GROWTH };
     }
     return this.state;
   }
   get() {
     return this.state;
   }
+  /** The persisted run audit trail (call after load()). */
+  loadRuns() {
+    return this.runs;
+  }
+  /** Self-growth bookkeeping (call after load()). */
+  loadGrowth() {
+    return this.growth;
+  }
   /** 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();
+  }
+  /** Replace the self-growth bookkeeping and schedule a save. */
+  setGrowth(growth) {
+    this.growth = growth;
+    this.scheduleSave();
+  }
   scheduleSave() {
     if (this.timer) clearTimeout(this.timer);
     this.timer = setTimeout(() => this.saveNow(), 500);
@@ -2000,7 +2463,11 @@ 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, growth: this.growth }, null, 2),
+        "utf8"
+      );
       fs.renameSync(tmp, this.file);
     } catch (err) {
       console.error("Failed to persist factory registry:", err);
@@ -2014,6 +2481,22 @@ const MAX_CANDIDATES = 8;
 const MAX_RUNS = 25;
 const MAX_TOPICS = 60;
 const MAX_LESSONS = 40;
+const TICK_MS$1 = 6e4;
+const AUTO_PROPOSE_INTERVAL_MS = 6 * 60 * 6e4;
+const AUTO_PROPOSE_BOOT_GRACE_MS = 10 * 6e4;
+const DETECT_DEBOUNCE_MS = 4e3;
+const DETECT_TIMEOUT_MS = 45e3;
+const MIN_TURNS_SINCE_DETECT = 3;
+const DETECT_MIN_INTERVAL_MS = 20 * 6e4;
+const DETECT_CONTEXT_MAX = 6e3;
+const MIN_CONFIDENCE = 0.6;
+const MAX_SUGGESTIONS_PER_DETECT = 2;
+const JUDGE_DAILY_CAP = 12;
+const MAX_SUGGESTIONS = 60;
+function localDay$1() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
 const KNOWN_LABELS = {
   claude_ai_Atlassian: "Atlassian (Confluence / Jira)",
   claude_ai_Figma: "Figma",
@@ -2024,14 +2507,41 @@ class FactoryService {
   constructor(getWin2) {
     this.getWin = getWin2;
     this.state = this.store.load();
+    this.runs = restoreRuns(this.store.loadRuns());
+    for (const s of this.state.suggestions) {
+      if (s.status === "creating") {
+        s.status = "open";
+        s.result = void 0;
+      }
+    }
   }
   store = new FactoryStore();
   state;
   runs = [];
   sources = null;
-  /** The in-flight agent child, so dispose()/a new run can cancel it. */
+  /** The in-flight cancellable agent child (scan/author/judge), so dispose()/cancel() can kill it. */
   inFlight = null;
+  /** Source-discovery child — a SEPARATE slot from `inFlight` so discovery (which
+   *  can run while `busy` is false) never nulls a live scan/author/judge child. */
+  discoverChild = null;
+  /** In-flight discovery promise; concurrent callers join it instead of spawning
+   *  a second discovery agent (the single-headless-child invariant). */
+  discovering = null;
   busy = false;
+  /** Resolves when the current heavy op (scan/author/judge) releases the lock —
+   *  the public listSources() awaits it before starting a discovery agent so the
+   *  two never run concurrently. Null while idle. */
+  busyPromise = null;
+  busyResolve = null;
+  /** Set by cancel(); the in-flight scan/author reports 'cancelled' instead of 'error'. */
+  cancelRequested = false;
+  /** Self-growth background timer; null until start(). */
+  timer = null;
+  /** Debounce timer for the conversation detector. */
+  detectTimer = null;
+  /** Claimed synchronously while an auto-propose pass is dispatched (incl. its
+   *  pre-scan discovery await), so the 60s timer can't double-dispatch it. */
+  autoProposing = false;
   getState() {
     return this.state;
   }
@@ -2039,37 +2549,513 @@ class FactoryService {
     return this.runs;
   }
   dispose() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (this.detectTimer) clearTimeout(this.detectTimer);
+    this.detectTimer = null;
     try {
       this.inFlight?.kill();
     } catch {
     }
+    try {
+      this.discoverChild?.kill();
+    } catch {
+    }
     this.inFlight = null;
+    this.discoverChild = null;
     this.store.saveNow();
   }
+  // ---------- self-growth: background timer ----------
+  /** Begin the self-growth loop: an infrequent token-spending auto-propose pass. */
+  start() {
+    if (this.timer) return;
+    const g = this.store.loadGrowth();
+    const earliest = Date.now() - AUTO_PROPOSE_INTERVAL_MS + AUTO_PROPOSE_BOOT_GRACE_MS;
+    if (g.lastAutoProposeAt < earliest) {
+      this.store.setGrowth({ ...g, lastAutoProposeAt: earliest });
+    }
+    this.timer = setInterval(() => this.tick(), TICK_MS$1);
+  }
+  tick() {
+    if (this.busy || this.autoProposing) return;
+    const g = this.store.loadGrowth();
+    if (Date.now() - g.lastAutoProposeAt >= AUTO_PROPOSE_INTERVAL_MS) {
+      void this.autoProposePass().catch(() => {
+      });
+    }
+  }
+  /**
+   * Infrequent token-spending pass: scan the connected MCP source that's gone
+   * longest without a scan (round-robin), then convert that scan's proposed
+   * candidates into suggestions (never auto-installed). A dedicated
+   * `autoProposing` guard (claimed synchronously) prevents a second tick from
+   * dispatching while this one is parked in discovery; the budget/rotation slot
+   * is only consumed when a scan actually runs, and we harvest exactly the run
+   * this pass produced (never a stale older one).
+   */
+  async autoProposePass() {
+    if (this.busy || this.autoProposing) return;
+    this.autoProposing = true;
+    try {
+      const sources = await this.listSources().catch(() => []);
+      if (sources.length === 0) return;
+      const g = this.store.loadGrowth();
+      const next = [...sources].sort(
+        (a, b) => (g.lastScannedAt[a.server] ?? 0) - (g.lastScannedAt[b.server] ?? 0)
+      )[0];
+      const runId = await this.scan(
+        next.server,
+        "Automated background scan: surface only a few high-value, clearly groundable candidates."
+      );
+      if (!runId) return;
+      const g2 = this.store.loadGrowth();
+      this.store.setGrowth({
+        ...g2,
+        lastScannedAt: { ...g2.lastScannedAt, [next.server]: Date.now() },
+        lastAutoProposeAt: Date.now()
+      });
+      const run = this.runs.find((r) => r.id === runId);
+      if (run && run.status === "done") this.absorbScanSuggestions(run);
+    } finally {
+      this.autoProposing = false;
+    }
+  }
+  absorbScanSuggestions(run) {
+    let newest = null;
+    let added = 0;
+    for (const c of run.candidates) {
+      if (c.status !== "proposed") continue;
+      if (this.suggestionDuplicate(c.kind, c.name, c.description)) continue;
+      newest = this.enqueueSuggestion({
+        suggestedKind: c.kind,
+        name: c.name,
+        title: c.description,
+        description: c.description,
+        rationale: c.rationale,
+        origin: "scan",
+        sourceRef: run.source,
+        sourceLabel: run.sourceLabel,
+        source: run.source,
+        context: run.summary,
+        topics: c.topics,
+        keywords: c.keywords,
+        existing: c.existing,
+        confidence: 0.8
+      });
+      added++;
+    }
+    if (added > 0) {
+      this.persist();
+      if (newest) this.getWin()?.webContents.send("factory:suggestion", newest);
+    }
+  }
+  // ---------- self-growth: conversation detector ----------
+  /**
+   * Called (fire-and-forget) after each completed Conductor turn. Debounced and
+   * heavily rate-limited; schedules a short headless judge that may queue
+   * skill/agent suggestions. Never blocks or throws into the caller.
+   */
+  considerConversation(messages) {
+    const g = this.store.loadGrowth();
+    this.store.setGrowth({ ...g, turnsSinceDetect: (g.turnsSinceDetect ?? 0) + 1 });
+    if (this.detectTimer) clearTimeout(this.detectTimer);
+    this.detectTimer = setTimeout(() => {
+      this.detectTimer = null;
+      void this.maybeRunJudge(messages).catch(() => {
+      });
+    }, DETECT_DEBOUNCE_MS);
+  }
+  async maybeRunJudge(messages) {
+    if (this.busy || this.discovering) return;
+    const g = this.store.loadGrowth();
+    const now = Date.now();
+    if (g.turnsSinceDetect < MIN_TURNS_SINCE_DETECT && now - g.lastDetectAt < DETECT_MIN_INTERVAL_MS) {
+      return;
+    }
+    const turnsAtStart = g.turnsSinceDetect;
+    const day = localDay$1();
+    const callsToday = g.judgeDay === day ? g.judgeCallsToday : 0;
+    if (callsToday >= JUDGE_DAILY_CAP) return;
+    const recent = messages.filter((m) => !m.pending && m.text?.trim()).slice(-6);
+    if (recent.length === 0) return;
+    this.setBusy(true);
+    this.cancelRequested = false;
+    try {
+      const convo = recent.map((m) => `${m.role === "user" ? "USER" : "ASSISTANT"}: ${m.text.trim()}`).join("\n\n");
+      const out = await runHeadlessClaude({
+        cwd: process.cwd(),
+        prompt: this.judgePrompt(convo),
+        allowedTools: ["Read"],
+        timeoutMs: DETECT_TIMEOUT_MS,
+        onSpawn: (child) => this.inFlight = child
+      });
+      this.absorbChatSuggestions(
+        this.parseJudge(out),
+        recent[recent.length - 1].id,
+        convo.slice(0, DETECT_CONTEXT_MAX)
+      );
+    } catch {
+    } finally {
+      this.inFlight = null;
+      this.setBusy(false);
+      const g2 = this.store.loadGrowth();
+      const day2 = localDay$1();
+      this.store.setGrowth({
+        ...g2,
+        lastDetectAt: Date.now(),
+        turnsSinceDetect: Math.max(0, (g2.turnsSinceDetect ?? 0) - turnsAtStart),
+        judgeDay: day2,
+        judgeCallsToday: (g2.judgeDay === day2 ? g2.judgeCallsToday : 0) + 1
+      });
+    }
+  }
+  judgePrompt(convo) {
+    const existing = this.existingNamesSnapshot();
+    return [
+      "You are the talent scout for an Agent & Skill Factory inside Maestro. You read a recent",
+      "slice of the user's Conductor chat and decide whether it reveals a REUSABLE workflow or",
+      "body of knowledge worth capturing as a Claude Code SKILL (a repeatable procedure the user",
+      "invokes) or SUB-AGENT (a specialist for one bounded domain).",
+      "",
+      "Be conservative: most chats are one-offs and should yield NOTHING. Only suggest when the",
+      "same kind of task would plausibly recur. Never suggest something that overlaps an artifact",
+      "that already exists below — neither a near-duplicate name nor the same purpose.",
+      "",
+      `Artifacts that already exist (do NOT duplicate):
+${JSON.stringify(existing, null, 2)}`,
+      "",
+      "Recent Conductor conversation (oldest first):",
+      convo,
+      "",
+      "Respond with ONLY one JSON object — no markdown fences, no prose:",
+      '{"suggest": <true|false>,',
+      ' "items": [{"kind":"skill|agent",',
+      '   "name":"<kebab-case-slug>",',
+      '   "title":"<short human title>",',
+      '   "description":"<one line: when to use it>",',
+      '   "rationale":"<why this conversation shows it would recur>",',
+      '   "confidence": <0..1>}]}',
+      'Return {"suggest": false, "items": []} when nothing is worth capturing.'
+    ].join("\n");
+  }
+  /** Existing skills/agents (registered + on-disk), for judge prompts and dedupe. */
+  existingNamesSnapshot() {
+    return [
+      ...this.state.artifacts.map((a) => ({ kind: a.kind, name: a.name, description: a.description })),
+      ...scanSkills().map((s) => ({ kind: "skill", name: s.name, description: s.description ?? "" })),
+      ...scanAgents().map((a) => ({ kind: "agent", name: a.name, description: a.description ?? "" }))
+    ];
+  }
+  parseJudge(out) {
+    const parsed = extractJson(out);
+    if (!parsed || parsed.suggest === false) return [];
+    const raw = Array.isArray(parsed.items) ? parsed.items : [];
+    const items = [];
+    for (const r of raw) {
+      if (!r || typeof r !== "object") continue;
+      const o = r;
+      const kind = o.kind === "agent" ? "agent" : "skill";
+      const name = slugify(String(o.name ?? ""));
+      const description = String(o.description ?? "").trim();
+      if (!name || !description) continue;
+      let confidence = Number(o.confidence);
+      if (!Number.isFinite(confidence)) confidence = 0;
+      items.push({
+        kind,
+        name,
+        title: String(o.title ?? description).trim() || description,
+        description,
+        rationale: String(o.rationale ?? "").trim(),
+        confidence: Math.max(0, Math.min(1, confidence))
+      });
+    }
+    return items;
+  }
+  absorbChatSuggestions(items, sourceMsgId, context) {
+    let newest = null;
+    let added = 0;
+    for (const it of items) {
+      if (added >= MAX_SUGGESTIONS_PER_DETECT) break;
+      if (it.confidence < MIN_CONFIDENCE) continue;
+      if (this.suggestionDuplicate(it.kind, it.name, it.title)) continue;
+      newest = this.enqueueSuggestion({
+        suggestedKind: it.kind,
+        name: it.name,
+        title: it.title,
+        description: it.description,
+        rationale: it.rationale,
+        origin: "chat",
+        sourceRef: sourceMsgId,
+        sourceLabel: "Maestro chat",
+        source: null,
+        context,
+        topics: [],
+        keywords: [],
+        existing: null,
+        confidence: it.confidence
+      });
+      added++;
+    }
+    if (added > 0) {
+      this.persist();
+      if (newest) this.getWin()?.webContents.send("factory:suggestion", newest);
+    }
+  }
+  // ---------- self-growth: suggestion queue ----------
+  enqueueSuggestion(input) {
+    const now = Date.now();
+    const s = { id: crypto.randomUUID(), status: "open", createdAt: now, updatedAt: now, ...input };
+    this.state.suggestions.push(s);
+    this.capSuggestions();
+    return s;
+  }
+  /**
+   * Keep the queue bounded by pruning ONLY the oldest terminal (created/dismissed)
+   * entries. Actionable suggestions (open/creating/error) are never dropped — if
+   * those alone exceed the cap we let the queue run over rather than silently
+   * losing work the user still has to act on.
+   */
+  capSuggestions() {
+    if (this.state.suggestions.length <= MAX_SUGGESTIONS) return;
+    const terminalOldestFirst = this.state.suggestions.filter((s) => s.status === "created" || s.status === "dismissed").sort((a, b) => a.updatedAt - b.updatedAt);
+    const drop = /* @__PURE__ */ new Set();
+    for (const s of terminalOldestFirst) {
+      if (this.state.suggestions.length - drop.size <= MAX_SUGGESTIONS) break;
+      drop.add(s.id);
+    }
+    if (drop.size > 0) {
+      this.state.suggestions = this.state.suggestions.filter((x) => !drop.has(x.id));
+    }
+  }
+  /**
+   * Deterministic, token-free dedupe: is this idea already installed/registered,
+   * or already in the open queue, or semantically the same as one of those?
+   */
+  suggestionDuplicate(kind, slug, title) {
+    const key = `${kind}:${slug}`;
+    const installed = /* @__PURE__ */ new Set([
+      ...this.state.artifacts.map((a) => `${a.kind}:${a.name}`),
+      ...listInstalled().map((i) => `${i.kind}:${i.name}`)
+    ]);
+    if (installed.has(key)) return "artifact";
+    const words = (t2) => new Set(t2.toLowerCase().replace(/[^a-z0-9 ]+/g, " ").split(/\s+/).filter(Boolean));
+    const jaccard = (a, b) => {
+      if (a.size === 0 || b.size === 0) return 0;
+      let inter = 0;
+      for (const w of a) if (b.has(w)) inter++;
+      return inter / (a.size + b.size - inter);
+    };
+    const t = words(title);
+    for (const s of this.state.suggestions) {
+      if (s.status !== "open" && s.status !== "creating") continue;
+      if (s.suggestedKind === kind && s.name === slug) return "suggestion";
+      if (jaccard(t, words(s.title)) >= 0.6) return "suggestion";
+    }
+    for (const a of this.state.artifacts) {
+      if (jaccard(t, words(`${a.name} ${a.description}`)) >= 0.6) return "artifact";
+    }
+    return null;
+  }
+  /** Author + write + register the artifact for a suggestion (the only way one is built). */
+  async createFromSuggestion(id, kind) {
+    const s = this.state.suggestions.find((x) => x.id === id);
+    if (!s || s.status !== "open" && s.status !== "error") return;
+    if (this.busy) return;
+    const useKind = kind ?? s.suggestedKind;
+    this.setBusy(true);
+    this.cancelRequested = false;
+    s.status = "creating";
+    s.suggestedKind = useKind;
+    s.result = void 0;
+    s.updatedAt = Date.now();
+    this.persist();
+    try {
+      await this.discovering?.catch(() => {
+      });
+      const slug = slugify(s.name);
+      let authored;
+      if (s.origin === "scan") {
+        const sources = await this.discoverCache().catch(() => []);
+        const source = sources.find((x) => x.server === s.source) ?? { server: s.source ?? "mcp", label: s.sourceLabel, toolPrefix: `mcp__${s.source ?? ""}`, readTools: [] };
+        const candidate = {
+          id: s.id,
+          kind: useKind,
+          name: slug,
+          description: s.description,
+          topics: s.topics,
+          keywords: s.keywords,
+          rationale: s.rationale,
+          existing: s.existing,
+          status: "authoring"
+        };
+        const allowedTools = ["Read", "Grep", "Glob", source.toolPrefix, ...source.readTools];
+        const out = await runHeadlessClaude({
+          cwd: process.cwd(),
+          prompt: this.authorPrompt(source, candidate, slug),
+          allowedTools,
+          timeoutMs: AUTHOR_TIMEOUT_MS,
+          onSpawn: (child) => this.inFlight = child
+        });
+        authored = this.parseAuthor(out);
+      } else {
+        const out = await runHeadlessClaude({
+          cwd: process.cwd(),
+          prompt: this.conversationAuthorPrompt(s, useKind, slug),
+          allowedTools: ["Read", "Grep", "Glob"],
+          timeoutMs: AUTHOR_TIMEOUT_MS,
+          onSpawn: (child) => this.inFlight = child
+        });
+        authored = this.parseAuthor(out);
+      }
+      if (!authored) throw new Error("The author agent did not return usable file content.");
+      const filePath = useKind === "skill" ? writeSkill(slug, authored.content) : writeAgent(slug, authored.content);
+      this.registerArtifact({
+        kind: useKind,
+        name: slug,
+        filePath,
+        description: authored.description || s.description,
+        topics: authored.topics.length ? authored.topics : s.topics,
+        keywords: authored.keywords.length ? authored.keywords : s.keywords,
+        source: s.origin === "scan" ? s.source ?? "scan" : "conversation",
+        related: authored.related
+      });
+      const artifact = this.state.artifacts.find((a) => a.kind === useKind && a.name === slug);
+      s.status = "created";
+      s.artifactId = artifact?.id;
+      s.filePath = filePath;
+      s.result = `Wrote ${useKind} to ${filePath}`;
+    } catch (err) {
+      if (this.cancelRequested) {
+        s.status = "open";
+        s.result = void 0;
+      } else {
+        s.status = "error";
+        s.result = err.message || String(err);
+      }
+    } finally {
+      s.updatedAt = Date.now();
+      this.inFlight = null;
+      this.setBusy(false);
+      this.persist();
+    }
+  }
+  /** Dismiss a suggestion without building it (kept as history; may resurface later). */
+  dismissSuggestion(id) {
+    const s = this.state.suggestions.find((x) => x.id === id);
+    if (!s || s.status !== "open" && s.status !== "error") return;
+    s.status = "dismissed";
+    s.updatedAt = Date.now();
+    this.persist();
+  }
+  conversationAuthorPrompt(s, kind, slug) {
+    const related = this.state.artifacts.map((a) => ({ name: a.name, kind: a.kind, description: a.description }));
+    const lessons = this.state.lessons.map((l) => l.text);
+    const isSkill = kind === "skill";
+    return [
+      `You are authoring a Claude Code ${isSkill ? "SKILL" : "SUB-AGENT"} that captures a reusable`,
+      "workflow the user demonstrated in a Maestro Conductor conversation. You run unattended.",
+      "",
+      `Target artifact:
+${JSON.stringify({ kind, name: slug, description: s.description, topics: s.topics, rationale: s.rationale }, null, 2)}`,
+      "",
+      "The conversation that motivated this artifact — capture the GENERAL, reusable procedure it",
+      "shows; strip one-off specifics (particular file names, ids, values) and keep the repeatable",
+      "method:",
+      s.context || "(no excerpt was captured; rely on the target description above)",
+      "",
+      "Write the COMPLETE file content as Markdown with a YAML frontmatter block.",
+      isSkill ? [
+        "For a SKILL the file is SKILL.md. Frontmatter MUST be exactly:",
+        "---",
+        `name: ${slug}`,
+        "description: <one line describing WHEN to use this skill>",
+        "---",
+        "Then the body: a focused, step-by-step procedure the agent can follow."
+      ].join("\n") : [
+        "For a SUB-AGENT the file is an agent definition. Frontmatter MUST be exactly:",
+        "---",
+        `name: ${slug}`,
+        "description: <one line: when to route to this agent — be specific with trigger terms>",
+        "model: claude-sonnet-4-6",
+        "---",
+        "Then the body: the agent's system prompt — its scope, what it knows, and what it does NOT cover."
+      ].join("\n"),
+      "",
+      `Other artifacts that exist (name any genuinely related):
+${JSON.stringify(related, null, 2)}`,
+      lessons.length ? `
+Lessons learned (respect these):
+- ${lessons.join("\n- ")}` : "",
+      "",
+      "Respond with ONLY one JSON object — no markdown fences around the whole object, no prose:",
+      '{"content":"<the FULL file content, frontmatter + body, as a single string>",',
+      ' "description":"<final one-line description>",',
+      ' "topics":["..."], "keywords":["..."],',
+      ' "related":["<names of related existing artifacts>"]}'
+    ].filter((l) => l !== "").join("\n");
+  }
+  /** 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
    * connectors are not in ~/.claude.json, so a no-tool headless agent reports
    * what it can see; we merge that with the user-scope servers from
    * ~/.claude.json. Cached for the app run; `refresh` forces a re-discovery.
+   *
+   * PUBLIC entry point (IPC / renderer refresh / auto-propose pre-scan): if a
+   * heavy op holds the lock, WAIT for it before starting a discovery agent, so
+   * we never run two headless `claude -p` children at once. Lock-holders
+   * (scan/approve/createFromSuggestion) must call discoverCache() instead — they
+   * already hold the lock and would otherwise wait on themselves (deadlock).
    */
   async listSources(refresh = false) {
     if (this.sources && !refresh) return this.sources;
-    const discovered = await this.discoverSources().catch(() => []);
-    const byKey = /* @__PURE__ */ new Map();
-    for (const s of discovered) byKey.set(s.server, s);
-    for (const m of readUserMcpServers()) {
-      if (!byKey.has(m.name)) {
-        byKey.set(m.name, {
-          server: m.name,
-          label: KNOWN_LABELS[m.name] ?? m.name,
-          toolPrefix: `mcp__${m.name}`,
-          readTools: []
-        });
+    while (this.busy && this.busyPromise) await this.busyPromise;
+    return this.discoverCache(refresh);
+  }
+  /**
+   * The actual cached/memoized discovery, with NO busy-wait. Safe to call from a
+   * lock-holder because discovery runs before that op spawns its own child, so
+   * only one headless child is ever alive. Concurrent callers join one discovery.
+   */
+  discoverCache(refresh = false) {
+    if (this.sources && !refresh) return Promise.resolve(this.sources);
+    if (this.discovering) return this.discovering;
+    this.discovering = (async () => {
+      try {
+        const discovered = await this.discoverSources().catch(() => []);
+        const byKey = /* @__PURE__ */ new Map();
+        for (const s of discovered) byKey.set(s.server, s);
+        for (const m of readUserMcpServers()) {
+          if (!byKey.has(m.name)) {
+            byKey.set(m.name, {
+              server: m.name,
+              label: KNOWN_LABELS[m.name] ?? m.name,
+              toolPrefix: `mcp__${m.name}`,
+              readTools: []
+            });
+          }
+        }
+        this.sources = [...byKey.values()].sort((a, b) => a.label.localeCompare(b.label));
+        return this.sources;
+      } finally {
+        this.discovering = null;
       }
-    }
-    this.sources = [...byKey.values()].sort((a, b) => a.label.localeCompare(b.label));
-    return this.sources;
+    })();
+    return this.discovering;
   }
   async discoverSources() {
     const prompt = [
@@ -2096,8 +3082,8 @@ class FactoryService {
       prompt,
       allowedTools: ["Read"],
       timeoutMs: DISCOVER_TIMEOUT_MS,
-      onSpawn: (child) => this.inFlight = child
-    }).finally(() => this.inFlight = null);
+      onSpawn: (child) => this.discoverChild = child
+    }).finally(() => this.discoverChild = null);
     const parsed = extractJson(out);
     const list = Array.isArray(parsed?.servers) ? parsed.servers : [];
     const sources = [];
@@ -2117,29 +3103,37 @@ class FactoryService {
     return sources;
   }
   // ---------- scan (phase 1) ----------
-  /** Explore a source and propose skill/agent candidates. */
+  /**
+   * Explore a source and propose skill/agent candidates. Claims the single
+   * `busy` lock SYNCHRONOUSLY (before any await) so two headless agents can
+   * never run at once. Returns the created run's id, or null if it bailed on
+   * the busy guard (no run, no tokens spent) — callers (auto-propose) use this
+   * to harvest exactly this run and to only consume budget when a scan ran.
+   * Throws (releasing the lock) only for an unknown source / discovery failure.
+   */
   async scan(serverKey, guidance) {
-    if (this.busy) return;
-    const sources = await this.listSources();
-    const source = sources.find((s) => s.server === serverKey);
-    if (!source) throw new Error(`Unknown source: ${serverKey}`);
-    this.busy = true;
-    const run = {
-      id: crypto.randomUUID(),
-      source: source.server,
-      sourceLabel: source.label,
-      guidance: guidance.trim(),
-      startedAt: Date.now(),
-      finishedAt: null,
-      status: "running",
-      phase: "discovering",
-      candidates: [],
-      summary: ""
-    };
-    this.pushRun(run);
+    if (this.busy) return null;
+    this.setBusy(true);
+    this.cancelRequested = false;
+    let run = null;
     try {
+      const sources = await this.discoverCache();
+      const source = sources.find((s) => s.server === serverKey);
+      if (!source) throw new Error(`Unknown source: ${serverKey}`);
+      run = {
+        id: crypto.randomUUID(),
+        source: source.server,
+        sourceLabel: source.label,
+        guidance: guidance.trim(),
+        startedAt: Date.now(),
+        finishedAt: null,
+        status: "running",
+        phase: "discovering",
+        candidates: [],
+        summary: ""
+      };
+      this.pushRun(run);
       const allowedTools = ["Read", "Grep", "Glob", source.toolPrefix, ...source.readTools];
-      run.phase = "discovering";
       this.broadcastRuns();
       const out = await runHeadlessClaude({
         cwd: process.cwd(),
@@ -2155,15 +3149,24 @@ class FactoryService {
       run.status = "done";
       this.absorbTopics(parsed.newTopics, source.server);
     } catch (err) {
-      run.status = "error";
-      run.phase = "done";
-      run.summary = err.message || String(err);
+      if (run) {
+        run.status = this.cancelRequested ? "cancelled" : "error";
+        run.phase = "done";
+        run.summary = this.cancelRequested ? "Cancelled." : err.message || String(err);
+      } else {
+        this.inFlight = null;
+        this.setBusy(false);
+        throw err;
+      }
     } finally {
-      run.finishedAt = Date.now();
-      this.inFlight = null;
-      this.busy = false;
-      this.broadcastRuns();
+      if (run) {
+        run.finishedAt = Date.now();
+        this.inFlight = null;
+        this.setBusy(false);
+        this.broadcastRuns();
+      }
     }
+    return run ? run.id : null;
   }
   scanPrompt(source, guidance) {
     const existing = [
@@ -2256,18 +3259,19 @@ 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.setBusy(true);
+    this.cancelRequested = false;
     candidate.status = "authoring";
     candidate.result = void 0;
     this.broadcastRuns();
     try {
-      const source = (await this.listSources()).find((s) => s.server === run.source) ?? { server: run.source, label: run.sourceLabel, toolPrefix: `mcp__${run.source}`, readTools: [] };
+      const source = (await this.discoverCache()).find((s) => s.server === run.source) ?? { server: run.source, label: run.sourceLabel, toolPrefix: `mcp__${run.source}`, readTools: [] };
       const allowedTools = ["Read", "Grep", "Glob", source.toolPrefix, ...source.readTools];
       const slug = slugify(candidate.name);
       const out = await runHeadlessClaude({
@@ -2294,21 +3298,27 @@ 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;
+      this.setBusy(false);
       this.broadcastRuns();
       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 +3435,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()));
@@ -2491,13 +3552,53 @@ Lessons learned (respect these):
     this.store.set(this.state);
     this.broadcastState();
   }
-  broadcastState() {
-    this.getWin()?.webContents.send("factory:changed", this.state);
+  broadcastState() {
+    this.getWin()?.webContents.send("factory:changed", this.state);
+  }
+  /**
+   * Single source of truth for the headless lock. Setting it broadcasts so the
+   * renderer can reflect background work (judge / author / scan) that doesn't
+   * create a visible FactoryRun — preventing buttons that would silently no-op
+   * against the lock from staying enabled.
+   */
+  setBusy(v) {
+    if (this.busy === v) return;
+    this.busy = v;
+    if (v) {
+      this.busyPromise = new Promise((resolve) => this.busyResolve = resolve);
+    } else {
+      this.busyResolve?.();
+      this.busyResolve = null;
+      this.busyPromise = null;
+    }
+    this.getWin()?.webContents.send("factory:busy", v);
+  }
+  /** Current headless-lock state (for the initial renderer fetch). */
+  isBusy() {
+    return this.busy;
   }
   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 +3664,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 +3682,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 +4248,7 @@ class UsageService {
     return entries;
   }
 }
+const CONDUCTOR_ATTACH_SCOPE = "conductor";
 function tokenize(template) {
   const tokens = [];
   const re = /"([^"]*)"|(\S+)/g;
@@ -3152,7 +4256,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, agents, tokenEff, getWin2) {
   const rootOf = (id) => {
     const config = sessions.getConfig(id);
     if (!config) throw new Error(`Unknown session: ${id}`);
@@ -3209,6 +4313,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 +4400,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,9 +4415,27 @@ 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());
+  electron.ipcMain.handle("factory:isBusy", () => factory.isBusy());
   electron.ipcMain.handle(
     "factory:scan",
     (_e, serverKey, guidance) => factory.scan(serverKey, guidance)
@@ -3326,11 +4449,30 @@ 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));
   electron.ipcMain.handle("factory:deleteLesson", (_e, id) => factory.deleteLesson(id));
+  electron.ipcMain.handle(
+    "factory:createFromSuggestion",
+    (_e, id, kind) => factory.createFromSuggestion(id, kind)
+  );
+  electron.ipcMain.handle("factory:dismissSuggestion", (_e, id) => factory.dismissSuggestion(id));
+  electron.ipcMain.handle("agents:get", () => agents.snapshot());
+  electron.ipcMain.handle("agents:refresh", () => agents.refresh());
+  electron.ipcMain.handle("agents:read", (_e, filePath) => agents.readAgentFile(filePath));
+  electron.ipcMain.handle("agents:reveal", (_e, filePath) => agents.revealAgentFile(filePath));
   electron.ipcMain.handle("actions:list", () => sessions.actions);
   electron.ipcMain.handle("actions:save", (_e, actions) => sessions.saveActions(actions));
   electron.ipcMain.handle(
@@ -3423,6 +4565,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();
@@ -3459,8 +4628,20 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     Object.assign(persistence2.state.settings, patch);
     persistence2.scheduleSave();
     getWin2()?.webContents.send("session:changed");
+    if (patch.agentRegistryPath !== void 0) agents.refresh();
   });
 }
+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 +4653,10 @@ const DEFAULT_SETTINGS = {
   backgroundOpacity: 0.3,
   watchdogEnabled: true,
   watchdogStallMinutes: 10,
-  watchdogUnansweredMinutes: 5
+  watchdogUnansweredMinutes: 5,
+  tokenEfficiency: DEFAULT_TOKEN_EFFICIENCY,
+  tokenEfficiencyRepoOverrides: {},
+  agentRegistryPath: "C:\\repos\\agent-factory\\registry\\registry.json"
 };
 const DEFAULT_CATEGORIES = [
   {
@@ -3520,7 +4704,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 +4755,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 +4815,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 +4908,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 +5071,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 +5088,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 +5113,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 +5138,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 +5287,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 +5349,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 +5396,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 +5446,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 +5537,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 +5824,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 +5918,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 +6252,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 +6267,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 +6372,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 +6413,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,12 +7290,14 @@ 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);
     const conductor = new ConductorService(persistence, sessions, features, autoExpand, getWin);
     const factory = new FactoryService(getWin);
+    const agentRegistry = new AgentRegistryService(persistence, getWin);
     registerIpc(
       sessions,
       fsService,
@@ -5268,6 +7307,8 @@ if (!gotLock) {
       autoExpand,
       conductor,
       factory,
+      agentRegistry,
+      tokenEff,
       getWin
     );
     createWindow();
@@ -5275,10 +7316,15 @@ if (!gotLock) {
     sessions.startWatchdog();
     sentinels.start();
     autoExpand.start();
+    tokenEff.start();
+    factory.start();
+    conductor.onTurnComplete((messages) => factory.considerConversation(messages));
     electron.app.on("activate", () => {
       if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
     });
     electron.app.on("before-quit", () => {
+      tokenEff.dispose();
+      agentRegistry.dispose();
       factory.dispose();
       conductor.dispose();
       autoExpand.dispose();