claude-maestro 0.1.19 → 0.1.20

package/out/main/index.js

@@ -1,5 +1,6 @@
 "use strict";
 const electron = require("electron");
+const events = require("events");
 const path = require("path");
 const fs = require("fs");
 const os = require("os");
@@ -1009,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;
@@ -1323,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. */
@@ -1523,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));
@@ -2021,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,
@@ -2031,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,
@@ -2052,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,
@@ -2504,8 +2508,10 @@ 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) {
@@ -2623,23 +2629,23 @@ class FactoryService {
   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;
+    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: c.kind,
-        name: c.name,
-        title: c.description,
-        description: c.description,
-        rationale: c.rationale,
+        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: c.topics,
-        keywords: c.keywords,
-        existing: c.existing,
+        topics: c2.topics,
+        keywords: c2.keywords,
+        existing: c2.existing,
         confidence: 0.8
       });
       added++;
@@ -3262,7 +3268,7 @@ 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.setBusy(true);
@@ -3316,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();
@@ -3423,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)) {
@@ -3590,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;
       }
     }
   }
@@ -3626,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;
@@ -3649,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) {
@@ -3842,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;
@@ -4256,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, agents, 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}`);
@@ -4469,6 +4789,7 @@ function registerIpc(sessions, fs2, persistence2, sentinels, features, autoExpan
     (_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));
@@ -4656,7 +4977,12 @@ const DEFAULT_SETTINGS = {
   watchdogUnansweredMinutes: 5,
   tokenEfficiency: DEFAULT_TOKEN_EFFICIENCY,
   tokenEfficiencyRepoOverrides: {},
-  agentRegistryPath: "C:\\repos\\agent-factory\\registry\\registry.json"
+  agentRegistryPath: "C:\\repos\\agent-factory\\registry\\registry.json",
+  theme: "dark",
+  accentColor: null,
+  gamificationEnabled: true,
+  gamificationReduceMotion: false,
+  gamificationSound: false
 };
 const DEFAULT_CATEGORIES = [
   {
@@ -4826,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. */
@@ -5008,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));
@@ -5287,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();
@@ -5316,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;
   }
@@ -5327,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];
   }
   /**
@@ -5383,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) {
@@ -5472,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) {
@@ -5580,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). */
@@ -5661,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) {
@@ -5756,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) --------
@@ -6040,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;
@@ -6282,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);
@@ -7286,18 +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,
@@ -7309,6 +7667,7 @@ if (!gotLock) {
       factory,
       agentRegistry,
       tokenEff,
+      gamification,
       getWin
     );
     createWindow();
@@ -7318,13 +7677,17 @@ if (!gotLock) {
     autoExpand.start();
     tokenEff.start();
     factory.start();
-    conductor.onTurnComplete((messages) => factory.considerConversation(messages));
+    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();