@limno/core 0.1.9 → 0.1.11

package/dist/index.d.cts

@@ -101,11 +101,29 @@ interface RunnerState {
     /** Project-relative files the agent edited in this run. */
     files: string[];
     error?: string;
+    /** After a run that edited files: what to commit, and whether it has been. */
+    commit?: RunCommit;
+}
+interface RunCommit {
+    message: string;
+    /** Edited files git still sees as changed. Empty once they're committed. */
+    uncommitted: string[];
+    /** The project is a git repository. */
+    git: boolean;
+    /** Limno committed them (auto-commit). */
+    committed?: {
+        sha: string;
+        auto: boolean;
+    };
+    /** Why an auto-commit didn't happen. */
+    note?: string;
 }
 interface RunnerInfo {
     agents: RunnerAgent[];
     /** The agent this user allowed Limno to run on this project, if any. */
     allowed: RunnerAgentId | null;
+    /** Commit the agent's files once Limno has verified every change (never pushes). */
+    autoCommit: boolean;
     state: RunnerState;
 }
 /**

package/dist/index.d.ts

@@ -101,11 +101,29 @@ interface RunnerState {
     /** Project-relative files the agent edited in this run. */
     files: string[];
     error?: string;
+    /** After a run that edited files: what to commit, and whether it has been. */
+    commit?: RunCommit;
+}
+interface RunCommit {
+    message: string;
+    /** Edited files git still sees as changed. Empty once they're committed. */
+    uncommitted: string[];
+    /** The project is a git repository. */
+    git: boolean;
+    /** Limno committed them (auto-commit). */
+    committed?: {
+        sha: string;
+        auto: boolean;
+    };
+    /** Why an auto-commit didn't happen. */
+    note?: string;
 }
 interface RunnerInfo {
     agents: RunnerAgent[];
     /** The agent this user allowed Limno to run on this project, if any. */
     allowed: RunnerAgentId | null;
+    /** Commit the agent's files once Limno has verified every change (never pushes). */
+    autoCommit: boolean;
     state: RunnerState;
 }
 /**

package/dist/index.js

@@ -10,8 +10,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;
@@ -53,8 +53,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);
@@ -62,7 +62,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 {
@@ -174,16 +174,101 @@ async function stampTemplate(code, id, relFile, root) {
 
 // src/service.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, statSync, watch, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, statSync, watch, writeFileSync as writeFileSync4 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path4 from "path";
+import path5 from "path";
 import { emptyChangeSet, mergeStatuses, renderPrompt } from "@limno/spec";
 
 // src/runner.ts
-import { spawn } from "child_process";
-import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync, writeFileSync as writeFileSync2 } from "fs";
 import os from "os";
+import path3 from "path";
+import { commitMessage, describeChanges } from "@limno/spec";
+
+// src/history.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import path2 from "path";
+var KEEP = 20;
+function runsFile(folder) {
+  return path2.join(folder, "runs.json");
+}
+function readRuns(folder) {
+  try {
+    return JSON.parse(readFileSync(runsFile(folder), "utf8")).runs ?? [];
+  } catch {
+    return [];
+  }
+}
+function writeRuns(folder, runs) {
+  mkdirSync(folder, { recursive: true });
+  const file = runsFile(folder);
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify({ runs: runs.slice(-KEEP) }, null, 2)}
+`);
+  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 = 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 ? path2.relative(top, path2.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 && existsSync(path2.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 = [
@@ -191,9 +276,11 @@ 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 = () => path2.join(os.homedir(), ".limno", "trust.json");
+var trustFile = () => path3.join(os.homedir(), ".limno", "trust.json");
 function projectKey(root) {
   try {
     return realpathSync(root);
@@ -203,14 +290,14 @@ function projectKey(root) {
 }
 function readTrust() {
   try {
-    return JSON.parse(readFileSync(trustFile(), "utf8")).projects ?? {};
+    return JSON.parse(readFileSync2(trustFile(), "utf8")).projects ?? {};
   } catch {
     return {};
   }
 }
 function writeTrust(projects) {
-  mkdirSync(path2.dirname(trustFile()), { recursive: true });
-  writeFileSync(trustFile(), `${JSON.stringify({ projects }, null, 2)}
+  mkdirSync2(path3.dirname(trustFile()), { recursive: true });
+  writeFileSync2(trustFile(), `${JSON.stringify({ projects }, null, 2)}
 `);
 }
 function run(cmd, args, timeoutMs = 8e3) {
@@ -218,7 +305,7 @@ function run(cmd, args, timeoutMs = 8e3) {
     let out = "";
     let child;
     try {
-      child = spawn(cmd, args, { env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+      child = spawn2(cmd, args, { env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     } catch {
       return resolve({ code: null, out: "" });
     }
@@ -271,20 +358,20 @@ function isLocalRequest(req) {
   return true;
 }
 function createRunner(root, folder, onState) {
-  const sessionsFile = path2.join(folder, "runner.json");
+  const sessionsFile = path3.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(readFileSync(sessionsFile, "utf8"));
+      return JSON.parse(readFileSync2(sessionsFile, "utf8"));
     } catch {
       return {};
     }
   };
   const saveSession = (agent, id) => {
-    mkdirSync(folder, { recursive: true });
-    writeFileSync(sessionsFile, `${JSON.stringify({ ...sessions(), [agent]: id }, null, 2)}
+    mkdirSync2(folder, { recursive: true });
+    writeFileSync2(sessionsFile, `${JSON.stringify({ ...sessions(), [agent]: id }, null, 2)}
 `);
   };
   let emitTimer;
@@ -302,15 +389,108 @@ function createRunner(root, folder, onState) {
   };
   const rel = (p) => {
     if (!p) return "";
-    const abs = path2.isAbsolute(p) ? p : path2.join(root, p);
-    return path2.relative(root, abs) || p;
+    const abs = path3.isAbsolute(p) ? p : path3.join(root, p);
+    return path3.relative(root, abs) || p;
   };
   const key = projectKey(root);
   const allowed = () => readTrust()[key]?.agent ?? null;
+  const autoCommitOn = () => !!readTrust()[key]?.autoCommit;
+  const changeSetFile = path3.join(folder, "changeset.json");
+  const readSet = () => {
+    try {
+      return JSON.parse(readFileSync2(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: 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 = 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 ? 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";
     }
@@ -334,7 +514,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;
@@ -355,7 +535,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" });
     }
@@ -402,7 +582,7 @@ function createRunner(root, folder, onState) {
     return resume ? ["exec", ...opts, "resume", resume, PROMPT] : ["exec", ...opts, PROMPT];
   }
   function launch(agent, resume) {
-    const proc = spawn(agent, args(agent, resume), { cwd: root, env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+    const proc = spawn2(agent, args(agent, resume), { cwd: root, env: agentEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     child = proc;
     let buf = "";
     let stderr = "";
@@ -437,7 +617,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 = {
@@ -447,6 +631,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();
@@ -465,16 +650,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();
@@ -498,11 +699,11 @@ function createRunner(root, folder, onState) {
 }
 
 // src/update.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import os2 from "os";
-import path3 from "path";
+import path4 from "path";
 var require2 = createRequire2(import.meta.url);
 var TTL = 60 * 60 * 1e3;
 function currentVersion() {
@@ -514,7 +715,7 @@ function currentVersion() {
 }
 function installedVersion(fallback) {
   try {
-    return JSON.parse(readFileSync2(require2.resolve("../package.json"), "utf8")).version;
+    return JSON.parse(readFileSync3(require2.resolve("../package.json"), "utf8")).version;
   } catch {
     return fallback;
   }
@@ -528,18 +729,18 @@ var newer = (a, b) => {
 function packageManager(root) {
   let dir = root;
   for (; ; ) {
-    if (existsSync(path3.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync(path3.join(dir, "yarn.lock"))) return "yarn";
-    if (existsSync(path3.join(dir, "bun.lockb")) || existsSync(path3.join(dir, "bun.lock"))) return "bun";
-    if (existsSync(path3.join(dir, "package-lock.json"))) return "npm";
-    const up = path3.dirname(dir);
+    if (existsSync2(path4.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync2(path4.join(dir, "yarn.lock"))) return "yarn";
+    if (existsSync2(path4.join(dir, "bun.lockb")) || existsSync2(path4.join(dir, "bun.lock"))) return "bun";
+    if (existsSync2(path4.join(dir, "package-lock.json"))) return "npm";
+    const up = path4.dirname(dir);
     if (up === dir) return "npm";
     dir = up;
   }
 }
 function listedPackages(root) {
   try {
-    const pkg = JSON.parse(readFileSync2(path3.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path4.join(root, "package.json"), "utf8"));
     return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).filter((n) => n.startsWith("@limno/") && n !== "@limno/cli");
   } catch {
     return [];
@@ -552,10 +753,10 @@ function installArgs(pm, pkgs) {
   if (pm === "bun") return ["bun", ["add", "-d", ...at]];
   return ["npm", ["install", "-D", ...at]];
 }
-var cacheFile = () => path3.join(os2.homedir(), ".limno", "update-check.json");
+var cacheFile = () => path4.join(os2.homedir(), ".limno", "update-check.json");
 async function latestVersion() {
   try {
-    const cached = JSON.parse(readFileSync2(cacheFile(), "utf8"));
+    const cached = JSON.parse(readFileSync3(cacheFile(), "utf8"));
     if (Date.now() - cached.at < TTL) return cached.latest;
   } catch {
   }
@@ -564,8 +765,8 @@ async function latestVersion() {
     if (!res.ok) return null;
     const latest = (await res.json()).latest ?? null;
     if (latest) {
-      mkdirSync2(path3.dirname(cacheFile()), { recursive: true });
-      writeFileSync2(cacheFile(), JSON.stringify({ at: Date.now(), latest }));
+      mkdirSync3(path4.dirname(cacheFile()), { recursive: true });
+      writeFileSync3(cacheFile(), JSON.stringify({ at: Date.now(), latest }));
     }
     return latest;
   } catch {
@@ -592,14 +793,14 @@ function createUpdater(root) {
     const [cmd, args] = installArgs(packageManager(root), pkgs);
     installing = new Promise((resolve) => {
       let output = "";
-      const child = spawn2(cmd, args, { cwd: root, env: process.env, shell: process.platform === "win32" });
+      const child = spawn3(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 {
-            writeFileSync2(cacheFile(), JSON.stringify({ at: 0, latest: "" }));
+            writeFileSync3(cacheFile(), JSON.stringify({ at: 0, latest: "" }));
           } catch {
           }
         }
@@ -619,16 +820,16 @@ var require3 = createRequire3(import.meta.url);
 var STALE_MS = 3e4;
 function readJson(file) {
   try {
-    return JSON.parse(readFileSync3(file, "utf8"));
+    return JSON.parse(readFileSync4(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeAtomic(file, data) {
-  mkdirSync3(path4.dirname(file), { recursive: true });
+  mkdirSync4(path5.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync3(tmp, data);
-  renameSync(tmp, file);
+  writeFileSync4(tmp, data);
+  renameSync2(tmp, file);
 }
 function body(req) {
   return new Promise((resolve, reject) => {
@@ -649,9 +850,9 @@ function overlayFile() {
   return require3.resolve("@limno/overlay/dist/overlay.js");
 }
 function createLimnoService({ root, dir = ".limno" }) {
-  const folder = path4.join(root, dir);
-  const file = path4.join(folder, "changeset.json");
-  const presenceFile = path4.join(folder, "agent.json");
+  const folder = path5.join(root, dir);
+  const file = path5.join(folder, "changeset.json");
+  const presenceFile = path5.join(folder, "agent.json");
   let lastWrittenHash = "";
   const clients = /* @__PURE__ */ new Set();
   function broadcast(event, data) {
@@ -680,23 +881,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" ? path4.join(root, ".mcp.json") : path4.join(root, ".cursor", "mcp.json");
+    const dest = target === "claude" ? path5.join(root, ".mcp.json") : path5.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync2(dest)) {
+    if (existsSync3(dest)) {
       try {
-        config = JSON.parse(readFileSync3(dest, "utf8"));
+        config = JSON.parse(readFileSync4(dest, "utf8"));
       } catch {
-        throw new Error(`${path4.relative(root, dest)} isn't valid JSON; fix or remove it first.`);
+        throw new Error(`${path5.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 path4.isAbsolute(a) ? path4.relative(root, a).split(path4.sep).join("/") : a;
+      return path5.isAbsolute(a) ? path5.relative(root, a).split(path5.sep).join("/") : a;
     });
     config.mcpServers = { ...config.mcpServers ?? {}, limno: { command, args: portable } };
     writeAtomic(dest, JSON.stringify(config, null, 2) + "\n");
-    return path4.relative(root, dest);
+    return path5.relative(root, dest);
   }
   let lastAgent = "";
   function pushAgent() {
@@ -707,12 +908,13 @@ data: ${JSON.stringify(data)}
     broadcast("agent", status);
   }
   function onChangeSetFile() {
-    const raw = existsSync2(file) ? readFileSync3(file, "utf8") : "";
+    const raw = existsSync3(file) ? readFileSync4(file, "utf8") : "";
     if (!raw || hash(raw) === lastWrittenHash) return;
     const set = readJson(file);
     if (set) broadcast("changeset", set);
+    runner.changeSetChanged(set);
   }
-  mkdirSync3(folder, { recursive: true });
+  mkdirSync4(folder, { recursive: true });
   let watcher = null;
   let watchedIno = -1;
   let debounce;
@@ -754,8 +956,8 @@ data: ${JSON.stringify(data)}
   async function openInEditor(spec) {
     const m = /^(.*?)(?::(\d+))?(?::(\d+))?$/.exec(spec);
     if (!m) return false;
-    const target = path4.resolve(root, m[1]);
-    if (!target.startsWith(root + path4.sep) || !existsSync2(target)) return false;
+    const target = path5.resolve(root, m[1]);
+    if (!target.startsWith(root + path5.sep) || !existsSync3(target)) return false;
     const { default: launch } = await import("launch-editor");
     launch(`${target}${m[2] ? `:${m[2]}` : ""}${m[3] ? `:${m[3]}` : ""}`);
     return true;
@@ -765,7 +967,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, readFileSync3(overlayFile(), "utf8"), "text/javascript");
+        return send(res, 200, readFileSync4(overlayFile(), "utf8"), "text/javascript");
       }
       if (url === `${ROUTE}/events`) {
         res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", Connection: "keep-alive" });
@@ -784,6 +986,7 @@ data: ${JSON.stringify(data)}
         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") {
@@ -825,6 +1028,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();
@@ -836,7 +1044,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: path4.relative(root, file) });
+        return send(res, 200, { name: "limno", root, file: path5.relative(root, file) });
       }
       send(res, 404, { error: "not found" });
     } catch (err) {