@limno/core 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -59,8 +59,8 @@ function jsxName(name) {
   return `${jsxName(name.object)}.${name.property.name}`;
 }
 var isCapitalized = (s) => /^[A-Z]/.test(s);
-function componentName(path5, fileBase) {
-  let p = path5.getFunctionParent();
+function componentName(path6, fileBase) {
+  let p = path6.getFunctionParent();
   while (p) {
     const node = p.node;
     let name;
@@ -102,8 +102,8 @@ function stampSource(code, id, relFile) {
   const fileBase = relFile.split("/").pop().replace(/\.[jt]sx?$/, "").replace(/^./, (c) => c.toUpperCase());
   let touched = false;
   traverse(ast, {
-    JSXOpeningElement(path5) {
-      const node = path5.node;
+    JSXOpeningElement(path6) {
+      const node = path6.node;
       const loc = node.loc;
       if (!loc || node.name.end == null) return;
       const name = jsxName(node.name);
@@ -111,7 +111,7 @@ function stampSource(code, id, relFile) {
       const host = node.name.type === "JSXIdentifier" && !isCapitalized(name);
       if (host) {
         if (hasAttr(node, "data-limno-src")) return;
-        const comp = componentName(path5, fileBase);
+        const comp = componentName(path6, fileBase);
         s.appendLeft(node.name.end, ` data-limno-src="${escapeAttr(where)}"${comp ? ` data-limno-comp="${escapeAttr(comp)}"` : ""}`);
         touched = true;
       } else {
@@ -223,16 +223,101 @@ async function stampTemplate(code, id, relFile, root) {
 
 // src/service.ts
 var import_node_crypto = require("crypto");
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_module3 = require("module");
-var import_node_path4 = __toESM(require("path"), 1);
-var import_spec = require("@limno/spec");
+var import_node_path5 = __toESM(require("path"), 1);
+var import_spec2 = require("@limno/spec");
 
 // src/runner.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_spec = require("@limno/spec");
+
+// src/history.ts
 var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
-var import_node_os = __toESM(require("os"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
+var KEEP = 20;
+function runsFile(folder) {
+  return import_node_path2.default.join(folder, "runs.json");
+}
+function readRuns(folder) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(runsFile(folder), "utf8")).runs ?? [];
+  } catch {
+    return [];
+  }
+}
+function writeRuns(folder, runs) {
+  (0, import_node_fs.mkdirSync)(folder, { recursive: true });
+  const file = runsFile(folder);
+  const tmp = `${file}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(tmp, `${JSON.stringify({ runs: runs.slice(-KEEP) }, null, 2)}
+`);
+  (0, import_node_fs.renameSync)(tmp, file);
+}
+function saveRun(folder, run2) {
+  const runs = readRuns(folder).filter((r) => r.id !== run2.id);
+  writeRuns(folder, [...runs, run2]);
+}
+function git(root, args, timeoutMs = 15e3) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = (0, import_node_child_process.spawn)("git", args, { cwd: root, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" }, stdio: ["ignore", "pipe", "pipe"] });
+    } catch {
+      return resolve({ code: null, out: "" });
+    }
+    const timer = setTimeout(() => child.kill(), timeoutMs);
+    child.stdout?.on("data", (d) => out += d);
+    child.stderr?.on("data", (d) => out += d);
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve({ code: null, out });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code, out });
+    });
+  });
+}
+async function isGitRepo(root) {
+  return (await git(root, ["rev-parse", "--is-inside-work-tree"])).out.trim() === "true";
+}
+async function uncommitted(root, files) {
+  if (!files.length || !await isGitRepo(root)) return [];
+  const r = await git(root, ["status", "--porcelain", "--untracked-files=all", "--", ...files]);
+  if (r.code !== 0) return [];
+  const dirty = new Set(
+    r.out.split("\n").filter(Boolean).map((l) => l.slice(3).replace(/^"|"$/g, "").split(" -> ").pop())
+  );
+  const top = (await git(root, ["rev-parse", "--show-toplevel"])).out.trim();
+  return files.filter((f) => dirty.has(top ? import_node_path2.default.relative(top, import_node_path2.default.join(root, f)) : f) || dirty.has(f));
+}
+async function commitFiles(root, files, message) {
+  if (!await isGitRepo(root)) return { ok: false, error: "This project isn\u2019t a git repository." };
+  for (const marker of ["MERGE_HEAD", "rebase-merge", "rebase-apply", "CHERRY_PICK_HEAD"]) {
+    const p = (await git(root, ["rev-parse", "--git-path", marker])).out.trim();
+    if (p && (0, import_node_fs.existsSync)(import_node_path2.default.resolve(root, p))) return { ok: false, error: "Git is in the middle of a merge or rebase." };
+  }
+  const dirty = await uncommitted(root, files);
+  if (!dirty.length) return { ok: false, error: "Nothing to commit: those files have no changes." };
+  const add = await git(root, ["add", "--", ...dirty]);
+  if (add.code !== 0) return { ok: false, error: add.out.trim().split("\n").pop() || "git add failed" };
+  const commit = await git(root, ["commit", "-m", message, "--", ...dirty], 6e4);
+  if (commit.code !== 0) return { ok: false, error: commit.out.trim().split("\n").slice(-2).join(" ") || "git commit failed" };
+  const sha = (await git(root, ["rev-parse", "--short", "HEAD"])).out.trim();
+  return { ok: true, sha };
+}
+
+// src/runner.ts
+var fullMessage = (text) => {
+  const t = String(text).trim().replace(/\n{3,}/g, "\n\n");
+  return t.length > 4e3 ? `${t.slice(0, 3999).trimEnd()}\u2026` : t;
+};
 var NAMES = { claude: "Claude Code", codex: "Codex" };
 var SIGN_IN = { claude: "claude auth login", codex: "codex login" };
 var PROMPT = [
@@ -240,26 +325,28 @@ var PROMPT = [
   "Call limno_get_changes to read the visual changes and comments waiting for you, then implement them in this project's source by following the rules it gives you.",
   "Report progress with limno_update_status, and answer comments with limno_reply.",
   "Only read and edit files inside this project. Don't run shell commands; Limno checks the result on the page itself.",
-  "Finish with one short sentence summarising what you changed."
+  "Finish with a summary the designer reads in Limno, at most two short sentences and 45 words in total:",
+  "first what you changed (or why you changed nothing); then, only if needed, what they must know or decide, as a direct question when it is one.",
+  "No file paths, no lists, nothing they already know from the change itself."
 ].join(" ");
-var trustFile = () => import_node_path2.default.join(import_node_os.default.homedir(), ".limno", "trust.json");
+var trustFile = () => import_node_path3.default.join(import_node_os.default.homedir(), ".limno", "trust.json");
 function projectKey(root) {
   try {
-    return (0, import_node_fs.realpathSync)(root);
+    return (0, import_node_fs2.realpathSync)(root);
   } catch {
     return root;
   }
 }
 function readTrust() {
   try {
-    return JSON.parse((0, import_node_fs.readFileSync)(trustFile(), "utf8")).projects ?? {};
+    return JSON.parse((0, import_node_fs2.readFileSync)(trustFile(), "utf8")).projects ?? {};
   } catch {
     return {};
   }
 }
 function writeTrust(projects) {
-  (0, import_node_fs.mkdirSync)(import_node_path2.default.dirname(trustFile()), { recursive: true });
-  (0, import_node_fs.writeFileSync)(trustFile(), `${JSON.stringify({ projects }, null, 2)}
+  (0, import_node_fs2.mkdirSync)(import_node_path3.default.dirname(trustFile()), { recursive: true });
+  (0, import_node_fs2.writeFileSync)(trustFile(), `${JSON.stringify({ projects }, null, 2)}
 `);
 }
 function run(cmd, args, timeoutMs = 8e3) {
@@ -267,7 +354,7 @@ function run(cmd, args, timeoutMs = 8e3) {
     let out = "";
     let child;
     try {
-      child = (0, import_node_child_process.spawn)(cmd, args, { env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+      child = (0, import_node_child_process2.spawn)(cmd, args, { env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     } catch {
       return resolve({ code: null, out: "" });
     }
@@ -320,20 +407,20 @@ function isLocalRequest(req) {
   return true;
 }
 function createRunner(root, folder, onState) {
-  const sessionsFile = import_node_path2.default.join(folder, "runner.json");
+  const sessionsFile = import_node_path3.default.join(folder, "runner.json");
   let child = null;
   let again = false;
   let state = { status: "idle", agent: null, startedAt: null, endedAt: null, log: [], files: [] };
   const sessions = () => {
     try {
-      return JSON.parse((0, import_node_fs.readFileSync)(sessionsFile, "utf8"));
+      return JSON.parse((0, import_node_fs2.readFileSync)(sessionsFile, "utf8"));
     } catch {
       return {};
     }
   };
   const saveSession = (agent, id) => {
-    (0, import_node_fs.mkdirSync)(folder, { recursive: true });
-    (0, import_node_fs.writeFileSync)(sessionsFile, `${JSON.stringify({ ...sessions(), [agent]: id }, null, 2)}
+    (0, import_node_fs2.mkdirSync)(folder, { recursive: true });
+    (0, import_node_fs2.writeFileSync)(sessionsFile, `${JSON.stringify({ ...sessions(), [agent]: id }, null, 2)}
 `);
   };
   let emitTimer;
@@ -351,15 +438,108 @@ function createRunner(root, folder, onState) {
   };
   const rel = (p) => {
     if (!p) return "";
-    const abs = import_node_path2.default.isAbsolute(p) ? p : import_node_path2.default.join(root, p);
-    return import_node_path2.default.relative(root, abs) || p;
+    const abs = import_node_path3.default.isAbsolute(p) ? p : import_node_path3.default.join(root, p);
+    return import_node_path3.default.relative(root, abs) || p;
   };
   const key = projectKey(root);
   const allowed = () => readTrust()[key]?.agent ?? null;
+  const autoCommitOn = () => !!readTrust()[key]?.autoCommit;
+  const changeSetFile = import_node_path3.default.join(folder, "changeset.json");
+  const readSet = () => {
+    try {
+      return JSON.parse((0, import_node_fs2.readFileSync)(changeSetFile, "utf8"));
+    } catch {
+      return null;
+    }
+  };
+  let run2 = null;
+  let committing = false;
+  const say = (line) => console.log(`\x1B[36m[limno]\x1B[0m ${line}`);
+  const list = (files) => files.length <= 3 ? files.join(", ") : `${files.slice(0, 3).join(", ")} and ${files.length - 3} more`;
+  async function finishRun(agent) {
+    const startedAt = state.startedAt;
+    const files = state.files;
+    const set = readSet();
+    const ids = run2?.changeIds ?? [];
+    const changes = (set?.changes ?? []).filter((c) => ids.includes(c.id));
+    const rec = {
+      id: run2?.id ?? String(startedAt),
+      agent: NAMES[agent],
+      startedAt: startedAt ?? Date.now(),
+      endedAt: state.endedAt ?? Date.now(),
+      status: state.status === "done" ? "done" : state.status === "stopped" ? "stopped" : "failed",
+      files,
+      changeIds: ids,
+      summary: [...state.log].reverse().find((l) => l.kind === "message")?.text,
+      message: (0, import_spec.commitMessage)(changes)
+    };
+    run2 = rec;
+    try {
+      saveRun(folder, rec);
+    } catch {
+    }
+    if (!files.length) {
+      if (rec.status === "done") say(`${NAMES[agent]} finished without editing any files.`);
+      return;
+    }
+    const dirty = await uncommitted(root, files);
+    const git2 = dirty.length > 0 || await isGitRepo(root);
+    if (state.startedAt === startedAt) {
+      state.commit = { message: rec.message, uncommitted: dirty, git: git2 };
+      emit(true);
+    }
+    const n = files.length;
+    say(`${NAMES[agent]} edited ${n} ${n === 1 ? "file" : "files"}: ${list(files)}${dirty.length ? " (not committed yet)" : ""}`);
+    if (dirty.length) {
+      say(`Commit message: ${rec.message.split("\n")[0]}`);
+      if (autoCommitOn()) say("Auto-commit is on: Limno commits these files once every change is verified on the page.");
+    }
+    if (state.startedAt === startedAt) void changeSetChanged(set);
+  }
+  async function changeSetChanged(set) {
+    const commit = state.commit;
+    if (!set || !run2 || committing || !commit || commit.committed || !commit.uncommitted.length || !autoCommitOn()) return;
+    if (state.status !== "done") return;
+    const sent = set.changes.filter((c) => run2.changeIds.includes(c.id) && c.kind !== "note");
+    if (!sent.length) return;
+    if (sent.some((c) => c.status === "differs" || c.status === "failed")) {
+      if (!commit.note) {
+        commit.note = "A change doesn\u2019t match the preview yet.";
+        const off = (0, import_spec.describeChanges)(sent.filter((c) => c.status === "differs" || c.status === "failed")).length || 1;
+        say(`Not auto-committing: ${off === 1 ? "1 change doesn\u2019t" : `${off} changes don\u2019t`} match the preview yet. Review in Limno.`);
+        emit(true);
+      }
+      return;
+    }
+    if (!sent.every((c) => c.status === "verified")) return;
+    committing = true;
+    try {
+      const r = await commitFiles(root, state.files, run2.message);
+      if (r.ok) {
+        commit.committed = { sha: r.sha, auto: true };
+        commit.uncommitted = [];
+        commit.note = void 0;
+        run2.commit = { sha: r.sha, at: Date.now(), auto: true };
+        try {
+          saveRun(folder, run2);
+        } catch {
+        }
+        say(`Committed ${state.files.length === 1 ? "1 file" : `${state.files.length} files`} as ${r.sha}: ${run2.message.split("\n")[0]} (not pushed)`);
+      } else {
+        commit.note = `Not committed: ${r.error}`;
+        say(`Didn\u2019t auto-commit: ${r.error}`);
+      }
+      emit(true);
+    } finally {
+      committing = false;
+    }
+  }
   function limnoLine(tool, input = {}) {
     if (tool.endsWith("get_changes")) return "Reading your changes";
     if (tool.endsWith("update_status")) {
-      const n = Array.isArray(input.ids) ? input.ids.length : 0;
+      const ids = Array.isArray(input.ids) ? input.ids : [];
+      const sent = (readSet()?.changes ?? []).filter((c) => ids.includes(c.id));
+      const n = sent.length ? (0, import_spec.describeChanges)(sent).length : ids.length;
       const status = String(input.status ?? "");
       return status === "implemented" ? `Marked ${n || ""} ${n === 1 ? "change" : "changes"} done`.replace("  ", " ") : status === "failed" ? "Reported a change it couldn\u2019t make" : "Working on your changes";
     }
@@ -383,7 +563,7 @@ function createRunner(root, folder, onState) {
           else if (name === "Edit" || name === "MultiEdit" || name === "Write") log({ kind: "edit", text: `Editing ${rel(input.file_path)}`, file: rel(input.file_path) });
           else if (name === "Glob" || name === "Grep") log({ kind: "search", text: "Searching the project" });
         } else if (block.type === "text" && String(block.text).trim()) {
-          log({ kind: "message", text: String(block.text).trim().split("\n")[0].slice(0, 220) });
+          log({ kind: "message", text: fullMessage(block.text) });
         }
       }
       return;
@@ -404,7 +584,7 @@ function createRunner(root, folder, onState) {
     else if (item.type === "file_change" && e.type === "item.completed") {
       for (const c of item.changes ?? []) log({ kind: "edit", text: `Editing ${rel(c.path)}`, file: rel(c.path) });
     } else if (item.type === "agent_message" && e.type === "item.completed" && item.text) {
-      log({ kind: "message", text: String(item.text).trim().split("\n")[0].slice(0, 220) });
+      log({ kind: "message", text: fullMessage(item.text) });
     } else if (item.type === "command_execution" && e.type === "item.started") {
       log({ kind: "search", text: "Looking through the project" });
     }
@@ -451,7 +631,7 @@ function createRunner(root, folder, onState) {
     return resume ? ["exec", ...opts, "resume", resume, PROMPT] : ["exec", ...opts, PROMPT];
   }
   function launch(agent, resume) {
-    const proc = (0, import_node_child_process.spawn)(agent, args(agent, resume), { cwd: root, env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+    const proc = (0, import_node_child_process2.spawn)(agent, args(agent, resume), { cwd: root, env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     child = proc;
     let buf = "";
     let stderr = "";
@@ -486,7 +666,11 @@ function createRunner(root, folder, onState) {
         launch(agent);
         return;
       }
-      if (state.status === "stopped") return emit(true);
+      if (state.status === "stopped") {
+        emit(true);
+        void finishRun(agent);
+        return;
+      }
       const failed = code !== 0 || !!state.error;
       const tail = stderr.trim().split("\n").filter(Boolean).slice(-2).join(" ").slice(0, 300);
       state = {
@@ -496,6 +680,7 @@ function createRunner(root, folder, onState) {
         error: failed ? state.error ?? (tail || `${NAMES[agent]} exited${signal ? ` (${signal})` : ` with code ${code}`}`) : void 0
       };
       emit(true);
+      void finishRun(agent);
       if (again && !failed) {
         again = false;
         void start();
@@ -514,16 +699,32 @@ function createRunner(root, folder, onState) {
     if (!info?.installed) return { ok: false, error: `${NAMES[agent]} isn\u2019t installed on this computer.` };
     if (!info.signedIn) return { ok: false, error: `${NAMES[agent]} isn\u2019t signed in. Run \u201C${SIGN_IN[agent]}\u201D in a terminal, then send again.` };
     state = { status: "starting", agent, startedAt: Date.now(), endedAt: null, log: [], files: [] };
+    const queued = (readSet()?.changes ?? []).filter((c) => c.enabled && ["queued", "in_progress", "differs", "failed"].includes(c.status)).map((c) => c.id);
+    run2 = { id: String(state.startedAt), agent: NAMES[agent], startedAt: state.startedAt, endedAt: 0, status: "done", files: [], changeIds: queued, message: "" };
     emit(true);
     launch(agent, sessions()[agent]);
     return { ok: true };
   }
   return {
     async info(force) {
-      return { agents: await detectAgents(force), allowed: allowed(), state };
+      if (state.commit && !state.commit.committed && state.commit.uncommitted.length && !child) {
+        state.commit = { ...state.commit, uncommitted: await uncommitted(root, state.files) };
+      }
+      return { agents: await detectAgents(force), allowed: allowed(), autoCommit: autoCommitOn(), state };
+    },
+    setAutoCommit(on) {
+      const t = readTrust();
+      if (!t[key]) return;
+      t[key] = { ...t[key], autoCommit: on };
+      writeTrust(t);
+      if (on) void changeSetChanged(readSet());
+    },
+    changeSetChanged(set) {
+      void changeSetChanged(set);
     },
     allow(agent) {
-      writeTrust({ ...readTrust(), [key]: { agent, at: Date.now() } });
+      const prev = readTrust()[key];
+      writeTrust({ ...readTrust(), [key]: { agent, at: Date.now(), autoCommit: prev?.autoCommit } });
     },
     forget() {
       const t = readTrust();
@@ -547,11 +748,11 @@ function createRunner(root, folder, onState) {
 }
 
 // src/update.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs2 = require("fs");
+var import_node_child_process3 = require("child_process");
+var import_node_fs3 = require("fs");
 var import_node_module2 = require("module");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var require2 = (0, import_node_module2.createRequire)(importMetaUrl);
 var TTL = 60 * 60 * 1e3;
 function currentVersion() {
@@ -563,7 +764,7 @@ function currentVersion() {
 }
 function installedVersion(fallback) {
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(require2.resolve("../package.json"), "utf8")).version;
+    return JSON.parse((0, import_node_fs3.readFileSync)(require2.resolve("../package.json"), "utf8")).version;
   } catch {
     return fallback;
   }
@@ -577,18 +778,18 @@ var newer = (a, b) => {
 function packageManager(root) {
   let dir = root;
   for (; ; ) {
-    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "yarn.lock"))) return "yarn";
-    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "bun.lockb")) || (0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "bun.lock"))) return "bun";
-    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(dir, "package-lock.json"))) return "npm";
-    const up = import_node_path3.default.dirname(dir);
+    if ((0, import_node_fs3.existsSync)(import_node_path4.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if ((0, import_node_fs3.existsSync)(import_node_path4.default.join(dir, "yarn.lock"))) return "yarn";
+    if ((0, import_node_fs3.existsSync)(import_node_path4.default.join(dir, "bun.lockb")) || (0, import_node_fs3.existsSync)(import_node_path4.default.join(dir, "bun.lock"))) return "bun";
+    if ((0, import_node_fs3.existsSync)(import_node_path4.default.join(dir, "package-lock.json"))) return "npm";
+    const up = import_node_path4.default.dirname(dir);
     if (up === dir) return "npm";
     dir = up;
   }
 }
 function listedPackages(root) {
   try {
-    const pkg = JSON.parse((0, import_node_fs2.readFileSync)(import_node_path3.default.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs3.readFileSync)(import_node_path4.default.join(root, "package.json"), "utf8"));
     return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).filter((n) => n.startsWith("@limno/") && n !== "@limno/cli");
   } catch {
     return [];
@@ -601,10 +802,10 @@ function installArgs(pm, pkgs) {
   if (pm === "bun") return ["bun", ["add", "-d", ...at]];
   return ["npm", ["install", "-D", ...at]];
 }
-var cacheFile = () => import_node_path3.default.join(import_node_os2.default.homedir(), ".limno", "update-check.json");
+var cacheFile = () => import_node_path4.default.join(import_node_os2.default.homedir(), ".limno", "update-check.json");
 async function latestVersion() {
   try {
-    const cached = JSON.parse((0, import_node_fs2.readFileSync)(cacheFile(), "utf8"));
+    const cached = JSON.parse((0, import_node_fs3.readFileSync)(cacheFile(), "utf8"));
     if (Date.now() - cached.at < TTL) return cached.latest;
   } catch {
   }
@@ -613,8 +814,8 @@ async function latestVersion() {
     if (!res.ok) return null;
     const latest = (await res.json()).latest ?? null;
     if (latest) {
-      (0, import_node_fs2.mkdirSync)(import_node_path3.default.dirname(cacheFile()), { recursive: true });
-      (0, import_node_fs2.writeFileSync)(cacheFile(), JSON.stringify({ at: Date.now(), latest }));
+      (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(cacheFile()), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(cacheFile(), JSON.stringify({ at: Date.now(), latest }));
     }
     return latest;
   } catch {
@@ -641,14 +842,14 @@ function createUpdater(root) {
     const [cmd, args] = installArgs(packageManager(root), pkgs);
     installing = new Promise((resolve) => {
       let output = "";
-      const child = (0, import_node_child_process2.spawn)(cmd, args, { cwd: root, env: process.env, shell: process.platform === "win32" });
+      const child = (0, import_node_child_process3.spawn)(cmd, args, { cwd: root, env: process.env, shell: process.platform === "win32" });
       child.stdout?.on("data", (d) => output += d);
       child.stderr?.on("data", (d) => output += d);
       child.on("error", (e) => resolve({ ok: false, output: String(e) }));
       child.on("close", (code) => {
         if (code === 0) {
           try {
-            (0, import_node_fs2.writeFileSync)(cacheFile(), JSON.stringify({ at: 0, latest: "" }));
+            (0, import_node_fs3.writeFileSync)(cacheFile(), JSON.stringify({ at: 0, latest: "" }));
           } catch {
           }
         }
@@ -668,16 +869,16 @@ var require3 = (0, import_node_module3.createRequire)(importMetaUrl);
 var STALE_MS = 3e4;
 function readJson(file) {
   try {
-    return JSON.parse((0, import_node_fs3.readFileSync)(file, "utf8"));
+    return JSON.parse((0, import_node_fs4.readFileSync)(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeAtomic(file, data) {
-  (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(file), { recursive: true });
+  (0, import_node_fs4.mkdirSync)(import_node_path5.default.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  (0, import_node_fs3.writeFileSync)(tmp, data);
-  (0, import_node_fs3.renameSync)(tmp, file);
+  (0, import_node_fs4.writeFileSync)(tmp, data);
+  (0, import_node_fs4.renameSync)(tmp, file);
 }
 function body(req) {
   return new Promise((resolve, reject) => {
@@ -698,9 +899,9 @@ function overlayFile() {
   return require3.resolve("@limno/overlay/dist/overlay.js");
 }
 function createLimnoService({ root, dir = ".limno" }) {
-  const folder = import_node_path4.default.join(root, dir);
-  const file = import_node_path4.default.join(folder, "changeset.json");
-  const presenceFile = import_node_path4.default.join(folder, "agent.json");
+  const folder = import_node_path5.default.join(root, dir);
+  const file = import_node_path5.default.join(folder, "changeset.json");
+  const presenceFile = import_node_path5.default.join(folder, "agent.json");
   let lastWrittenHash = "";
   const clients = /* @__PURE__ */ new Set();
   function broadcast(event, data) {
@@ -729,23 +930,23 @@ data: ${JSON.stringify(data)}
     return { connected, client: connected ? presence?.client ?? null : null, lastSeen: presence?.lastSeen ?? null, setup: setupInfo() };
   }
   function installConfig(target) {
-    const dest = target === "claude" ? import_node_path4.default.join(root, ".mcp.json") : import_node_path4.default.join(root, ".cursor", "mcp.json");
+    const dest = target === "claude" ? import_node_path5.default.join(root, ".mcp.json") : import_node_path5.default.join(root, ".cursor", "mcp.json");
     let config = {};
-    if ((0, import_node_fs3.existsSync)(dest)) {
+    if ((0, import_node_fs4.existsSync)(dest)) {
       try {
-        config = JSON.parse((0, import_node_fs3.readFileSync)(dest, "utf8"));
+        config = JSON.parse((0, import_node_fs4.readFileSync)(dest, "utf8"));
       } catch {
-        throw new Error(`${import_node_path4.default.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
+        throw new Error(`${import_node_path5.default.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
       }
     }
     const { command, args } = setupInfo();
     const portable = args.map((a, i) => {
       if (args[i - 1] === "--root") return ".";
-      return import_node_path4.default.isAbsolute(a) ? import_node_path4.default.relative(root, a).split(import_node_path4.default.sep).join("/") : a;
+      return import_node_path5.default.isAbsolute(a) ? import_node_path5.default.relative(root, a).split(import_node_path5.default.sep).join("/") : a;
     });
     config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
     writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
-    return import_node_path4.default.relative(root, dest);
+    return import_node_path5.default.relative(root, dest);
   }
   let lastAgent = "";
   function pushAgent() {
@@ -756,12 +957,13 @@ data: ${JSON.stringify(data)}
     broadcast("agent", status);
   }
   function onChangeSetFile() {
-    const raw = (0, import_node_fs3.existsSync)(file) ? (0, import_node_fs3.readFileSync)(file, "utf8") : "";
+    const raw = (0, import_node_fs4.existsSync)(file) ? (0, import_node_fs4.readFileSync)(file, "utf8") : "";
     if (!raw || hash(raw) === lastWrittenHash) return;
     const set = readJson(file);
     if (set) broadcast("changeset", set);
+    runner.changeSetChanged(set);
   }
-  (0, import_node_fs3.mkdirSync)(folder, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(folder, { recursive: true });
   let watcher = null;
   let watchedIno = -1;
   let debounce;
@@ -769,8 +971,8 @@ data: ${JSON.stringify(data)}
     watcher?.close();
     watcher = null;
     try {
-      watchedIno = (0, import_node_fs3.statSync)(folder).ino;
-      watcher = (0, import_node_fs3.watch)(folder, (_event, name) => {
+      watchedIno = (0, import_node_fs4.statSync)(folder).ino;
+      watcher = (0, import_node_fs4.watch)(folder, (_event, name) => {
         if (!name || name.endsWith(".tmp")) return;
         clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -786,7 +988,7 @@ data: ${JSON.stringify(data)}
   const presenceTimer = setInterval(() => {
     let ino = -1;
     try {
-      ino = (0, import_node_fs3.statSync)(folder).ino;
+      ino = (0, import_node_fs4.statSync)(folder).ino;
     } catch {
     }
     if (ino !== -1 && ino !== watchedIno) {
@@ -803,8 +1005,8 @@ data: ${JSON.stringify(data)}
   async function openInEditor(spec) {
     const m = /^(.*?)(?::(\d+))?(?::(\d+))?$/.exec(spec);
     if (!m) return false;
-    const target = import_node_path4.default.resolve(root, m[1]);
-    if (!target.startsWith(root + import_node_path4.default.sep) || !(0, import_node_fs3.existsSync)(target)) return false;
+    const target = import_node_path5.default.resolve(root, m[1]);
+    if (!target.startsWith(root + import_node_path5.default.sep) || !(0, import_node_fs4.existsSync)(target)) return false;
     const { default: launch } = await import("launch-editor");
     launch(`${target}${m[2] ? `:${m[2]}` : ""}${m[3] ? `:${m[3]}` : ""}`);
     return true;
@@ -814,7 +1016,7 @@ data: ${JSON.stringify(data)}
     if (!url.startsWith(ROUTE)) return next ? next() : send(res, 404, { error: "not found" });
     try {
       if (url === `${ROUTE}/overlay.js`) {
-        return send(res, 200, (0, import_node_fs3.readFileSync)(overlayFile(), "utf8"), "text/javascript");
+        return send(res, 200, (0, import_node_fs4.readFileSync)(overlayFile(), "utf8"), "text/javascript");
       }
       if (url === `${ROUTE}/events`) {
         res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive" });
@@ -824,20 +1026,21 @@ data: ${JSON.stringify(data)}
         return;
       }
       if (url === `${ROUTE}/changeset` && req.method === "GET") {
-        return send(res, 200, readJson(file) ?? (0, import_spec.emptyChangeSet)());
+        return send(res, 200, readJson(file) ?? (0, import_spec2.emptyChangeSet)());
       }
       if (url === `${ROUTE}/changeset` && req.method === "PUT") {
         const incoming = JSON.parse(await body(req));
-        const merged = (0, import_spec.mergeStatuses)(incoming, readJson(file));
+        const merged = (0, import_spec2.mergeStatuses)(incoming, readJson(file));
         merged.updatedAt = Date.now();
         const raw = JSON.stringify(merged, null, 2);
         lastWrittenHash = hash(raw);
         writeAtomic(file, raw);
+        runner.changeSetChanged(merged);
         return send(res, 200, merged);
       }
       if (url === `${ROUTE}/prompt` && req.method === "GET") {
-        const set = readJson(file) ?? (0, import_spec.emptyChangeSet)();
-        return send(res, 200, (0, import_spec.renderPrompt)(set, { mcp: false, statuses: ["draft", "queued", "in_progress", "differs", "failed"] }), "text/markdown; charset=utf-8");
+        const set = readJson(file) ?? (0, import_spec2.emptyChangeSet)();
+        return send(res, 200, (0, import_spec2.renderPrompt)(set, { mcp: false, statuses: ["draft", "queued", "in_progress", "differs", "failed"] }), "text/markdown; charset=utf-8");
       }
       if (url === `${ROUTE}/agent` && req.method === "GET") {
         return send(res, 200, agentStatus());
@@ -874,6 +1077,11 @@ data: ${JSON.stringify(data)}
           runner.forget();
           return send(res, 200, await runner.info());
         }
+        if (action === "autocommit") {
+          const { on } = JSON.parse(await body(req));
+          runner.setAutoCommit(!!on);
+          return send(res, 200, await runner.info());
+        }
         if (action === "run") return send(res, 200, await runner.start());
         if (action === "stop") {
           runner.stop();
@@ -885,7 +1093,7 @@ data: ${JSON.stringify(data)}
         return send(res, await openInEditor(spec) ? 200 : 404, { ok: true });
       }
       if (url === `${ROUTE}/info`) {
-        return send(res, 200, { name: "limno", root, file: import_node_path4.default.relative(root, file) });
+        return send(res, 200, { name: "limno", root, file: import_node_path5.default.relative(root, file) });
       }
       send(res, 404, { error: "not found" });
     } catch (err) {