claude-maestro 0.1.18 → 0.1.20

package/out/main/index.js

@@ -1,10 +1,11 @@
 "use strict";
 const electron = require("electron");
+const events = require("events");
 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 +26,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(
@@ -737,8 +1010,8 @@ function resolveClaude() {
   if (!IS_WIN$1) {
     return candidates[0] ? { file: candidates[0], argsPrefix: [] } : null;
   }
-  const exe = candidates.find((c) => c.toLowerCase().endsWith(".exe"));
-  const cmd = candidates.find((c) => /\.(cmd|bat)$/i.test(c));
+  const exe = candidates.find((c2) => c2.toLowerCase().endsWith(".exe"));
+  const cmd = candidates.find((c2) => /\.(cmd|bat)$/i.test(c2));
   if (exe) return { file: exe, argsPrefix: [] };
   if (cmd) return { file: process.env.ComSpec ?? "cmd.exe", argsPrefix: ["/c", cmd] };
   return null;
@@ -1035,7 +1308,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;
@@ -1051,10 +1324,12 @@ const ALLOWED_TOOLS$2 = [
   "Bash(git rev-parse:*)"
 ];
 class AutoExpandService {
-  constructor(persistence2, features, getWin2) {
+  constructor(persistence2, features, getWin2, emitGame = () => {
+  }) {
     this.persistence = persistence2;
     this.features = features;
     this.getWin = getWin2;
+    this.emitGame = emitGame;
   }
   timer = null;
   /** Next scheduled run (ms epoch) per session id. */
@@ -1064,7 +1339,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() {
@@ -1251,6 +1526,7 @@ class AutoExpandService {
     run.finishedAt = Date.now();
     run.status = status;
     this.broadcast(run.sessionId);
+    if (status === "done") this.emitGame({ type: "autoexpand.done" });
   }
   broadcast(sessionId) {
     this.getWin()?.webContents.send("autoexpand:runs", sessionId, this.listRuns(sessionId));
@@ -1431,6 +1707,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;
   }
@@ -1508,6 +1792,12 @@ class ConductorService {
       this.inFlight = null;
       this.busy = false;
       this.persistAndBroadcast();
+      if (!assistantMsg.error) {
+        try {
+          this.turnCompleteCb?.(this.messages);
+        } catch {
+        }
+      }
     }
   }
   /**
@@ -1735,9 +2025,9 @@ class ConductorService {
     const list = focusId ? this.sessions.list().filter((s) => s.config.id === focusId) : this.sessions.list();
     const sessions = await Promise.all(
       list.map(async (s) => {
-        const c = s.config;
-        const git2 = await this.sessions.getGitStatus(c.id).catch(() => null);
-        const feats = this.features.list(c.id).map((f) => ({
+        const c2 = s.config;
+        const git2 = await this.sessions.getGitStatus(c2.id).catch(() => null);
+        const feats = this.features.list(c2.id).map((f) => ({
           id: f.id,
           title: f.title,
           status: f.status,
@@ -1745,19 +2035,19 @@ class ConductorService {
           openSpecs: f.specs.filter((sp) => !sp.done).length
         }));
         const entry = {
-          id: c.id,
-          name: c.name,
-          folder: c.folder,
-          isActive: c.id === activeId,
+          id: c2.id,
+          name: c2.name,
+          folder: c2.folder,
+          isActive: c2.id === activeId,
           status: s.status,
-          categoryId: c.categoryId ?? null,
+          categoryId: c2.categoryId ?? null,
           terminals: s.terminals.map((t) => ({ kind: t.config.kind, status: t.status })),
-          worktree: c.worktree ? {
-            parentSessionId: c.worktree.parentSessionId,
-            branch: c.worktree.branch,
-            baseBranch: c.worktree.baseBranch
+          worktree: c2.worktree ? {
+            parentSessionId: c2.worktree.parentSessionId,
+            branch: c2.worktree.branch,
+            baseBranch: c2.worktree.baseBranch
           } : null,
-          autoExpand: c.autoExpand ? { enabled: c.autoExpand.enabled, branch: c.autoExpand.branch } : null,
+          autoExpand: c2.autoExpand ? { enabled: c2.autoExpand.enabled, branch: c2.autoExpand.branch } : null,
           git: git2 ? {
             branch: git2.branch,
             ahead: git2.ahead,
@@ -1766,8 +2056,8 @@ class ConductorService {
           } : null,
           features: feats
         };
-        if (c.worktree) {
-          const task = await this.sessions.getWorktreeTaskState(c.id).catch(() => null);
+        if (c2.worktree) {
+          const task = await this.sessions.getWorktreeTaskState(c2.id).catch(() => null);
           if (task) {
             entry.task = {
               dirty: task.dirty,
@@ -2101,12 +2391,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 {
@@ -2114,12 +2413,19 @@ 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;
   }
@@ -2130,6 +2436,10 @@ class FactoryStore {
   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;
@@ -2140,6 +2450,11 @@ class FactoryStore {
     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);
@@ -2152,7 +2467,11 @@ class FactoryStore {
     try {
       fs.mkdirSync(path.dirname(this.file), { recursive: true });
       const tmp = this.file + ".tmp";
-      fs.writeFileSync(tmp, JSON.stringify({ ...this.state, runs: this.runs }, 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);
@@ -2166,6 +2485,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",
@@ -2173,20 +2508,46 @@ const KNOWN_LABELS = {
   github: "GitHub"
 };
 class FactoryService {
-  constructor(getWin2) {
+  constructor(getWin2, emitGame = () => {
+  }) {
     this.getWin = getWin2;
+    this.emitGame = emitGame;
     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()/cancel() can kill 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;
   }
@@ -2194,13 +2555,451 @@ 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 c2 of run.candidates) {
+      if (c2.status !== "proposed") continue;
+      if (this.suggestionDuplicate(c2.kind, c2.name, c2.description)) continue;
+      newest = this.enqueueSuggestion({
+        suggestedKind: c2.kind,
+        name: c2.name,
+        title: c2.description,
+        description: c2.description,
+        rationale: c2.rationale,
+        origin: "scan",
+        sourceRef: run.source,
+        sourceLabel: run.sourceLabel,
+        source: run.source,
+        context: run.summary,
+        topics: c2.topics,
+        keywords: c2.keywords,
+        existing: c2.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;
@@ -2221,24 +3020,48 @@ class FactoryService {
    * 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 = [
@@ -2265,8 +3088,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 = [];
@@ -2286,30 +3109,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;
+    if (this.busy) return null;
+    this.setBusy(true);
     this.cancelRequested = false;
-    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);
+    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(),
@@ -2325,15 +3155,24 @@ class FactoryService {
       run.status = "done";
       this.absorbTopics(parsed.newTopics, source.server);
     } catch (err) {
-      run.status = this.cancelRequested ? "cancelled" : "error";
-      run.phase = "done";
-      run.summary = this.cancelRequested ? "Cancelled." : 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 = [
@@ -2429,16 +3268,16 @@ Lessons learned (respect these):
   /** 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);
+    const candidate = run?.candidates.find((c2) => c2.id === candidateId);
     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({
@@ -2474,7 +3313,7 @@ Lessons learned (respect these):
       }
     } finally {
       this.inFlight = null;
-      this.busy = false;
+      this.setBusy(false);
       this.broadcastRuns();
       this.broadcastState();
     }
@@ -2483,14 +3322,14 @@ Lessons learned (respect these):
   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);
+    for (const c2 of run.candidates) {
+      if (c2.status === "proposed") await this.approve(runId, c2.id);
       if (this.cancelRequested) break;
     }
   }
   reject(runId, candidateId) {
     const run = this.runs.find((r) => r.id === runId);
-    const candidate = run?.candidates.find((c) => c.id === candidateId);
+    const candidate = run?.candidates.find((c2) => c2.id === candidateId);
     if (!candidate || candidate.status !== "proposed") return;
     candidate.status = "rejected";
     this.broadcastRuns();
@@ -2590,6 +3429,10 @@ Lessons learned (respect these):
         createdAt: now,
         updatedAt: now
       });
+      this.emitGame({
+        type: input.kind === "agent" ? "factory.agent" : "factory.skill",
+        meta: { name: input.name }
+      });
     }
     for (const a of this.state.artifacts) {
       if (related.includes(a.name) && !a.relatedArtifacts.includes(input.name)) {
@@ -2722,6 +3565,28 @@ Lessons learned (respect these):
   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);
@@ -2735,10 +3600,10 @@ function restoreRuns(runs) {
       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;
+    for (const c2 of run.candidates) {
+      if (c2.status === "authoring") {
+        c2.status = "proposed";
+        c2.result = void 0;
       }
     }
   }
@@ -2771,9 +3636,11 @@ Feature: ${feature.title}
 Read that spec file in full, then implement every spec it lists. Make your changes in this worktree and commit them as each part works. If any spec is ambiguous, ask before guessing.`;
 }
 class FeatureService {
-  constructor(persistence2, sessions) {
+  constructor(persistence2, sessions, emitGame = () => {
+  }) {
     this.persistence = persistence2;
     this.sessions = sessions;
+    this.emitGame = emitGame;
   }
   get features() {
     return this.persistence.state.features;
@@ -2794,8 +3661,12 @@ class FeatureService {
   save(feature) {
     const list = this.features;
     const idx = list.findIndex((f) => f.id === feature.id);
-    if (idx >= 0) list[idx] = feature;
-    else list.push(feature);
+    if (idx >= 0) {
+      list[idx] = feature;
+    } else {
+      list.push(feature);
+      this.emitGame({ type: "feature.save" });
+    }
     this.persistence.scheduleSave();
   }
   delete(id) {
@@ -2987,6 +3858,310 @@ class FsService {
     }
   }
 }
+const XP_TABLE = {
+  "session.turn": 5,
+  "conductor.turn": 5,
+  "action.run": 8,
+  "checkpoint.create": 10,
+  "sentinel.run": 12,
+  "session.create": 20,
+  "worktree.create": 25,
+  "feature.save": 30,
+  "autoexpand.done": 40,
+  "worktree.pr": 50,
+  "worktree.merge": 60,
+  "factory.skill": 75,
+  "factory.agent": 75,
+  "feature.merge": 80
+};
+function xpForEvent(e) {
+  let xp = XP_TABLE[e.type] ?? 0;
+  if (e.type === "worktree.merge") xp += Math.min(e.meta?.commits ?? 0, 10) * 3;
+  return xp;
+}
+function xpForLevel(n) {
+  if (n <= 1) return 0;
+  const k = n - 1;
+  return 50 * k * k + 50 * k;
+}
+function levelForXp(xp) {
+  if (xp <= 0) return 1;
+  return Math.max(1, Math.floor((-50 + Math.sqrt(2500 + 200 * xp)) / 100) + 1);
+}
+function levelInfo(xp) {
+  const level = levelForXp(xp);
+  const floor = xpForLevel(level);
+  const next = xpForLevel(level + 1);
+  return { level, xpIntoLevel: xp - floor, xpForNextLevel: next - floor };
+}
+const DEFAULT_GAME_STATE = {
+  xp: 0,
+  streak: { current: 0, longest: 0, lastDay: "" },
+  achievements: {},
+  todaysQuests: [],
+  questDay: "",
+  counters: {},
+  nightTurns: 0,
+  earlyTurns: 0,
+  createdAt: 0
+};
+const c = (ctx, t) => ctx.counters[t] ?? 0;
+const ACHIEVEMENTS = [
+  // sessions
+  { id: "first-session", title: "Hello, Maestro", desc: "Start your first session.", icon: "🎬", category: "sessions", predicate: (x) => c(x, "session.create") >= 1 },
+  { id: "ten-sessions", title: "Regular", desc: "Start 10 sessions.", icon: "📁", category: "sessions", predicate: (x) => c(x, "session.create") >= 10 },
+  { id: "worktree-novice", title: "Branching Out", desc: "Create your first parallel task.", icon: "🌱", category: "sessions", predicate: (x) => c(x, "worktree.create") >= 1 },
+  { id: "worktree-adept", title: "Multitasker", desc: "Create 10 parallel tasks.", icon: "🌳", category: "sessions", predicate: (x) => c(x, "worktree.create") >= 10 },
+  // merges
+  { id: "first-merge", title: "Merge One", desc: "Merge your first worktree.", icon: "🔀", category: "merges", predicate: (x) => c(x, "worktree.merge") >= 1 },
+  { id: "ten-merges", title: "Merge Maestro", desc: "Merge 10 worktrees.", icon: "🧬", category: "merges", predicate: (x) => c(x, "worktree.merge") >= 10 },
+  { id: "fifty-merges", title: "Merge Machine", desc: "Merge 50 worktrees.", icon: "⚙️", category: "merges", predicate: (x) => c(x, "worktree.merge") >= 50 },
+  { id: "pr-opener", title: "Pull Request", desc: "Open your first PR.", icon: "📤", category: "merges", predicate: (x) => c(x, "worktree.pr") >= 1 },
+  { id: "pr-prolific", title: "PR Prolific", desc: "Open 10 PRs.", icon: "🚀", category: "merges", predicate: (x) => c(x, "worktree.pr") >= 10 },
+  { id: "feature-shipper", title: "Ship It", desc: "Merge a feature you specced.", icon: "📦", category: "merges", predicate: (x) => c(x, "feature.merge") >= 1 },
+  // turns
+  { id: "first-turn", title: "First Light", desc: "Finish your first Claude turn.", icon: "✶", category: "turns", predicate: (x) => c(x, "session.turn") >= 1 },
+  { id: "hundred-turns", title: "Century", desc: "Finish 100 turns.", icon: "💯", category: "turns", predicate: (x) => c(x, "session.turn") >= 100 },
+  { id: "thousand-turns", title: "Marathoner", desc: "Finish 1,000 turns.", icon: "🏃", category: "turns", predicate: (x) => c(x, "session.turn") >= 1e3 },
+  { id: "conductor-curious", title: "Conductor Curious", desc: "Have your first Conductor turn.", icon: "✦", category: "turns", predicate: (x) => c(x, "conductor.turn") >= 1 },
+  { id: "conductor-regular", title: "Maestro of Maestro", desc: "Have 50 Conductor turns.", icon: "🎼", category: "turns", predicate: (x) => c(x, "conductor.turn") >= 50 },
+  // factory
+  { id: "first-skill", title: "Skill Smith", desc: "Create your first skill.", icon: "🛠", category: "factory", predicate: (x) => c(x, "factory.skill") >= 1 },
+  { id: "first-agent", title: "Agent Architect", desc: "Create your first agent.", icon: "🤖", category: "factory", predicate: (x) => c(x, "factory.agent") >= 1 },
+  { id: "toolsmith", title: "Toolsmith", desc: "Create 5 skills/agents.", icon: "⚒", category: "factory", predicate: (x) => c(x, "factory.skill") + c(x, "factory.agent") >= 5 },
+  { id: "master-toolsmith", title: "Master Toolsmith", desc: "Create 20 skills/agents.", icon: "🏭", category: "factory", predicate: (x) => c(x, "factory.skill") + c(x, "factory.agent") >= 20 },
+  // streak
+  { id: "streak-3", title: "Warmed Up", desc: "Keep a 3-day streak.", icon: "🔥", category: "streak", predicate: (x) => x.streakLongest >= 3 },
+  { id: "streak-7", title: "On Fire", desc: "Keep a 7-day streak.", icon: "🔥", category: "streak", predicate: (x) => x.streakLongest >= 7 },
+  { id: "streak-30", title: "Unstoppable", desc: "Keep a 30-day streak.", icon: "☄️", category: "streak", predicate: (x) => x.streakLongest >= 30 },
+  // time of day
+  { id: "night-owl", title: "Night Owl", desc: "Finish a turn between midnight and 5am.", icon: "🦉", category: "time", predicate: (x) => x.nightTurns >= 1 },
+  { id: "early-bird", title: "Early Bird", desc: "Finish a turn between 5 and 8am.", icon: "🌅", category: "time", predicate: (x) => x.earlyTurns >= 1 },
+  // level
+  { id: "level-10", title: "Double Digits", desc: "Reach level 10.", icon: "⭐", category: "level", predicate: (x) => x.level >= 10 },
+  { id: "level-25", title: "Maestro Prime", desc: "Reach level 25.", icon: "🌟", category: "level", predicate: (x) => x.level >= 25 }
+];
+const DAILY_QUEST_POOL = [
+  { id: "q-turns-5", title: "Finish 5 Claude turns", target: 5, reward: 30, events: ["session.turn"] },
+  { id: "q-merge-1", title: "Merge a worktree", target: 1, reward: 40, events: ["worktree.merge"] },
+  { id: "q-merge-3", title: "Merge 3 worktrees", target: 3, reward: 100, events: ["worktree.merge"] },
+  { id: "q-create-1", title: "Start a session", target: 1, reward: 20, events: ["session.create"] },
+  { id: "q-worktree-2", title: "Spin up 2 parallel tasks", target: 2, reward: 50, events: ["worktree.create"] },
+  { id: "q-checkpoint", title: "Make a checkpoint", target: 1, reward: 20, events: ["checkpoint.create"] },
+  { id: "q-conductor-3", title: "Have 3 Conductor turns", target: 3, reward: 30, events: ["conductor.turn"] },
+  { id: "q-factory-1", title: "Create a skill or agent", target: 1, reward: 75, events: ["factory.skill", "factory.agent"] },
+  { id: "q-feature-1", title: "Save a feature spec", target: 1, reward: 30, events: ["feature.save"] },
+  { id: "q-pr-1", title: "Open a pull request", target: 1, reward: 50, events: ["worktree.pr"] }
+];
+const questDef = (id) => DAILY_QUEST_POOL.find((q) => q.id === id);
+function hashStr(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pickDailyQuests(dayKey2, n = 3) {
+  const rnd = mulberry32(hashStr("quest:" + dayKey2));
+  const pool = [...DAILY_QUEST_POOL];
+  for (let i = pool.length - 1; i > 0; i--) {
+    const j = Math.floor(rnd() * (i + 1));
+    [pool[i], pool[j]] = [pool[j], pool[i]];
+  }
+  return pool.slice(0, Math.min(n, pool.length)).map((q) => ({
+    id: q.id,
+    target: q.target,
+    progress: 0,
+    rewarded: false
+  }));
+}
+function dayKey(d) {
+  return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
+function prevDayKey(d) {
+  const y = new Date(d.getFullYear(), d.getMonth(), d.getDate() - 1);
+  return dayKey(y);
+}
+class GamificationStore {
+  file = path.join(electron.app.getPath("userData"), "gamification.json");
+  timer = null;
+  state = structuredClone(DEFAULT_GAME_STATE);
+  /** Load saved progress (best-effort; defaults on any error, back-compat via spread). */
+  load() {
+    try {
+      const raw = JSON.parse(fs.readFileSync(this.file, "utf8"));
+      const s = { ...structuredClone(DEFAULT_GAME_STATE), ...raw ?? {} };
+      const num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : Number.isFinite(Number(v)) ? Number(v) : fallback;
+      if (!s.streak || typeof s.streak !== "object") s.streak = { current: 0, longest: 0, lastDay: "" };
+      s.streak.current = num(s.streak.current, 0);
+      s.streak.longest = num(s.streak.longest, 0);
+      if (typeof s.streak.lastDay !== "string") s.streak.lastDay = "";
+      if (!s.achievements || typeof s.achievements !== "object" || Array.isArray(s.achievements)) {
+        s.achievements = {};
+      }
+      if (!Array.isArray(s.todaysQuests)) s.todaysQuests = [];
+      s.todaysQuests = s.todaysQuests.filter((q) => q && typeof q.id === "string").map((q) => ({ id: q.id, target: num(q.target, 1), progress: num(q.progress, 0), rewarded: !!q.rewarded }));
+      if (!s.counters || typeof s.counters !== "object" || Array.isArray(s.counters)) s.counters = {};
+      for (const k of Object.keys(s.counters)) {
+        s.counters[k] = num(s.counters[k], 0);
+      }
+      s.nightTurns = num(s.nightTurns, 0);
+      s.earlyTurns = num(s.earlyTurns, 0);
+      s.xp = num(s.xp, 0);
+      if (!s.createdAt) s.createdAt = Date.now();
+      this.state = s;
+    } catch {
+      this.state = structuredClone(DEFAULT_GAME_STATE);
+      this.state.createdAt = Date.now();
+    }
+    return this.state;
+  }
+  get() {
+    return this.state;
+  }
+  set(state) {
+    this.state = state;
+    this.scheduleSave();
+  }
+  scheduleSave() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.saveNow(), 500);
+  }
+  saveNow() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    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.renameSync(tmp, this.file);
+    } catch (err) {
+      console.error("Failed to persist gamification state:", err);
+    }
+  }
+}
+const ACHIEVEMENT_XP = 25;
+class GamificationService {
+  constructor(getWin2) {
+    this.getWin = getWin2;
+    this.state = this.store.load();
+  }
+  store = new GamificationStore();
+  state;
+  /** GameState + derived level fields (for the initial renderer fetch). */
+  snapshot() {
+    return { ...this.state, ...levelInfo(this.state.xp) };
+  }
+  dispose() {
+    this.store.saveNow();
+  }
+  /**
+   * Apply one event: bump counters, roll the day (streak + quests), add XP,
+   * advance quests, unlock achievements — each guarded so nothing double-counts.
+   * Wrapped so a gamification failure can never break the caller's turn/merge.
+   */
+  award(e) {
+    try {
+      const s = this.state;
+      const now = /* @__PURE__ */ new Date();
+      const today = dayKey(now);
+      const celebrations = [];
+      if (s.streak.lastDay !== today) {
+        s.streak.current = s.streak.lastDay === prevDayKey(now) ? s.streak.current + 1 : 1;
+        s.streak.longest = Math.max(s.streak.longest, s.streak.current);
+        s.streak.lastDay = today;
+        s.todaysQuests = pickDailyQuests(today);
+        s.questDay = today;
+        if (s.streak.current >= 2) {
+          celebrations.push({
+            kind: "streak",
+            seed: `streak:${today}:${s.streak.current}`,
+            current: s.streak.current
+          });
+        }
+      }
+      s.counters[e.type] = (s.counters[e.type] ?? 0) + 1;
+      if (e.type === "session.turn" || e.type === "conductor.turn") {
+        const hour = e.meta?.hour ?? now.getHours();
+        if (hour >= 0 && hour < 5) s.nightTurns += 1;
+        else if (hour >= 5 && hour < 8) s.earlyTurns += 1;
+      }
+      const beforeLevel = levelForXp(s.xp);
+      s.xp += xpForEvent(e);
+      for (const q of s.todaysQuests) {
+        if (q.rewarded) continue;
+        const def = questDef(q.id);
+        if (!def || !def.events.includes(e.type)) continue;
+        q.progress = Math.min(q.target, q.progress + 1);
+        if (q.progress >= q.target) {
+          q.rewarded = true;
+          s.xp += def.reward;
+          celebrations.push({
+            kind: "quest",
+            seed: `quest:${today}:${q.id}`,
+            id: q.id,
+            title: def.title,
+            xp: def.reward
+          });
+        }
+      }
+      let unlockedThisPass = true;
+      while (unlockedThisPass) {
+        unlockedThisPass = false;
+        const ctx = {
+          counters: s.counters,
+          nightTurns: s.nightTurns,
+          earlyTurns: s.earlyTurns,
+          streakLongest: s.streak.longest,
+          level: levelForXp(s.xp)
+        };
+        for (const a of ACHIEVEMENTS) {
+          if (s.achievements[a.id]) continue;
+          if (a.predicate(ctx)) {
+            s.achievements[a.id] = { unlockedAt: Date.now() };
+            s.xp += ACHIEVEMENT_XP;
+            unlockedThisPass = true;
+            celebrations.push({
+              kind: "achievement",
+              seed: `ach:${a.id}`,
+              id: a.id,
+              title: a.title,
+              icon: a.icon,
+              xp: ACHIEVEMENT_XP
+            });
+          }
+        }
+      }
+      const afterLevel = levelForXp(s.xp);
+      for (let l = beforeLevel + 1; l <= afterLevel; l++) {
+        celebrations.push({ kind: "level-up", seed: `level:${l}`, level: l });
+      }
+      this.store.set(s);
+      this.broadcast();
+      for (const c2 of celebrations) this.celebrate(c2);
+    } catch (err) {
+      console.error("Gamification award failed (ignored):", err);
+    }
+  }
+  broadcast() {
+    this.getWin()?.webContents.send("gamification:changed", this.snapshot());
+  }
+  celebrate(c2) {
+    this.getWin()?.webContents.send("gamification:celebrate", c2);
+  }
+}
 const IMAGE_EXTS$1 = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
 const THUMB_HEIGHT = 64;
 const MAX_LISTED = 100;
