@garuda-agent/garuda 0.18.0 → 0.18.1

package/dist/{chunk-NHWHG3SW.js → chunk-5UDYQ5MK.js}

@@ -1,11 +1,19 @@
 #!/usr/bin/env node
-import {
-  mergedModels,
-  writeFileAtomic
-} from "./chunk-65NUEOI7.js";
 import {
   loadLspConfig
 } from "./chunk-G2AX7MGS.js";
+import {
+  gateProjectSettings
+} from "./chunk-ULAJPMY7.js";
+import {
+  mergedModels
+} from "./chunk-JMH5W5DG.js";
+import {
+  writeFileAtomic
+} from "./chunk-NH72AELP.js";
+import {
+  ReceiptCollector
+} from "./chunk-4QRTTRVK.js";
 import {
   hasServerBlocks,
   serverCallText,
@@ -29,17 +37,17 @@ import {
   compacted,
   createSession,
   emptyUndoState,
-  gateProjectSettings,
   isCostIncomplete,
   newSessionId,
   newUserMessage,
+  pendingChildTokens,
   popPoint,
   pushPoint,
   redoPoint,
   redoTurn,
   settleChildDebits,
   undoTurn
-} from "./chunk-UKIE4AAM.js";
+} from "./chunk-NLS7GMF7.js";
 import {
   REDACTED,
   Redactor,
@@ -57,10 +65,10 @@ import {
 } from "./chunk-B25VL4RU.js";
 import {
   BUILTIN_COMMANDS
-} from "./chunk-23FXBNBB.js";
+} from "./chunk-MNE7HHX2.js";
 import {
   VERSION
-} from "./chunk-C57GHLKP.js";
+} from "./chunk-IYGJWX65.js";
 import {
   TrustStore
 } from "./chunk-5DEWP3YX.js";
@@ -91,8 +99,9 @@ import {
   expandAllowlist,
   hostAllowed,
   isSensitive,
-  loadSettings
-} from "./chunk-B4SJY7KT.js";
+  loadSettings,
+  presetFor
+} from "./chunk-LMKGSYJC.js";
 import {
   EFFORTS,
   ZERO_USAGE,
@@ -1502,7 +1511,12 @@ ${z.prettifyError(parsed.error)}`,
       await logRun(outcome.isError);
       const final = context.hooks === void 0 ? outcome : await context.hooks.after(hookCall, outcome, context.signal);
       const subagent = tool.report?.(output);
-      return subagent === void 0 ? final : { ...final, subagent };
+      const command = tool.commandFacts?.(output);
+      return {
+        ...final,
+        ...subagent === void 0 ? {} : { subagent },
+        ...command === void 0 ? {} : { command }
+      };
     } catch (error) {
       if (context.signal.aborted) throw error;
       if (error instanceof AuditWriteError) {
@@ -1795,7 +1809,8 @@ function createBashTool({
       }
       const result = await executor.run(run, policy, { signal });
       const hints = commandHints(run, stripped);
-      const network = sandboxed ? networkHint(permissions.takeNetworkBlocks?.() ?? [], strict) : void 0;
+      const blocks = sandboxed ? permissions.takeNetworkBlocks?.() ?? [] : [];
+      const network = sandboxed ? networkHint(blocks, strict) : void 0;
       if (network !== void 0) hints.push(network);
       const blocked = sandboxed && network === void 0 ? sandboxHint(result, policy.proxy !== void 0, strict) : void 0;
       if (blocked !== void 0) hints.push(blocked);
@@ -1810,7 +1825,21 @@ function createBashTool({
           `Garuda could not check for processes that left the command's process group (${result.reapProblem}). Such a process may still run, inside the sandbox.`
         );
       }
