@garuda-agent/garuda 0.17.0 → 0.18.1

package/dist/chunk-H7LIBGZT.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// src/buildInfo.ts
+var BUILD_COMMIT = true ? "820270c2d2acf39e101be31cdb9b8f9ed1b5839e" : void 0;
+
+export {
+  BUILD_COMMIT
+};
+//# sourceMappingURL=chunk-H7LIBGZT.js.map

package/dist/chunk-IKPGHM54.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+import {
+  taskHash
+} from "./chunk-DUYLVGPY.js";
+import {
+  compareReports,
+  costPerPass,
+  formatComparison
+} from "./chunk-CWVXOSAA.js";
+
+// src/evals/tune.ts
+import { readFile } from "fs/promises";
+var ADDENDUM_MAX_CHARS = 4e3;
+var CHECK_TAIL_LINES = 40;
+var REJECTED = [
+  /\b(skip|disable|ignore|bypass|weaken)\b[^.\n]{0,40}\b(tests?|checks?|assert\w*|sandbox|protect\w*)/i,
+  /\b(edit|change|modify|delete|remove|rewrite)\b[^.\n]{0,40}\b(the )?(tests?|test files?|checks?|protected files?)\b/i,
+  /\boutside_sandbox\b/i,
+  /\b(hard-?code|special-?case)\b[^.\n]{0,40}\b(expected|test|check)/i,
+  /\.check\//i
+];
+async function readAddendum(path, missingIsEmpty = false) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (missingIsEmpty && error.code === "ENOENT") return { text: "" };
+    return { problem: `--addendum ${path}: ${error.message}` };
+  }
+  if (text.length > ADDENDUM_MAX_CHARS) {
+    return {
+      problem: `--addendum ${path}: ${text.length} characters; the limit is ${ADDENDUM_MAX_CHARS}.`
+    };
+  }
+  return { text };
+}
+function rejectReason(text) {
+  if (text.trim() === "") return "the addendum is empty";
+  if (text.length > ADDENDUM_MAX_CHARS) {
+    return `the addendum has ${text.length} characters; the limit is ${ADDENDUM_MAX_CHARS}`;
+  }
+  for (const clause of text.split(/[.;!?](?=\s|$)|\n/)) {
+    for (const pattern of REJECTED) {
+      const hit = pattern.exec(clause);
+      if (hit === null || NEGATION.test(clause.slice(0, hit.index + hit[0].length))) continue;
+      return `the addendum asks to get around the grading ("${hit[0]}")`;
+    }
+  }
+  return void 0;
+}
+var NEGATION = /\b(never|not|don't|do not|no|without)\b/i;
+function groupRuns(results) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of results) out.set(r.id, [...out.get(r.id) ?? [], r]);
+  return out;
+}
+var asReport = (path, results, tasks) => ({
+  path,
+  schema: 2,
+  model: void 0,
+  seed: void 0,
+  tasks: tasks === void 0 ? void 0 : Object.fromEntries(tasks.map((t) => [t.id, taskHash(t)])),
+  results: [...results]
+});
+function decide(current, candidate, options) {
+  const passesCurrent = current.filter((r) => r.passed).length;
+  const passesCandidate = candidate.filter((r) => r.passed).length;
+  const runs = candidate.length;
+  const base = { passesCurrent, passesCandidate, runs };
+  const before = groupRuns(current);
+  const after = groupRuns(candidate);
+  const lost = [...before.entries()].filter(([, rs]) => rs.length > 0 && rs.every((r) => r.passed)).filter(([id]) => {
+    const now = after.get(id) ?? [];
+    return now.length > 0 && now.every((r) => !r.passed);
+  }).map(([id]) => id);
+  if (lost.length > 0) {
+    return {
+      ...base,
+      kept: false,
+      reason: `dropped: ${lost.join(", ")} went from all runs passed to none`
+    };
+  }
+  const compared = compareReports(asReport("current", current), asReport("candidate", candidate), {
+    seed: options.seed
+  });
+  const ratio = "problems" in compared || compared.comparison.costRatio === void 0 ? void 0 : compared.comparison.costRatio;
+  const costRatio = ratio === void 0 ? void 0 : { value: ratio.value, low: ratio.low, high: ratio.high };
+  const withCost = costRatio === void 0 ? base : { ...base, costRatio };
+  const gain = passesCandidate - passesCurrent;
+  if (gain >= options.margin) {
+    return {
+      ...withCost,
+      kept: true,
+      reason: `kept: ${gain} more passing run(s) (margin ${options.margin})`
+    };
+  }
+  if (gain >= 0 && costRatio !== void 0 && costRatio.high < 1) {
+    return {
+      ...withCost,
+      kept: true,
+      reason: `kept: as many passes or more, and cost per accepted change \xD7${costRatio.value.toFixed(2)} (95% interval \xD7${costRatio.low.toFixed(2)} to \xD7${costRatio.high.toFixed(2)})`
+    };
+  }
+  const cost = costRatio === void 0 ? "cost ratio unknown" : `cost \xD7${costRatio.value.toFixed(2)} (\xD7${costRatio.low.toFixed(2)} to \xD7${costRatio.high.toFixed(2)})`;
+  return {
+    ...withCost,
+    kept: false,
+    reason: `dropped: ${gain >= 0 ? "+" : ""}${gain} passing run(s) (margin ${options.margin}), ${cost}`
+  };
+}
+function proposerInput(addendum, tasks, results, history) {
+  const prompts = new Map(tasks.map((t) => [t.id, t.prompt]));
+  const lines = [
+    "# The current addendum",
+    "",
+    addendum.trim() === "" ? "(empty)" : addendum.trim(),
+    ""
+  ];
+  const failed = results.filter((r) => !r.passed);
+  if (failed.length > 0) {
+    lines.push(`# Failed runs (${failed.length} of ${results.length})`, "");
+    for (const r of failed) {
+      const tail = (r.reason ?? "").split("\n").slice(-CHECK_TAIL_LINES).join("\n");
+      lines.push(
+        `## ${r.id} (run ${r.attempt ?? 1}): ${r.stopReason}, ${r.steps} steps`,
+        "",
+        "Task prompt:",
+        prompts.get(r.id) ?? "(unknown)",
+        "",
+        "Why it failed (last lines):",
+        "```",
+        tail,
+        "```",
+        ...r.unexpected !== void 0 && r.unexpected.length > 0 ? ["", `Unexpected changes: ${r.unexpected.join(", ")}`] : [],
+        ""
+      );
+    }
+  } else {
+    lines.push(`# Every run passed (${results.length}). Lower the cost: what each task took`, "");
+    for (const [id, rs] of groupRuns(results)) {
+      const mean = (f) => rs.reduce((s, r) => s + f(r), 0) / rs.length;
+      const costliest = [...rs].sort((a, b) => (b.costUsd ?? 0) - (a.costUsd ?? 0))[0];
+      lines.push(
+        `- ${id}: ${mean((r) => r.steps).toFixed(1)} steps, ${Math.round(mean((r) => r.tokens))} tokens, $${mean((r) => r.costUsd ?? 0).toFixed(4)} a run; tools of the costliest run: ${(costliest?.tools ?? []).join(", ") || "(none recorded)"}`
+      );
+    }
+    lines.push("");
+  }
+  if (history.length > 0) {
+    lines.push("# Earlier proposals", "");
+    for (const h of history) {
+      lines.push(
+        `- round ${h.round} (${h.version}): ${h.rejected === void 0 ? h.decision?.reason ?? "" : `rejected before a run: ${h.rejected}`}. The proposer's reason: ${h.reason}`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var PROPOSER_SYSTEM = [
+  "You improve a coding agent. The agent gets a short text, the addendum, at the end of its system",
+  "prompt. You see the current addendum and the agent's results on development tasks. Write a",
+  "complete new addendum that should make the agent pass more tasks, or pass them at a lower cost.",
+  "",
+  "Rules:",
+  `- At most ${ADDENDUM_MAX_CHARS} characters. General advice about how to work, not about one task:`,
+  "  the addendum is measured later on tasks you never see.",
+  "- Never tell the agent to skip, weaken or edit tests or checks, to touch protected files, or to",
+  "  leave the sandbox. Such a text is refused without a run.",
+  "",
+  "Answer in exactly this form:",
+  "<addendum>",
+  "the complete new addendum",
+  "</addendum>",
+  "<reason>one paragraph: what you changed and why</reason>"
+].join("\n");
+function parseProposal(text) {
+  const addendum = /<addendum>\n?([\s\S]*?)\n?<\/addendum>/.exec(text)?.[1];
+  const reason = /<reason>([\s\S]*?)<\/reason>/.exec(text)?.[1];
+  if (addendum === void 0) return void 0;
+  return { addendum: addendum.trim(), reason: (reason ?? "").trim() };
+}
+var costOf = (results) => {
+  const c = costPerPass(results);
+  if (c.kind === "unknown") return void 0;
+  return results.reduce((s, r) => s + (r.costUsd ?? 0), 0);
+};
+async function tune(options) {
+  const history = [];
+  let spent = 0;
+  let current = options.start;
+  let version = 0;
+  await options.save("v0.md", current);
+  options.log(`Scoring v0 on ${options.devTasks.length} dev task(s) \xD7 ${options.repeat}.`);
+  let currentResults = await options.score(current, options.devTasks, options.repeat, "v0");
+  let lastScoreCost = costOf(currentResults);
+  if (lastScoreCost === void 0) {
+    return { final: current, history, spentUsd: spent, stopped: "unknown cost" };
+  }
+  spent += lastScoreCost;
+  let stopped = "rounds";
+  let lastProposalCost = 0;
+  for (let round = 1; round <= options.rounds; round++) {
+    if (spent + lastScoreCost + lastProposalCost > options.maxCostUsd) {
+      stopped = "cost";
+      options.log(
+        `Stopping before round ${round}: $${spent.toFixed(2)} spent, and the next round would pass --max-cost $${options.maxCostUsd}.`
+      );
+      break;
+    }
+    const input = proposerInput(current, options.devTasks, currentResults, history);
+    const name = `v${round}`;
+    await options.save(`${name}.input.md`, input);
+    let proposal = await options.propose(input);
+    if (proposal.costUsd === void 0) {
+      stopped = "unknown cost";
+      break;
+    }
+    let proposalCost = proposal.costUsd;
+    let rejected = rejectReason(proposal.addendum);
+    let refusedFirst;
+    if (rejected !== void 0) {
+      refusedFirst = rejected;
+      await options.save(`${name}.refused.md`, proposal.addendum);
+      options.log(`Round ${round}: ${name} refused (${rejected}); asking once more.`);
+      const again = await options.propose(
+        `${input}
+# Your last answer was refused
+
+${rejected}. Write the complete addendum again without that phrase. Do not tell the agent to skip, change or delete tests or checks, even as an example of what to avoid.
+`
+      );
+      if (again.costUsd === void 0) {
+        stopped = "unknown cost";
+        break;
+      }
+      proposalCost += again.costUsd;
+      proposal = again;
+      rejected = rejectReason(proposal.addendum);
+    }
+    spent += proposalCost;
+    lastProposalCost = proposalCost;
+    await options.save(`${name}.md`, proposal.addendum);
+    if (rejected !== void 0) {
+      history.push({
+        round,
+        version: name,
+        reason: proposal.reason,
+        rejected,
+        costUsd: proposalCost
+      });
+      options.log(`Round ${round}: ${name} rejected before a run: ${rejected}.`);
+      continue;
+    }
+    options.log(`Round ${round}: scoring ${name}.`);
+    const candidate = await options.score(
+      proposal.addendum,
+      options.devTasks,
+      options.repeat,
+      name
+    );
+    const scoreCost = costOf(candidate);
+    if (scoreCost === void 0) {
+      stopped = "unknown cost";
+      break;
+    }
+    spent += scoreCost;
+    lastScoreCost = scoreCost;
+    const decision = decide(currentResults, candidate, {
+      margin: options.margin,
+      seed: options.seed
+    });
+    history.push({
+      round,
+      version: name,
+      reason: proposal.reason,
+      decision,
+      costUsd: proposalCost + scoreCost,
+      ...refusedFirst === void 0 ? {} : { refusedFirst }
+    });
+    options.log(`Round ${round}: ${name} ${decision.reason}.`);
+    if (decision.kept) {
+      current = proposal.addendum;
+      currentResults = candidate;
+      version = round;
+    }
+    await options.save("history.json", `${JSON.stringify(history, null, 2)}
+`);
+  }
+  await options.save("history.json", `${JSON.stringify(history, null, 2)}
+`);
+  await options.save("final.md", current);
+  let heldOut;
+  if (options.heldOutTasks.length > 0 && version > 0) {
+    options.log(
+      `Held-out: the empty addendum (A) against v${version} (B), \xD7 ${options.heldoutRepeat}.`
+    );
+    const a = await options.score("", options.heldOutTasks, options.heldoutRepeat, "heldout-empty");
+    const b = await options.score(
+      current,
+      options.heldOutTasks,
+      options.heldoutRepeat,
+      "heldout-final"
+    );
+    spent += (costOf(a) ?? 0) + (costOf(b) ?? 0);
+    const ra = asReport("held-out, empty addendum", a, options.heldOutTasks);
+    const rb = asReport(`held-out, v${version}`, b, options.heldOutTasks);
+    const compared = compareReports(ra, rb, { seed: options.seed });
+    heldOut = "problems" in compared ? compared.problems.join("\n") : formatComparison(ra, rb, compared.comparison);
+    await options.save("heldout.txt", `${heldOut}
+`);
+  } else if (version === 0) {
+    options.log("No version was kept: no held-out measurement.");
+  }
+  return {
+    final: current,
+    history,
+    spentUsd: spent,
+    stopped,
+    ...heldOut === void 0 ? {} : { heldOut }
+  };
+}
+
+export {
+  ADDENDUM_MAX_CHARS,
+  readAddendum,
+  rejectReason,
+  decide,
+  proposerInput,
+  PROPOSER_SYSTEM,
+  parseProposal,
+  tune
+};
+//# sourceMappingURL=chunk-IKPGHM54.js.map

package/dist/chunk-IYGJWX65.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var VERSION = "0.18.1";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-IYGJWX65.js.map

package/dist/{chunk-U65DQZDB.js → chunk-JMH5W5DG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   knownModels
-} from "./chunk-J4346IDH.js";
+} from "./chunk-7KBOIPUT.js";
 
 // src/model/catalog.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -91,53 +91,10 @@ function prefixInfo(id) {
   return best?.info;
 }
 
-// src/tools/atomicWrite.ts
-import { randomBytes } from "crypto";
-import { chmod, link, realpath, rename, stat, unlink, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname2, join as join2 } from "path";
-async function writeFileAtomic(path, content, { createOnly }) {
-  const target = createOnly ? path : await realpath(path);
-  const temp = join2(
-    dirname2(target),
-    `.${basename(target)}.garuda-${randomBytes(4).toString("hex")}.tmp`
-  );
-  const mode = createOnly ? void 0 : (await stat(target)).mode & 4095;
-  await writeFile2(temp, content, { flag: "wx", ...mode === void 0 ? {} : { mode } });
-  try {
-    if (createOnly) {
-      try {
-        await link(temp, target);
-      } catch (error) {
-        const code = error.code;
-        if (code !== "EPERM" && code !== "ENOTSUP" && code !== "EXDEV") throw error;
-        if (await exists(target)) throw Object.assign(new Error("EEXIST"), { code: "EEXIST" });
-        await rename(temp, target);
-        return;
-      }
-    } else {
-      await chmod(temp, mode ?? 420);
-      await rename(temp, target);
-      return;
-    }
-  } finally {
-    await unlink(temp).catch(() => {
-    });
-  }
-}
-async function exists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export {
-  writeFileAtomic,
   fetchCatalog,
   saveCatalog,
   loadCatalog,
   mergedModels
 };
-//# sourceMappingURL=chunk-U65DQZDB.js.map
+//# sourceMappingURL=chunk-JMH5W5DG.js.map

package/dist/chunk-L55VUSX3.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+// src/cli/uiState.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var KEY_HINT_CHATS = 5;
+async function countChat(home) {
+  const dir = join(home, ".garuda");
+  const file = join(dir, "ui.json");
+  let chats = 0;
+  let data = {};
+  try {
+    const read = JSON.parse(await readFile(file, "utf8"));
+    if (typeof read === "object" && read !== null && !Array.isArray(read)) {
+      data = read;
+    }
+    if (typeof data.chats === "number" && Number.isInteger(data.chats) && data.chats >= 0) {
+      chats = data.chats;
+    }
+  } catch {
+  }
+  chats++;
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await writeFile(file, `${JSON.stringify({ ...data, chats })}
+`, { mode: 384 });
+  } catch {
+  }
+  return chats;
+}
+var KEYS_HELP = [
+  "Keys:",
+  "  Enter sends \xB7 \\ then Enter, or Alt+Enter: a new line \xB7 \u2191\u2193 earlier inputs",
+  "  Tab completes /commands and @paths \xB7 Shift+Tab plan mode \xB7 Ctrl-P commands",
+  "  Ctrl-G edits the prompt in your editor \xB7 Ctrl-O shows the last output in full",
+  "  Esc or Ctrl-C stops a turn \xB7 Ctrl-C clears the line \xB7 Ctrl-D exits",
+  "  !command runs a command yourself \xB7 @path attaches a file"
+].join("\n");
+function contextBar(percent) {
+  const full = percent <= 0 ? 0 : Math.max(1, Math.min(10, Math.round(percent / 10)));
+  return `${"\u2593".repeat(full)}${"\u2591".repeat(10 - full)}`;
+}
+function contextLevel(percent) {
+  return percent >= 80 ? "full" : percent >= 70 ? "high" : "ok";
+}
+
+export {
+  KEY_HINT_CHATS,
+  countChat,
+  KEYS_HELP,
+  contextBar,
+  contextLevel
+};
+//# sourceMappingURL=chunk-L55VUSX3.js.map

package/dist/{chunk-B4SJY7KT.js → chunk-LMKGSYJC.js}

@@ -42,6 +42,10 @@ var NETWORK_PRESETS = {
   ]
 };
 var PRESET_NAMES = Object.keys(NETWORK_PRESETS);
