claude-maestro 0.1.18 → 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(
@@ -1035,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;
@@ -1064,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() {
@@ -1431,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;
   }
@@ -1508,6 +1788,12 @@ class ConductorService {
       this.inFlight = null;
       this.busy = false;
       this.persistAndBroadcast();
+      if (!assistantMsg.error) {
+        try {
+          this.turnCompleteCb?.(this.messages);
+        } catch {
+        }
+      }
     }
   }
   /**
@@ -2101,12 +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 {
@@ -2114,12 +2409,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 +2432,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 +2446,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 +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, 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 +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",
@@ -2177,16 +2508,40 @@ class FactoryService {
     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()/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 +2549,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 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;
@@ -2221,24 +3014,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 +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 = [];
@@ -2286,30 +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;
+    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 +3149,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 = [
@@ -2432,13 +3265,13 @@ Lessons learned (respect these):
     const candidate = run?.candidates.find((c) => c.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 +3307,7 @@ Lessons learned (respect these):
       }
     } finally {
       this.inFlight = null;
-      this.busy = false;
+      this.setBusy(false);
       this.broadcastRuns();
       this.broadcastState();
     }
@@ -2722,6 +3555,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);
@@ -3401,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, tokenEff, 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}`);
@@ -3580,6 +4435,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 +4464,15 @@ 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("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 +4628,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 +4655,8 @@ const DEFAULT_SETTINGS = {
   watchdogStallMinutes: 10,
   watchdogUnansweredMinutes: 5,
   tokenEfficiency: DEFAULT_TOKEN_EFFICIENCY,
-  tokenEfficiencyRepoOverrides: {}
+  tokenEfficiencyRepoOverrides: {},
+  agentRegistryPath: "C:\\repos\\agent-factory\\registry\\registry.json"
 };
 const DEFAULT_CATEGORIES = [
   {
@@ -6430,6 +7297,7 @@ if (!gotLock) {
     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,
@@ -6439,6 +7307,7 @@ if (!gotLock) {
       autoExpand,
       conductor,
       factory,
+      agentRegistry,
       tokenEff,
       getWin
     );
@@ -6448,11 +7317,14 @@ if (!gotLock) {
     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();