-      return { ...result, hints };
+      return {
+        ...result,
+        hints,
+        sandboxed,
+        blockedHosts: [...new Set(blocks.map((b) => b.host))]
+      };
+    },
+    commandFacts(result) {
+      if ("daemon" in result && result.daemon !== void 0) return void 0;
+      return {
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        sandboxed: result.sandboxed ?? false,
+        blockedHosts: result.blockedHosts ?? []
+      };
     },
     toText(result) {
       const lines = [];
@@ -6725,7 +6754,8 @@ function rebuildState(records) {
     unreportedTokens: 0,
     childDebits: /* @__PURE__ */ new Map(),
     start: void 0,
-    undo: emptyUndoState()
+    undo: emptyUndoState(),
+    turns: 0
   };
   const addCost2 = (cost) => {
     state.costUsd = state.costUsd === void 0 || cost === void 0 ? void 0 : state.costUsd + cost;
@@ -6743,10 +6773,15 @@ function rebuildState(records) {
       case "user":
         state.messages.push(record.message);
         newUserMessage(state.undo);
+        state.turns++;
         break;
-      case "snapshot":
+      case "snapshot": {
         pushPoint(state.undo, record.tree, record.messages, record.prompt);
+        const point = state.undo.points.at(-1);
+        const at = record.at ?? Date.parse(record.t);
+        if (point !== void 0 && !Number.isNaN(at)) point.at = at;
         break;
+      }
       case "undo":
         popPoint(state.undo, state.messages, record.after);
         break;
@@ -6792,6 +6827,23 @@ function rebuildState(records) {
       case "thinking":
         state.thinking = record.choice;
         break;
+      case "fork":
+        state.messages = structuredClone(record.messages);
+        state.turns = record.from.turn - 1;
+        break;
+      case "receipt": {
+        const point = state.undo.points.at(-1);
+        if (point !== void 0 && record.receipt.files !== void 0) {
+          point.changedFiles = record.receipt.files.length;
+        }
+        if (point !== void 0 && record.receipt.costUsd !== void 0) {
+          point.costUsd = record.receipt.costUsd;
+        }
+        if (record.receipt.tests?.total !== void 0) {
+          state.lastTestTotal = record.receipt.tests.total;
+        }
+        break;
+      }
       case "unreported":
         state.unreportedTokens += record.tokens;
         state.costIncomplete = true;
@@ -6835,6 +6887,8 @@ async function resumeSession(options) {
   session.childDebits = state.childDebits;
   session.undo = state.undo;
   if (state.thinking !== void 0) session.thinking = state.thinking;
+  session.turns = state.turns;
+  if (state.lastTestTotal !== void 0) session.lastTestTotal = state.lastTestTotal;
   journal.write({ type: "resume", sessionId: id2, ...options.start });
   closeOpenToolCalls(session);
   return session;
@@ -6863,6 +6917,34 @@ function repairServerBlocks(message) {
   return { ...message, content: withoutServerBlocks(message.content) };
 }
 
+// src/session/list.ts
+var TITLE_CHARS = 60;
+function summariseSession(id2, updated, records) {
+  const prompts = records.filter((r) => r.type === "user");
+  const first = prompts[0]?.message.content.find((b) => b.type === "text");
+  const named = records.findLast((r) => r.type === "title");
+  const line = named?.type === "title" ? named.title : (first?.type === "text" ? first.text : "").trim().split("\n")[0] ?? "";
+  const state = rebuildState(records);
+  return {
+    id: id2,
+    updated,
+    title: line.length <= TITLE_CHARS ? line : `${line.slice(0, TITLE_CHARS - 1)}\u2026`,
+    turns: prompts.length,
+    model: state.start?.model,
+    costUsd: state.costUsd,
+    // A child debit with no report: its USD cost is not known (Codex review of 1370184).
+    costIncomplete: isCostIncomplete(state)
+  };
+}
+var MAX_TITLE_CHARS = TITLE_CHARS;
+function cleanTitle(text) {
+  const one = [...text].map((c) => {
+    const code = c.codePointAt(0) ?? 0;
+    return code < 32 || code >= 127 && code < 160 ? " " : c;
+  }).join("").replace(/\s+/g, " ").trim();
+  return one.length <= MAX_TITLE_CHARS ? one : `${one.slice(0, MAX_TITLE_CHARS - 1)}\u2026`;
+}
+
 // src/skills/load.ts
 import { createHash as createHash7 } from "crypto";
 import { lstat as lstat4, readdir as readdir5, readFile as readFile12, stat as stat7 } from "fs/promises";
@@ -8136,6 +8218,10 @@ function networkNote(entries, strict = false) {
     strict ? "For any other host, also run the command in the sandbox: Garuda asks the user for that host, and the result says if it was blocked." : "For any other host, also run the command in the sandbox: Garuda asks the user for that host, and the result says if it was blocked. Use outside_sandbox only when the sandbox blocks something else (a write outside the project)."
   ].join("\n");
 }
+function networkKeepHint(host2) {
+  const entry = presetFor(host2) ?? host2;
+  return `${host2} works for commands in this session. To keep it for this project, add "${entry}" to "network.allow" in .garuda/settings.json.`;
+}
 function networkConsent(entries, isolation, changed) {
   const lines = [
     changed ? "The network allowlist in .garuda/settings.json changed since you allowed it." : "This project's .garuda/settings.json opens the network for commands in the sandbox.",
@@ -8167,34 +8253,6 @@ function nodeBinary(execPath = process.execPath, path = process.env.PATH ?? "")
   return void 0;
 }
 
-// src/session/list.ts
-var TITLE_CHARS = 60;
-function summariseSession(id2, updated, records) {
-  const prompts = records.filter((r) => r.type === "user");
-  const first = prompts[0]?.message.content.find((b) => b.type === "text");
-  const named = records.findLast((r) => r.type === "title");
-  const line = named?.type === "title" ? named.title : (first?.type === "text" ? first.text : "").trim().split("\n")[0] ?? "";
-  const state = rebuildState(records);
-  return {
-    id: id2,
-    updated,
-    title: line.length <= TITLE_CHARS ? line : `${line.slice(0, TITLE_CHARS - 1)}\u2026`,
-    turns: prompts.length,
-    model: state.start?.model,
-    costUsd: state.costUsd,
-    // A child debit with no report: its USD cost is not known (Codex review of 1370184).
-    costIncomplete: isCostIncomplete(state)
-  };
-}
-var MAX_TITLE_CHARS = TITLE_CHARS;
-function cleanTitle(text) {
-  const one = [...text].map((c) => {
-    const code = c.codePointAt(0) ?? 0;
-    return code < 32 || code >= 127 && code < 160 ? " " : c;
-  }).join("").replace(/\s+/g, " ").trim();
-  return one.length <= MAX_TITLE_CHARS ? one : `${one.slice(0, MAX_TITLE_CHARS - 1)}\u2026`;
-}
-
 // src/app/sessionManager.ts
 async function findSession(ref, store) {
   const all = await store.list();
@@ -8307,6 +8365,34 @@ function filesText(changes) {
   if (changes.length === 0) return "no file changes";
   return `${changes.length} file${changes.length === 1 ? "" : "s"} changed`;
 }
+function rewindQuestion(kind, turn, prompt, count2, changes, isolation) {
+  const lines = [`Back to the start of turn ${turn}: "${prompt}"`];
+  if (changes.length === 0) lines.push("No file changes.");
+  else {
+    lines.push(`Files (${changes.length}):`);
+    for (const c of changes.slice(0, MAX_CHANGE_LINES))
+      lines.push(`  ${MARKS[c.status]} ${cleanText(c.path).replace(/\n/g, " ")}`);
+    if (changes.length > MAX_CHANGE_LINES) {
+      lines.push(`  \u2026 and ${changes.length - MAX_CHANGE_LINES} more.`);
+    }
+    lines.push("  (+ comes back, - is removed, ~ changes)");
+  }
+  lines.push("Files that .gitignore covers (for example build output) are not in undo.");
+  lines.push(
+    kind === "rewind" ? `This takes back ${count2} turn${count2 === 1 ? "" : "s"}: their file changes and their messages. /redo brings them back one at a time.` : "A new session starts with the conversation up to this turn. This session stays as it is: /sessions opens it again.",
+    "Changes that you made to these files since then go back too."
+  );
+  return {
+    tool: kind === "rewind" ? "undo" : "fork",
+    target: { kind: "input", json: "{}" },
+    preview: lines.join("\n"),
+    isolation,
+    title: kind === "rewind" ? `Rewind to turn ${turn}?` : `Fork a new session from turn ${turn}?`,
+    question: kind === "rewind" ? "Rewind?" : "Fork?",
+    choices: ["once", "deny"],
+    labels: { once: kind === "rewind" ? "Yes, rewind" : "Yes, fork", deny: "No" }
+  };
+}
 
 // src/app/undoCoordinator.ts
 var UndoCoordinator = class {
@@ -8361,6 +8447,81 @@ var UndoCoordinator = class {
       return `The ${kind} failed, and no file changed: ${error.message}`;
     }
   }
+  /**
+   * /rewind <n> (UX U6): back to the start of undo point `index` (0-based) in one step: one
+   * question, one restore, then each later turn leaves the conversation as /undo does, newest
+   * first. Each redo entry keeps the files after its turn, so /redo brings them back in order.
+   */
+  async rewind(session, index3, pendingNotes, signal) {
+    const store = this.snapshots;
+    if (store === void 0) return "Undo is off for this session, so /rewind cannot go back.";
+    const points = session?.undo.points ?? [];
+    const target = points[index3];
+    if (session === void 0 || target === void 0) {
+      return `There is no turn ${index3 + 1}. Type /rewind for the list.`;
+    }
+    try {
+      const now = await store.take(signal);
+      const changes = await store.changes(now, target.tree, signal);
+      const count2 = points.length - index3;
+      const choice = await this.approver.ask(
+        rewindQuestion("rewind", index3 + 1, target.prompt, count2, changes, this.isolation),
+        signal
+      );
+      if (choice === "deny") return "Nothing changed.";
+      const afters = points.slice(index3).map((_, i) => points[index3 + i + 1]?.tree ?? now);
+      await store.restore(now, target.tree, signal);
+      let compacted2 = false;
+      for (let i = afters.length - 1; i >= 0; i--) {
+        const point = undoTurn(session, afters[i]);
+        if (point !== void 0 && !point.conversation) compacted2 = true;
+      }
+      if (compacted2) {
+        pendingNotes.push(
+          `The user rewound to before the turn "${target.prompt}": the file changes of that turn and the later ones are gone. Read files again before you edit them.`
+        );
+      }
+      return `Rewound to the start of turn ${index3 + 1} ("${target.prompt}"): ${count2} turn${count2 === 1 ? "" : "s"} taken back, ${filesText(changes)}. /redo brings them back one at a time.`;
+    } catch (error) {
+      if (!(error instanceof SnapshotError)) throw error;
+      return `The rewind failed, and no file changed: ${error.message}`;
+    }
+  }
+  /**
+   * The files for a fork (UX U6): back to undo point `index`, after one question. The caller
+   * starts the new session. Returns undefined when the user said no.
+   */
+  async restoreForFork(session, index3, signal) {
+    const store = this.snapshots;
+    if (store === void 0)
+      return {
+        ok: false,
+        text: "Undo is off for this session, so a fork cannot restore the files."
+      };
+    const target = session.undo.points[index3];
+    if (target === void 0)
+      return { ok: false, text: `There is no turn ${index3 + 1}. Type /rewind for the list.` };
+    if (!target.conversation) {
+      return {
+        ok: false,
+        text: `Turn ${index3 + 1} is before a compaction: its messages are no longer separate, so it cannot start a fork.`
+      };
+    }
+    try {
+      const now = await store.take(signal);
+      const changes = await store.changes(now, target.tree, signal);
+      const choice = await this.approver.ask(
+        rewindQuestion("fork", index3 + 1, target.prompt, 0, changes, this.isolation),
+        signal
+      );
+      if (choice === "deny") return { ok: false, text: "Nothing changed." };
+      await store.restore(now, target.tree, signal);
+      return { ok: true };
+    } catch (error) {
+      if (!(error instanceof SnapshotError)) throw error;
+      return { ok: false, text: `The fork failed, and no file changed: ${error.message}` };
+    }
+  }
   async undoNow(session, pendingNotes, signal) {
     const store = this.snapshots;
     if (store === void 0) return "Undo is off for this session.";
@@ -8534,6 +8695,8 @@ var Runtime = class _Runtime {
   startModel;
   /** The prompt of the turn that runs or ran last (0.9: the note after a stopped turn). */
   lastPrompt;
+  /** The receipt of the last turn (UX U1); undefined before a turn ends, or after a failed one. */
+  receipt;
   /** LSP diagnostics after edits are on (0.4). */
   lspEnabled;
   lspOptions;
@@ -8718,6 +8881,10 @@ var Runtime = class _Runtime {
       );
     }
   }
+  /** The chat's look (0.18.1); the CLI applies it. */
+  get uiSettings() {
+    return this.settings.ui;
+  }
   /** The notification settings for the chat (0.6); the CLI applies them. */
   get notificationSettings() {
     return this.settings.notifications;
@@ -9352,6 +9519,8 @@ ${neutralizeTags(output)}`
   }
   /** Run one turn: the user's prompt, then the loop until it stops. */
   async runTurn(prompt, signal) {
+    const started = Date.now();
+    this.receipt = void 0;
     this.lastPrompt = prompt;
     this.turnSignal = signal;
     await this.startHooks(signal);
@@ -9382,6 +9551,22 @@ ${neutralizeTags(output)}`
     ];
     if (lines.length > 0) this.onEvent?.({ type: "notice", text: lines.join("\n") });
     closeOpenToolCalls(session);
+    session.turns = (session.turns ?? 0) + 1;
+    const before = {
+      cost: session.costUsd,
+      unreported: session.unreportedTokens,
+      pending: pendingChildTokens(session),
+      incomplete: session.costIncomplete
+    };
+    const collector = new ReceiptCollector(detectTestCommand(this.root, this.profiles));
+    let changesFiles = false;
+    const onEvent = (event) => {
+      collector.onEvent(event);
+      if (event.type === "tool_call" && !this.tools.isReadOnly(event.call.name)) {
+        changesFiles = true;
+      }
+      this.onEvent?.(event);
+    };
     addUserMessage(
       session,
       prompt,
@@ -9407,17 +9592,84 @@ ${neutralizeTags(output)}`
       ...this.outputTokens(),
       contextWindow: this.limits.contextWindow,
       ...this.price === void 0 ? {} : { price: this.price },
-      ...this.onEvent === void 0 ? {} : { onEvent: this.onEvent },
+      onEvent,
       ...this.settings.thinking?.keepBlocks === false ? { keepThinking: false } : {},
       ...this.thinkingParams === void 0 ? {} : { thinking: this.thinkingParams },
       signal
     });
+    this.receipt = await this.makeReceipt(session, result, collector, {
+      ...before,
+      started,
+      changesFiles,
+      signal
+    });
     if (this.turnMode === "plan" && result.stopReason === "done") {
       const plan2 = lastAssistantText(session.messages);
       if (plan2 !== "") this.plan = { request: prompt, plan: plan2, sessionId: session.id };
     }
     return result;
   }
+  /** The receipt of the last turn (UX U1), or undefined. */
+  get lastReceipt() {
+    return this.receipt;
+  }
+  /**
+   * The turn's receipt (UX U1; docs/lld/ux.md): the files from a snapshot at the end of the turn
+   * (only when a tool that can change files ran), the commands' facts, and the costs.
+   */
+  async makeReceipt(session, result, collector, before) {
+    const store = this.undoCoordinator.store;
+    const point = session.undo.points.at(-1);
+    let files;
+    if (store !== void 0 && point !== void 0) {
+      files = [];
+      if (before.changesFiles) {
+        try {
+          const end = await store.take(before.signal);
+          files = (await store.stats(point.tree, end, before.signal)).map((f) => ({
+            path: f.path,
+            ...f.added === void 0 ? {} : { added: f.added, removed: f.removed ?? 0 }
+          }));
+        } catch (error) {
+          if (before.signal.aborted) throw error;
+          files = void 0;
+        }
+      }
+      if (files !== void 0) point.changedFiles = files.length;
+      if (session.costUsd !== void 0 && before.cost !== void 0) {
+        point.costUsd = session.costUsd - before.cost;
+      }
+    }
+    const costIncomplete = session.unreportedTokens > before.unreported || pendingChildTokens(session) > before.pending || session.costIncomplete && !before.incomplete;
+    const tests = collector.tests;
+    if (tests !== void 0 && session.lastTestTotal !== void 0) {
+      tests.previousTotal = session.lastTestTotal;
+    }
+    if (tests?.total !== void 0) session.lastTestTotal = tests.total;
+    const receipt = {
+      turn: session.turns ?? 1,
+      stopReason: result.stopReason,
+      steps: result.steps,
+      durationMs: Date.now() - before.started,
+      ...session.costUsd === void 0 || before.cost === void 0 ? {} : { costUsd: session.costUsd - before.cost },
+      ...costIncomplete ? { costIncomplete: true } : {},
+      ...files === void 0 ? {} : { files },
+      ...tests === void 0 ? {} : { tests },
+      commands: {
+        sandboxed: collector.sandboxed,
+        outside: collector.outside,
+        blockedHosts: [...collector.blockedHosts]
+      },
+      contextPercent: Math.round(session.contextTokens / this.limits.contextWindow * 100),
+      ...session.costUsd === void 0 ? {} : { sessionCostUsd: session.costUsd },
+      ...isCostIncomplete(session) ? { sessionCostIncomplete: true } : {},
+      ...store === void 0 ? {} : {
+        keptChanges: session.undo.points.filter((p) => (p.changedFiles ?? 0) > 0).length
+      }
+    };
+    session.journal?.write({ type: "receipt", receipt });
+    return receipt;
+  }
   /** The last finished plan of this process, for /schedule (0.7). */
   get lastPlan() {
     return this.plan;
@@ -9434,7 +9686,7 @@ ${neutralizeTags(output)}`
         text: "There is no finished plan in this chat. Make one in plan mode (/plan), then type /schedule."
       };
     }
-    const { createJob } = await import("./create-W6BV75QX.js");
+    const { createJob } = await import("./create-OACSGJ37.js");
     const created = await createJob({
       root: this.root,
       executor: this.executor,
@@ -9517,7 +9769,7 @@ ${result.stderr.text}`)
    */
   async cancelJob(id2, agent = {}) {
     const { loadJob, saveJob } = await import("./job-7JOI4YIQ.js");
-    const { defaultAgentEnv, nightSpec, removeAgent, removeSpec } = await import("./launchd-3A3ONEW5.js");
+    const { defaultAgentEnv, nightSpec, removeAgent, removeSpec } = await import("./launchd-QG6R5RAK.js");
     if (id2 === "night") {
       const removed = await removeSpec(
         agent.executor ?? this.executor,
@@ -9549,8 +9801,8 @@ ${result.stderr.text}`)
    */
   async deleteJob(id2, signal, agent = {}) {
     const { loadJob } = await import("./job-7JOI4YIQ.js");
-    const { defaultAgentEnv, removeAgent } = await import("./launchd-3A3ONEW5.js");
-    const { jobLeftovers, removeJob } = await import("./remove-42WQNVPX.js");
+    const { defaultAgentEnv, removeAgent } = await import("./launchd-QG6R5RAK.js");
+    const { jobLeftovers, removeJob } = await import("./remove-STX5UO7X.js");
     let job;
     try {
       job = await loadJob(this.root, id2);
@@ -9722,7 +9974,7 @@ ${result.stderr.text}`)
    * The files it writes are new only; the turn's own writes go through the normal approvals.
    */
   async init(signal) {
-    const { runInit } = await import("./run-PTMRQCIU.js");
+    const { runInit } = await import("./run-W4TK52WT.js");
     const result = await runInit({
       root: this.root,
       home: this.commandsHome,
@@ -9757,6 +10009,8 @@ ${result.stderr.text}`)
     await this.staged?.remove().catch(() => {
     });
   }
+  /** UX U2: the proxy runs with no host on the list, only to ask for the hosts that commands need. */
+  watchingNetwork = false;
   /** The network allowlist in effect (0.13): the settings entries, or [] when the proxy is off. */
   networkAllowlist() {
     return this.networkProxy === void 0 ? [] : [...this.settings.network?.allow ?? []];
@@ -9768,9 +10022,11 @@ ${result.stderr.text}`)
    */
   async startNetwork(signal) {
     const entries = this.settings.network?.allow ?? [];
-    if (entries.length === 0 || this.executor.isolation !== "os") return;
+    if (this.executor.isolation !== "os") return;
+    const watch = entries.length === 0 && this.networkOptions.watch === true;
+    if (entries.length === 0 && !watch) return;
     this.networkStarted ??= (async () => {
-      if (this.networkOptions.approved !== true) {
+      if (!watch && this.networkOptions.approved !== true) {
         const trust = await TrustStore.open(this.networkOptions.home ?? homedir5());
         const hash = networkHash(entries);
         const known = trust.networkHash(this.root);
@@ -9790,9 +10046,11 @@ ${result.stderr.text}`)
       if (this.executor.name === "bwrap") {
         bridge = nodeBinary();
         if (bridge === void 0) {
-          this.onNotice?.(
-            "Network for commands: off. On Linux the allowlist needs node on the PATH (for the bridge into the sandbox)."
-          );
+          if (!watch) {
+            this.onNotice?.(
+              "Network for commands: off. On Linux the allowlist needs node on the PATH (for the bridge into the sandbox)."
+            );
+          }
           return;
         }
       }
@@ -9807,6 +10065,10 @@ ${result.stderr.text}`)
         policy: { ...started, ...bridge === void 0 ? {} : { bridge } },
         takeBlocked: () => proxy.takeBlocked()
       });
+      if (watch) {
+        this.watchingNetwork = true;
+        return;
+      }
       this.onNotice?.(
         `Network for commands: ${entries.join(", ")}, through Garuda's proxy. Other hosts ask.`
       );
@@ -9840,12 +10102,15 @@ ${result.stderr.text}`)
         readOnly: false,
         info: {
           target: { kind: "url", url: `https://${host2}`, host: host2 },
-          preview: `A command in the sandbox wants to reach ${host2}:${port} through Garuda's proxy. The host is not on the network allowlist ("network.allow" in .garuda/settings.json).`,
+          preview: this.watchingNetwork ? `A command in the sandbox wants to reach ${host2}:${port}. Commands have no network unless you allow a host; Garuda's proxy sees only the host name.` : `A command in the sandbox wants to reach ${host2}:${port} through Garuda's proxy. The host is not on the network allowlist ("network.allow" in .garuda/settings.json).`,
           title: `Let a command reach ${host2}?`
         }
       },
       this.turnSignal ?? new AbortController().signal
     );
+    if (decision.allowed && decision.remembered === true) {
+      this.onNotice?.(networkKeepHint(host2));
+    }
     return decision.allowed ? { allowed: true } : { allowed: false, reason: decision.reason.replace(/\.$/, "") };
   }
   get lspHome() {
@@ -9879,7 +10144,7 @@ ${result.stderr.text}`)
   }
   /** Install a language server into ~/.garuda/lsp (the user asked for it). */
   async installLsp(language, signal) {
-    const { installServer } = await import("./install-TKWN5AYH.js");
+    const { installServer } = await import("./install-4ST5BNRG.js");
     const result = await installServer(language, {
       executor: this.executor,
       home: this.lspHome,
@@ -9890,7 +10155,7 @@ ${result.stderr.text}`)
   }
   /** autoInstall (~/.garuda/lsp.json): ask before a managed install. */
   async askInstall(language, signal) {
-    const { installCommand } = await import("./install-TKWN5AYH.js");
+    const { installCommand } = await import("./install-4ST5BNRG.js");
     const { LANGUAGE_LABELS } = await import("./manager-4PMSXT47.js");
     const { managedLabel, managedDir } = await import("./servers-6YDGWOZ6.js");
     const dir = managedDir(language, this.lspHome);
@@ -9923,7 +10188,7 @@ ${result.stderr.text}`)
   async startMcp(signal) {
     if (this.mcpServers.length === 0) return;
     this.mcpStarted ??= (async () => {
-      const { McpManager } = await import("./manager-TCYTA5XU.js");
+      const { McpManager } = await import("./manager-L25IUXHW.js");
       const { AuthStore } = await import("./oauth-W6OK6XXO.js");
       const manager = new McpManager({
         root: this.root,
@@ -10091,6 +10356,36 @@ ${result.stderr.text}`)
   async undo(signal) {
     return this.undoCoordinator.undo(this.current, this.pendingNotes, signal);
   }