+function presetFor(host) {
+  const bare = host.toLowerCase();
+  return PRESET_NAMES.find((name) => NETWORK_PRESETS[name]?.includes(bare));
+}
 var NETWORK_PORTS = [80, 443];
 var HOST = /^(\*\.)?([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,63}$/;
 function expandAllowlist(entries) {
@@ -74,9 +78,9 @@ function describeAllowlist(entries) {
 }
 
 // src/permissions/sandboxPaths.ts
-import { realpathSync } from "fs";
+import { readdirSync, realpathSync } from "fs";
 import { homedir, tmpdir } from "os";
-import { isAbsolute, join, resolve } from "path";
+import { isAbsolute, join, resolve, sep } from "path";
 import { globbySync } from "globby";
 var DENY_READ_IN_HOME = [
   ".ssh",
@@ -101,6 +105,49 @@ var DENY_READ_IN_HOME = [
   ".claude.json",
   ".claude/.credentials.json"
 ];
+var PERSONAL_IN_HOME = [
+  "Desktop",
+  "Documents",
+  "Downloads",
+  "Movies",
+  "Music",
+  "Pictures",
+  "Public",
+  "Library/Mail",
+  "Library/Messages",
+  "Library/Safari",
+  "Library/Calendars",
+  "Library/Application Support/AddressBook",
+  "Library/Mobile Documents",
+  "Library/CloudStorage"
+];
+function denyAround(base, keep, keepHidden = false) {
+  let names;
+  try {
+    names = readdirSync(base);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const path = join(base, name);
+    if (keep.includes(path)) continue;
+    if (keep.some((k) => k.startsWith(`${path}${sep}`))) {
+      out.push(...denyAround(path, keep));
+      continue;
+    }
+    if (keepHidden && name.startsWith(".")) continue;
+    out.push(path);
+  }
+  return out;
+}
+function personalDenials(home, root) {
+  return PERSONAL_IN_HOME.flatMap((name) => {
+    const folder = join(home, name);
+    if (root === folder) return [];
+    return root.startsWith(`${folder}${sep}`) ? denyAround(folder, [root]) : [folder];
+  });
+}
 var PROTECTED_IN_ROOT = [".git/hooks", ".git/config", ".garuda"];
 var WRITE_IN_HOME = [
   ".cache",
@@ -122,6 +169,7 @@ function sandboxPaths(root, settings = {}, home = homedir()) {
     denyWritePaths: PROTECTED_IN_ROOT.map((p) => join(root, p)),
     denyReadPaths: unique([
       ...DENY_READ_IN_HOME.map((p) => join(home, p)),
+      ...personalDenials(home, root),
       ...(settings.denyRead ?? []).map(expand)
     ])
   };
@@ -817,10 +865,10 @@ function seatbeltProfile(policy, extra = []) {
     }
   }
   if (policy.denyWritePaths.length > 0) {
-    lines.push(`(deny file-write* ${paths(policy.denyWritePaths)})`);
+    lines.push(`(deny file-write* ${paths(withDataVolume(policy.denyWritePaths))})`);
   }
   if (policy.denyReadPaths.length > 0) {
-    lines.push(`(deny file-read* ${paths(policy.denyReadPaths)})`);
+    lines.push(`(deny file-read* ${paths(withDataVolume(policy.denyReadPaths))})`);
   }
   lines.push("(deny lsopen)", "(deny appleevent-send)");
   if (!policy.network) {
@@ -836,6 +884,14 @@ function seatbeltProfile(policy, extra = []) {
   lines.push(...extra);
   return lines.join("\n");
 }
+function withDataVolume(list) {
+  const out = [];
+  for (const path of list) {
+    out.push(path);
+    if (path.startsWith("/Users/")) out.push(`/System/Volumes/Data${path}`);
+  }
+  return out;
+}
 function quote2(path) {
   return `"${path.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 }
@@ -976,6 +1032,8 @@ var schema = z.strictObject({
   }).optional(),
   /** Language server diagnostics after edits (0.4). enabled: default false. */
   lsp: z.strictObject({ enabled: z.boolean().optional() }).optional(),
+  /** The chat's look (0.18.1). clearOnStart: default true (the Ink chat starts on a clear screen). */
+  ui: z.strictObject({ clearOnStart: z.boolean().optional() }).optional(),
   /**
    * The project's formatter after edits (0.10). enabled: default false (A/B first). commands: by
    * name, false turns a detected formatter off; a command adds one or replaces a detected one.
@@ -1065,6 +1123,7 @@ function parseSettings(json, source = SETTINGS_FILE) {
     skills,
     agents,
     notifications,
+    ui,
     thinking,
     formatters,
     network
@@ -1102,6 +1161,7 @@ function parseSettings(json, source = SETTINGS_FILE) {
     ...commands?.mode === void 0 ? {} : { commands: { mode: commands.mode } },
     ...todo?.enabled === void 0 ? {} : { todo: { enabled: todo.enabled } },
     ...lsp?.enabled === void 0 ? {} : { lsp: { enabled: lsp.enabled } },
+    ...ui?.clearOnStart === void 0 ? {} : { ui: { clearOnStart: ui.clearOnStart } },
     ...undo?.enabled === void 0 ? {} : { undo: { enabled: undo.enabled } },
     ...skills?.enabled === void 0 ? {} : { skills: { enabled: skills.enabled } },
     ...agents?.enabled === void 0 ? {} : { agents: { enabled: agents.enabled } },
@@ -1160,7 +1220,7 @@ async function loadSettings(root) {
 }
 
 // src/permissions/engine.ts
-import { sep } from "path";
+import { sep as sep2 } from "path";
 
 // src/permissions/sensitive.ts
 var SENSITIVE_PATTERNS = [
@@ -1430,7 +1490,14 @@ var PermissionEngine = class {
     if (choice === "once" && accepted !== void 0) {
       return { decision: { allowed: true, by: "user", hunks: accepted }, userChoice: choice };
     }
-    return { decision: { allowed: true, by: "user" }, userChoice: choice };
+    return {
+      decision: {
+        allowed: true,
+        by: "user",
+        ...choice === "session" ? { remembered: true } : {}
+      },
+      userChoice: choice
+    };
   }
   /**
    * Plan mode: file changes and memory are always denied; a command runs only in the OS sandbox
@@ -1518,7 +1585,7 @@ var PermissionEngine = class {
     const denied = policyDeniedPaths(this.root, this.policy?.denyPaths ?? []);
     let writePaths = [.../* @__PURE__ */ new Set([...paths.writePaths, ...this.access.writePaths])];
     let denyWritePaths = [...paths.denyWritePaths, ...denied];
-    const inRoot = (p) => p === this.root || p.startsWith(`${this.root}${sep}`);
+    const inRoot = (p) => p === this.root || p.startsWith(`${this.root}${sep2}`);
     if (readOnlyRoot) {
       writePaths = writePaths.filter((p) => !inRoot(p));
       denyWritePaths = [this.root, ...denyWritePaths];
@@ -1588,10 +1655,12 @@ function describeTarget(target) {
 
 export {
   isSensitive,
+  presetFor,
   NETWORK_PORTS,
   expandAllowlist,
   hostAllowed,
   describeAllowlist,
+  denyAround,
   sandboxPaths,
   HostExecutor,
   EXECUTOR_NAMES,
@@ -1602,4 +1671,4 @@ export {
   JOB_DENIAL,
   PermissionEngine
 };
-//# sourceMappingURL=chunk-B4SJY7KT.js.map
+//# sourceMappingURL=chunk-LMKGSYJC.js.map

package/dist/{chunk-23FXBNBB.js → chunk-MNE7HHX2.js}

@@ -36,6 +36,7 @@ var BUILTIN_COMMANDS = [
   "search",
   "undo",
   "redo",
+  "rewind",
   "exit",
   "quit"
 ];
@@ -43,4 +44,4 @@ var BUILTIN_COMMANDS = [
 export {
   BUILTIN_COMMANDS
 };
-//# sourceMappingURL=chunk-23FXBNBB.js.map
+//# sourceMappingURL=chunk-MNE7HHX2.js.map