@@ -3401,7 +4576,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, tokenEff, getWin2) {
+function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpand, conductor, factory, agents, tokenEff, gamification, getWin2) {
   const rootOf = (id) => {
     const config = sessions.getConfig(id);
     if (!config) throw new Error(`Unknown session: ${id}`);
@@ -3580,6 +4755,7 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
   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)
@@ -3608,6 +4784,16 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
   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("gamification:get", () => gamification.snapshot());
+  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(
@@ -3763,6 +4949,7 @@ 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 = {
@@ -3789,7 +4976,13 @@ const DEFAULT_SETTINGS = {
   watchdogStallMinutes: 10,
   watchdogUnansweredMinutes: 5,
   tokenEfficiency: DEFAULT_TOKEN_EFFICIENCY,
-  tokenEfficiencyRepoOverrides: {}
+  tokenEfficiencyRepoOverrides: {},
+  agentRegistryPath: "C:\\repos\\agent-factory\\registry\\registry.json",
+  theme: "dark",
+  accentColor: null,
+  gamificationEnabled: true,
+  gamificationReduceMotion: false,
+  gamificationSound: false
 };
 const DEFAULT_CATEGORIES = [
   {
@@ -3959,9 +5152,11 @@ function gitHead$1(folder) {
   });
 }
 class SentinelService {
-  constructor(persistence2, getWin2) {
+  constructor(persistence2, getWin2, emitGame = () => {
+  }) {
     this.persistence = persistence2;
     this.getWin = getWin2;
+    this.emitGame = emitGame;
   }
   timer = null;
   /** Last observed HEAD per session id; baseline is set without firing. */
@@ -4141,6 +5336,7 @@ class SentinelService {
     run.summary = summary;
     run.findings = findings;
     this.broadcast(run.sessionId);
+    if (status !== "error") this.emitGame({ type: "sentinel.run" });
   }
   broadcast(sessionId) {
     this.getWin()?.webContents.send("sentinel:runs", sessionId, this.listRuns(sessionId));
@@ -4420,11 +5616,13 @@ const STATUS_PRIORITY = [
   "exited"
 ];
 class SessionManager {
-  constructor(persistence2, fs2, tokenEff, getWin2) {
+  constructor(persistence2, fs2, tokenEff, getWin2, emitGame = () => {
+  }) {
     this.persistence = persistence2;
     this.fs = fs2;
     this.tokenEff = tokenEff;
     this.getWin = getWin2;
+    this.emitGame = emitGame;
   }
   /** Keyed by terminal id, across all sessions. */
   ptys = /* @__PURE__ */ new Map();
@@ -4449,6 +5647,8 @@ class SessionManager {
   watchdog = /* @__PURE__ */ new Map();
   /** The watchdog interval; null until startWatchdog() runs. */
   watchdogTimer = null;
+  /** Per-terminal last status, used only to award a turn on the working→done edge. */
+  lastStatusForAward = /* @__PURE__ */ new Map();
   get state() {
     return this.persistence.state;
   }
@@ -4460,12 +5660,12 @@ class SessionManager {
   }
   categoryOf(config) {
     if (!config.categoryId) return null;
-    return this.state.categories.find((c) => c.id === config.categoryId) ?? null;
+    return this.state.categories.find((c2) => c2.id === config.categoryId) ?? null;
   }
   /** Every MCP server name owned by any category — our materialization namespace. */
   managedServerNames() {
     const names = /* @__PURE__ */ new Set();
-    for (const c of this.state.categories) for (const s of c.mcpServers) names.add(s.name);
+    for (const c2 of this.state.categories) for (const s of c2.mcpServers) names.add(s.name);
     return [...names];
   }
   /**
@@ -4516,6 +5716,7 @@ class SessionManager {
     for (const terminal of config.terminals) this.spawnTerminal(config, terminal, "fresh");
     this.fs.start(config.id, config.folder, []);
     this.notifyChanged();
+    this.emitGame({ type: "session.create" });
     return this.toInfo(config);
   }
   close(id) {
@@ -4605,7 +5806,9 @@ class SessionManager {
   async createCheckpoint(sessionId, label) {
     const config = this.getConfig(sessionId);
     if (!config) throw new Error("Unknown session");
-    return createCheckpoint(config.folder, label);
+    const checkpoint = await createCheckpoint(config.folder, label);
+    this.emitGame({ type: "checkpoint.create" });
+    return checkpoint;
   }
   /** Recent checkpoints for a session's repo, newest first. */
   async listCheckpoints(sessionId) {
@@ -4713,6 +5916,7 @@ class SessionManager {
       }, INITIAL_PROMPT_DELAY_MS);
     }
     this.notifyChanged();
+    this.emitGame({ type: "worktree.create" });
     return this.toInfo(config);
   }
   /** Live git facts about a worktree task (uncommitted files, commits ahead). */
@@ -4794,7 +5998,12 @@ ${commit.output}` };
     }
     const result = await mergeBranch(baseFolder, branch, baseBranch);
     if (!result.ok) return { ...result, autoCommitted };
-    return { ...await this.pushAfterMerge(result, baseFolder, baseBranch), autoCommitted };
+    const merged = { ...await this.pushAfterMerge(result, baseFolder, baseBranch), autoCommitted };
+    this.emitGame({ type: "worktree.merge", meta: { commits: ahead ?? 0 } });
+    if (this.state.features.some((f) => f.taskSessionId === sessionId)) {
+      this.emitGame({ type: "feature.merge" });
+    }
+    return merged;
   }
   /** True if `branch` is the dedicated expansion branch of any auto-expand config. */
   isAutoExpandBranch(branch) {
@@ -4889,6 +6098,7 @@ ${commit.output}` };
     const title = prTitle(config.name, branch);
     const body = prBody(config.name, branch, baseBranch);
     const result = await createPullRequest(config.folder, branch, baseBranch, title, body);
+    if (result.ok) this.emitGame({ type: "worktree.pr" });
     return { ...result, autoCommitted };
   }
   // ---------- auto-complete (auto-merge / auto-PR when claude finishes) --------
@@ -5173,6 +6383,7 @@ ${err.message}`
     const action = this.state.actions.find((a) => a.id === actionId);
     const command = action?.command.trim();
     if (!config || !action || !command) return null;
+    this.emitGame({ type: "action.run" });
     if (action.shell === "claude") return this.runClaudeAction(config, command);
     let terminal = config.terminals.find((t) => t.actionId === action.id);
     let respawned = false;
@@ -5415,6 +6626,11 @@ ${err.message}`
     if (!config) return;
     const terminal = config.terminals.find((t) => t.id === terminalId);
     if (!terminal || terminal.kind !== "claude") return;
+    const prevForAward = this.lastStatusForAward.get(terminalId);
+    this.lastStatusForAward.set(terminalId, status);
+    if (status === "done" && prevForAward === "working") {
+      this.emitGame({ type: "session.turn" });
+    }
     if (status === "done" || status === "idle") this.scheduleQueueDispatch(config.id);
     if (config.worktree?.autoComplete) {
       if (status === "working") this.worktreeWorked.add(config.id);
@@ -6419,17 +7635,27 @@ if (!gotLock) {
   electron.app.whenReady().then(() => {
     electron.app.setAppUserModelId("com.pedroferreira.maestro");
     persistence.load();
+    const gameBus = new events.EventEmitter();
+    const emitGame = (e) => {
+      try {
+        gameBus.emit("game", e);
+      } catch {
+      }
+    };
     const fsService = new FsService(
-      (sessionId, events) => getWin()?.webContents.send("fs:events", sessionId, events),
+      (sessionId, events2) => getWin()?.webContents.send("fs:events", sessionId, events2),
       () => persistence.state.settings.ignoreNames
     );
     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 sessions = new SessionManager(persistence, fsService, tokenEff, getWin, emitGame);
+    const sentinels = new SentinelService(persistence, getWin, emitGame);
+    const features = new FeatureService(persistence, sessions, emitGame);
+    const autoExpand = new AutoExpandService(persistence, features, getWin, emitGame);
     const conductor = new ConductorService(persistence, sessions, features, autoExpand, getWin);
-    const factory = new FactoryService(getWin);
+    const factory = new FactoryService(getWin, emitGame);
+    const agentRegistry = new AgentRegistryService(persistence, getWin);
+    const gamification = new GamificationService(getWin);
+    gameBus.on("game", (e) => gamification.award(e));
     registerIpc(
       sessions,
       fsService,
@@ -6439,7 +7665,9 @@ if (!gotLock) {
       autoExpand,
       conductor,
       factory,
+      agentRegistry,
       tokenEff,
+      gamification,
       getWin
     );
     createWindow();
@@ -6448,11 +7676,18 @@ if (!gotLock) {
     sentinels.start();
     autoExpand.start();
     tokenEff.start();
+    factory.start();
+    conductor.onTurnComplete((messages) => {
+      factory.considerConversation(messages);
+      emitGame({ type: "conductor.turn" });
+    });
     electron.app.on("activate", () => {
       if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
     });
     electron.app.on("before-quit", () => {
       tokenEff.dispose();
+      agentRegistry.dispose();
+      gamification.dispose();
       factory.dispose();
       conductor.dispose();
       autoExpand.dispose();