+  /** The undo points of this session, oldest first (UX U6: the /rewind list). */
+  get rewindPoints() {
+    return this.current?.undo.points ?? [];
+  }
+  /** /rewind <n> (UX U6): back to the start of turn n (1-based in the list). */
+  async rewind(turn, signal) {
+    return this.undoCoordinator.rewind(this.current, turn - 1, this.pendingNotes, signal);
+  }
+  /**
+   * /rewind fork <n> (UX U6): a new session with the conversation up to the start of turn n, and
+   * the files as they were then. The old session stays on disk as it is.
+   */
+  async fork(turn, signal) {
+    const old = this.current;
+    if (old === void 0) return "No turn has run in this session yet.";
+    const restored = await this.undoCoordinator.restoreForFork(old, turn - 1, signal);
+    if (!restored.ok) return restored.text;
+    const point = old.undo.points[turn - 1];
+    const messages = structuredClone(old.messages.slice(0, point.messages));
+    this.newSession();
+    const fresh = this.ensureSession();
+    fresh.messages = messages;
+    fresh.turns = turn - 1;
+    fresh.journal?.write({ type: "fork", from: { sessionId: old.id, turn }, messages });
+    fresh.journal?.write({
+      type: "title",
+      title: cleanTitle(`Fork of turn ${turn}: ${point.prompt}`)
+    });
+    return `New session ${fresh.id}: the conversation up to turn ${turn} ("${point.prompt}"), and the files as they were then. The old session ${old.id} stays as it was: /sessions opens it.`;
+  }
   /** /redo (0.4): bring back the last undone turn: its files and its messages. */
   async redo(signal) {
     return this.undoCoordinator.redo(this.current, this.pendingNotes, signal);
@@ -10192,4 +10487,4 @@ export {
   modelFacts,
   Runtime
 };
-//# sourceMappingURL=chunk-NHWHG3SW.js.map
+//# sourceMappingURL=chunk-5UDYQ5MK.js.map