@persistmemory/cli 0.5.0 → 0.6.0

package/dist/bin.js

@@ -344,7 +344,7 @@ var SignalFired = class extends Error {
 };
 function untilAborted(work, signal) {
   work.catch(() => void 0);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal.aborted) {
       reject(new SignalFired());
       return;
@@ -354,7 +354,7 @@ function untilAborted(work, signal) {
     work.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve9(value);
+        resolve8(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -364,14 +364,14 @@ function untilAborted(work, signal) {
   });
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve8, reject) => {
     if (signal?.aborted) {
       reject(new AbortError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve9();
+      resolve8();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
@@ -1404,7 +1404,7 @@ function shortDate(iso) {
 }
 
 // src/help.ts
-var VERSION = true ? "0.5.0" : versionFromManifest();
+var VERSION = true ? "0.6.0" : versionFromManifest();
 var PACKAGE = "@persistmemory/cli";
 var HELP = `
   pm \u2014 PersistMemory from your terminal
@@ -1447,23 +1447,17 @@ var HELP = `
     remember --file <path>           capture a file's contents
 
     agent                            answer file and command requests from this
-                                     machine. Reads the folders in your home
-                                     directory \u2014 never anything hidden \u2014 and
-                                     nothing outside them. It says which ones
-                                     when it starts. Stays in the foreground;
-                                     background it and stop it later with:
+                                     machine. Reads anywhere on it \u2014 you
+                                     approve every request first, and see the
+                                     exact path or command before you do.
+                                     Stays in the foreground; background it
+                                     and stop it later with:
                                        nohup pm agent > ~/agent.log 2>&1 &
                                        pkill -f "pm agent"
-    agent --root <dir> [--root ...]  choose the folders for this run
+    agent --root <dir> [--root ...]  narrow it to these folders, for this run
 
-    Settings live in ~/.persistmemory/agent.json, and apply every time:
-
-      {
-        "roots": ["~/code", "~/Documents"],
-        "mode":  "ask",          ask | auto-read | plan
-        "allow": ["swift"],      programs this machine treats as reads
-        "deny":  ["rm"]          programs it refuses, whatever is approved
-      }
+    A command that reaches the network, or that runs a language, is refused by
+    this machine whatever anybody approves.
 
     search <query>                   search your memory
     list memories                    the most recent memories
@@ -1622,8 +1616,8 @@ async function startLoopback(options = {}) {
   const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
   let resolveCallback;
   let rejectCallback;
-  const received = new Promise((resolve9, reject) => {
-    resolveCallback = resolve9;
+  const received = new Promise((resolve8, reject) => {
+    resolveCallback = resolve8;
     rejectCallback = reject;
   });
   const server = createServer((request, response) => {
@@ -1659,9 +1653,9 @@ async function startLoopback(options = {}) {
     response.end(donePage(callback));
     resolveCallback?.(callback);
   });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve8, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve9);
+    server.listen(0, "127.0.0.1", resolve8);
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -1925,7 +1919,7 @@ function safeEqual(a, b) {
 }
 async function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve8, reject) => {
     const child = spawn(command, args, {
       stdio: "ignore",
       // Detached so closing the terminal does not close the browser, and so
@@ -1934,7 +1928,7 @@ async function openBrowser(url) {
     });
     child.once("error", reject);
     child.unref();
-    resolve9();
+    resolve8();
   });
 }
 async function describe(response) {
@@ -1996,16 +1990,16 @@ async function currentCredential(resolved, deps) {
 // src/context.ts
 import { createInterface } from "node:readline";
 async function askOnTty(prompt, input = process.stdin, output = process.stdout) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve8) => {
     const readline = createInterface({ input, output });
     let answered = false;
     readline.question(prompt, (answer3) => {
       answered = true;
-      resolve9(answer3.trim());
+      resolve8(answer3.trim());
       readline.close();
     });
     readline.once("close", () => {
-      if (!answered) resolve9("");
+      if (!answered) resolve8("");
     });
   });
 }
@@ -2015,16 +2009,16 @@ var BACKSPACE = "\b";
 async function readSecretFromTty(prompt) {
   const input = process.stdin;
   if (!input.isTTY) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve8) => {
       const readline = createInterface({ input });
       let answered = false;
       readline.once("line", (line) => {
         answered = true;
-        resolve9(line.trim());
+        resolve8(line.trim());
         readline.close();
       });
       readline.once("close", () => {
-        if (!answered) resolve9("");
+        if (!answered) resolve8("");
       });
     });
   }
@@ -2033,14 +2027,14 @@ async function readSecretFromTty(prompt) {
   input.setRawMode?.(true);
   input.resume();
   input.setEncoding("utf8");
-  return new Promise((resolve9) => {
+  return new Promise((resolve8) => {
     let value = "";
     const finish2 = () => {
       input.removeListener("data", onData);
       input.setRawMode?.(previouslyRaw);
       input.pause();
       process.stdout.write("\n");
-      resolve9(value.trim());
+      resolve8(value.trim());
     };
     const onData = (chunk) => {
       for (const character of chunk) {
@@ -2076,9 +2070,9 @@ async function readStdin() {
 
 // src/commands/agent.ts
 import { hostname } from "node:os";
-import { homedir as homedir3 } from "node:os";
-import { basename, join as join6, resolve as resolve4 } from "node:path";
-import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, join as join5, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
 
 // src/files.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
@@ -2376,7 +2370,7 @@ async function runCommand(argv, policy) {
   } catch {
     return { ok: false, text: `${cwd} does not exist.` };
   }
-  return new Promise((resolve9) => {
+  return new Promise((resolve8) => {
     const child = spawn2(argv[0], argv.slice(1), {
       cwd,
       // NO shell. With one, every character a model can produce is a character
@@ -2411,7 +2405,7 @@ async function runCommand(argv, policy) {
     const timer = setTimeout(() => child.kill("SIGKILL"), TIMEOUT_MS);
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve9({ ok: false, text: `Could not run it: ${error.message}` });
+      resolve8({ ok: false, text: `Could not run it: ${error.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
@@ -2423,98 +2417,13 @@ async function runCommand(argv, policy) {
 
 [exit code ${code}]` : ""
       ].join("");
-      resolve9({ ok: code === 0, text: `$ ${describe2(argv)}
+      resolve8({ ok: code === 0, text: `$ ${describe2(argv)}
 
 ${output}${notes}` });
     });
   });
 }
 
-// src/commands/agent-config.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync, statSync as statSync3 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join5, resolve as resolve3 } from "node:path";
-var NOT_MATERIAL = /* @__PURE__ */ new Set([
-  "Library",
-  "Applications",
-  "System",
-  "Public",
-  "node_modules",
-  "go",
-  "Parallels",
-  "VirtualBox VMs"
-]);
-function discoverRoots(home = homedir2(), list = (path) => {
-  try {
-    return readdirSync(path);
-  } catch {
-    return [];
-  }
-}, isDirectory = (path) => {
-  try {
-    return statSync3(path).isDirectory();
-  } catch {
-    return false;
-  }
-}) {
-  return list(home).filter((name) => !name.startsWith(".")).filter((name) => !NOT_MATERIAL.has(name)).map((name) => join5(home, name)).filter(isDirectory).sort();
-}
-function expandHome(path, home = homedir2()) {
-  return path.startsWith("~") ? resolve3(home, path.slice(1).replace(/^[/\\]/, "")) : resolve3(path);
-}
-var MODES = /* @__PURE__ */ new Set(["ask", "auto-read", "plan"]);
-function readAgentConfig(path, read2 = (at) => readFileSync5(at, "utf8"), exists = (at) => existsSync5(at), home = homedir2()) {
-  if (!exists(path)) return {};
-  let parsed;
-  try {
-    parsed = JSON.parse(read2(path));
-  } catch (error) {
-    return { error: `${path} is not valid JSON: ${error instanceof Error ? error.message : ""}` };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return { error: `${path} should hold an object, like {"roots": ["~/code"]}.` };
-  }
-  const held = parsed;
-  const config = {};
-  if (held["roots"] !== void 0) {
-    if (!Array.isArray(held["roots"]) || held["roots"].some((one) => typeof one !== "string")) {
-      return { error: `${path}: "roots" should be a list of folders.` };
-    }
-    config.roots = held["roots"].map((one) => expandHome(one, home));
-  }
-  if (held["mode"] !== void 0) {
-    if (typeof held["mode"] !== "string" || !MODES.has(held["mode"])) {
-      return { error: `${path}: "mode" should be "ask", "auto-read" or "plan".` };
-    }
-    config.mode = held["mode"];
-  }
-  for (const key of ["allow", "deny"]) {
-    if (held[key] === void 0) continue;
-    if (!Array.isArray(held[key]) || held[key].some((one) => typeof one !== "string")) {
-      return { error: `${path}: "${key}" should be a list of program names.` };
-    }
-    config[key] = held[key];
-  }
-  return { config };
-}
-function resolveAgentConfig(args) {
-  const roots = args.flagRoots && args.flagRoots.length > 0 ? args.flagRoots : args.stored?.roots && args.stored.roots.length > 0 ? args.stored.roots : args.discovered ?? [];
-  return {
-    roots,
-    /*
-          `ask` unless the owner said otherwise.
-    
-          The mode decides how much happens with nobody watching, so the default
-          is the one that does least. `auto-read` is a reasonable thing to choose
-          and an unreasonable thing to be given.
-        */
-    mode: args.stored?.mode ?? "ask",
-    allow: args.stored?.allow ?? [],
-    deny: args.stored?.deny ?? [],
-    source: args.flagRoots && args.flagRoots.length > 0 ? "flags" : args.stored?.roots && args.stored.roots.length > 0 ? "config" : "discovered"
-  };
-}
-
 // src/commands/agent.ts
 async function said(response, fallback) {
   const body = await response.json().catch(() => void 0);
@@ -2522,7 +2431,7 @@ async function said(response, fallback) {
   return message2 ?? `${fallback} (${response.status})`;
 }
 function locate(roots, requested) {
-  const expanded = requested.startsWith("~") ? resolve4(homedir3(), requested.slice(1).replace(/^[/\\]/, "")) : requested;
+  const expanded = requested.startsWith("~") ? resolve3(homedir2(), requested.slice(1).replace(/^[/\\]/, "")) : requested;
   if (!expanded.includes("/") && !expanded.includes("\\")) {
     const wanted2 = expanded.trim().toLowerCase();
     const named = roots.find((root) => basename(root).toLowerCase() === wanted2);
@@ -2538,29 +2447,23 @@ function locate(roots, requested) {
   throw new Error(`${requested} is not inside any allowed folder (${roots.join(", ")})`);
 }
 function uncontested(target) {
-  if (!existsSync6(target)) return target;
+  if (!existsSync5(target)) return target;
   const dot = target.lastIndexOf(".");
   const stem = dot > target.lastIndexOf("/") && dot !== -1 ? target.slice(0, dot) : target;
   const extension = stem === target ? "" : target.slice(dot);
   for (let n = 1; n < 1e3; n += 1) {
     const candidate = `${stem} (${n})${extension}`;
-    if (!existsSync6(candidate)) return candidate;
+    if (!existsSync5(candidate)) return candidate;
   }
   throw new Error(`${target} and a thousand names beside it are taken.`);
 }
-async function answer(context, apiUrl, token, settings, request) {
-  const roots = settings.roots;
+async function answer(context, apiUrl, token, roots, request) {
   let located;
   if (request.kind === "run_command") {
     if (!request.argv || request.argv.length === 0) {
       return { ok: false, error: "No command was given." };
     }
-    const policy = {
-      mode: settings.mode,
-      allow: settings.allow,
-      deny: settings.deny,
-      roots
-    };
+    const policy = { mode: "ask", allow: [], deny: [], roots };
     const outcome = await runCommand(request.argv, policy);
     if (!outcome.ok) return { ok: false, error: outcome.text };
     return upload(
@@ -2590,10 +2493,10 @@ async function answer(context, apiUrl, token, settings, request) {
     }
     try {
       let target = located;
-      if (existsSync6(located) && statSync4(located).isDirectory()) {
+      if (existsSync5(located) && statSync3(located).isDirectory()) {
         const disposition = fetched.headers.get("content-disposition") ?? "";
         const named = /filename="([^"]+)"/.exec(disposition)?.[1];
-        target = join6(located, basename(named ?? "file"));
+        target = join5(located, basename(named ?? "file"));
       }
       target = uncontested(target);
       writeFileSync4(target, downloaded, { flag: "wx" });
@@ -2616,12 +2519,12 @@ ${downloaded.length} bytes
   let filename = request.path.split("/").pop() ?? "file";
   if (request.kind === "list_dir") {
     try {
-      const stats = statSync4(located);
+      const stats = statSync3(located);
       if (!stats.isDirectory()) return { ok: false, error: `${request.path} is not a folder.` };
-      const entries = readdirSync2(located, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).slice(0, MAX_LISTED).map((entry) => {
+      const entries = readdirSync(located, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).slice(0, MAX_LISTED).map((entry) => {
         if (entry.isDirectory()) return `${entry.name}/`;
         try {
-          return `${entry.name}  ${sizeOf(join6(located, entry.name))}`;
+          return `${entry.name}  ${sizeOf(join5(located, entry.name))}`;
         } catch {
           return entry.name;
         }
@@ -2639,9 +2542,9 @@ ${listing}
     }
   }
   try {
-    const stats = statSync4(located);
+    const stats = statSync3(located);
     if (!stats.isFile()) return { ok: false, error: `${request.path} is not a file.` };
-    bytes = readFileSync6(located);
+    bytes = readFileSync5(located);
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : "could not read it" };
   }
@@ -2683,7 +2586,7 @@ async function upload(apiUrl, token, filename, bytes) {
 }
 var MAX_LISTED = 200;
 function sizeOf(path) {
-  const size = statSync4(path).size;
+  const size = statSync3(path).size;
   if (size < 1024) return `${size} B`;
   if (size < 1024 * 1024) return `${Math.round(size / 1024)} KB`;
   return `${(size / (1024 * 1024)).toFixed(1)} MB`;
@@ -2695,41 +2598,16 @@ async function agentCommand(context) {
     return 1;
   }
   const roots = (listFlag(context.args, "root") ?? []).map(
-    (one) => resolve4(one.startsWith("~") ? resolve4(homedir3(), one.slice(1).replace(/^[/\\]/, "")) : one)
+    (one) => resolve3(one.startsWith("~") ? resolve3(homedir2(), one.slice(1).replace(/^[/\\]/, "")) : one)
   );
-  const configPath = join6(context.paths.dir, "agent.json");
-  const stored = readAgentConfig(configPath);
-  if (stored.error) {
-    context.error(stored.error);
-    return 1;
-  }
-  const settings = resolveAgentConfig({
-    flagRoots: roots,
-    ...stored.config ? { stored: stored.config } : {},
-    discovered: discoverRoots()
-  });
-  if (settings.roots.length === 0) {
-    context.error(
-      "There is nothing in your home directory this machine would offer, so say which folders it may read from:"
-    );
-    context.error("");
-    context.error("  pm agent --root ~/projects");
-    context.error("");
-    context.error(`Or write them once in ${configPath}:`);
-    context.error("");
-    context.error('  { "roots": ["~/projects"], "mode": "ask" }');
-    return 1;
-  }
-  roots.length = 0;
-  roots.push(...settings.roots);
-  const shown = settings.roots.map((path) => path.replace(homedir3(), "~"));
-  const where = settings.source === "flags" ? "" : settings.source === "config" ? ` (from ${configPath})` : " (found in your home directory)";
+  const everywhere = roots.length === 0;
+  if (everywhere) roots.push("/");
   context.print(
-    `Reading ${shown.join(", ")} \u2014 nothing outside them${where}. Mode: ${settings.mode}.`
+    everywhere ? "Reading anywhere on this machine. You approve every request first, and see the exact path or command before you do. Narrow it with --root if you want to." : `Reading ${roots.map((path) => path.replace(homedir2(), "~")).join(", ")} \u2014 nothing outside them.`
   );
   for (const root of roots) {
     try {
-      if (!statSync4(root).isDirectory()) {
+      if (!statSync3(root).isDirectory()) {
         context.error(`${root} is not a folder.`);
         return 1;
       }
@@ -2803,7 +2681,7 @@ async function agentCommand(context) {
         const { items } = await claimed.json();
         for (const request of items) {
           context.print(`Reading ${request.path}`);
-          const outcome = await answer(context, apiUrl, await authorization(), settings, request);
+          const outcome = await answer(context, apiUrl, await authorization(), roots, request);
           const done = await call(
             `complete/${encodeURIComponent(request.id)}`,
             outcome.ok ? { result: { attachToken: outcome.attachToken } } : { error: outcome.error }
@@ -2825,8 +2703,8 @@ async function agentCommand(context) {
 
 // src/commands/google.ts
 import { writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename2, resolve as resolve5 } from "node:path";
-import { readFileSync as readFileSync7 } from "node:fs";
+import { basename as basename2, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
 async function callApi(context, path, init = {}) {
   const credential = context.resolved.credential;
   if (!credential) {
@@ -2891,7 +2769,7 @@ async function driveGet(context, fileId) {
   const disposition = response.headers.get("content-disposition") ?? "";
   const named = /filename="([^"]+)"/.exec(disposition)?.[1];
   const out = stringFlag(context.args, "out");
-  const target = resolve5(out ?? basename2(named ?? fileId));
+  const target = resolve4(out ?? basename2(named ?? fileId));
   writeFileSync5(target, Buffer.from(await response.arrayBuffer()));
   context.print(target);
   return 0;
@@ -2903,7 +2781,7 @@ async function drivePut(context, path) {
   }
   let bytes;
   try {
-    bytes = readFileSync7(resolve5(path));
+    bytes = readFileSync6(resolve4(path));
   } catch {
     context.error(`Cannot read ${path}.`);
     return 1;
@@ -2987,8 +2865,8 @@ async function mailCommand(context) {
 }
 
 // src/commands/requests.ts
-import { existsSync as existsSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { existsSync as existsSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 async function requestsCommand(context) {
   if (context.args.words[1] === "get") return collectCommand(context);
   const credential = context.resolved.credential;
@@ -3056,8 +2934,8 @@ async function collectCommand(context) {
     return 1;
   }
   const name = stringFlag(context.args, "output", "o") ?? filename;
-  const target = resolve6(name);
-  if (existsSync7(target)) {
+  const target = resolve5(name);
+  if (existsSync6(target)) {
     context.error(`${target} already exists. Pass --output to write somewhere else.`);
     return 1;
   }
@@ -3067,14 +2945,14 @@ async function collectCommand(context) {
 }
 
 // src/workspace.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname3, join as join7, resolve as resolvePath2 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname3, join as join6, resolve as resolvePath2 } from "node:path";
 var WORKSPACE_FILE = ".persistmemory.json";
 function findWorkspace(from = process.cwd()) {
   let dir = resolvePath2(from);
   for (; ; ) {
-    const file = join7(dir, WORKSPACE_FILE);
-    if (existsSync8(file)) {
+    const file = join6(dir, WORKSPACE_FILE);
+    if (existsSync7(file)) {
       const config = readWorkspace(file);
       if (config) return { file, dir, config };
     }
@@ -3085,7 +2963,7 @@ function findWorkspace(from = process.cwd()) {
 }
 function readWorkspace(file) {
   try {
-    const parsed = JSON.parse(readFileSync8(file, "utf8"));
+    const parsed = JSON.parse(readFileSync7(file, "utf8"));
     const space = parsed.space;
     if (space && typeof space === "object" && typeof space.id === "string" && space.id !== "" && typeof space.name === "string") {
       return { space: { id: space.id, name: space.name } };
@@ -3096,7 +2974,7 @@ function readWorkspace(file) {
   }
 }
 function writeWorkspace(dir, config) {
-  const file = join7(dir, WORKSPACE_FILE);
+  const file = join6(dir, WORKSPACE_FILE);
   writeFileSync7(file, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return file;
@@ -3366,9 +3244,9 @@ function message(error) {
 }
 
 // src/commands/maintain.ts
-import { existsSync as existsSync9, rmSync } from "node:fs";
+import { existsSync as existsSync8, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { dirname as dirname4, resolve as resolve8 } from "node:path";
+import { dirname as dirname4, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 function installArgs(pkg = PACKAGE) {
   return ["install", "-g", "--prefer-online", `${pkg}@latest`];
@@ -3432,7 +3310,7 @@ Delete the file it runs from: ${processPath()}`
   return 0;
 }
 async function deleteCommand(context) {
-  if (!existsSync9(context.paths.dir)) {
+  if (!existsSync8(context.paths.dir)) {
     context.print(`Nothing to delete: ${context.paths.dir} does not exist.`);
     return 0;
   }
@@ -3461,7 +3339,7 @@ async function deleteCommand(context) {
   return 0;
 }
 function removeEverything(context) {
-  const dir = resolve8(context.paths.dir);
+  const dir = resolve7(context.paths.dir);
   if (dir === "/" || dir.split("/").filter(Boolean).length < 2) {
     context.error(`Refusing to delete ${dir}: that does not look like a data directory.`);
     return;
@@ -3473,7 +3351,7 @@ function installer() {
 }
 function processPath() {
   try {
-    return resolve8(dirname4(fileURLToPath(import.meta.url)));
+    return resolve7(dirname4(fileURLToPath(import.meta.url)));
   } catch {
     return process.argv[1] ?? "";
   }
@@ -3485,12 +3363,12 @@ import { randomUUID } from "node:crypto";
 import { relative as relative2 } from "node:path";
 
 // src/events.ts
-import { appendFileSync, existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync9 } from "node:fs";
-import { join as join8 } from "node:path";
+import { appendFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8 } from "node:fs";
+import { join as join7 } from "node:path";
 function openSessionLog(paths, id) {
-  const directory = join8(paths.dir, "sessions");
+  const directory = join7(paths.dir, "sessions");
   mkdirSync3(directory, { recursive: true, mode: 448 });
-  const path = join8(directory, `${id}.jsonl`);
+  const path = join7(directory, `${id}.jsonl`);
   return {
     id,
     path,
@@ -3502,8 +3380,8 @@ function openSessionLog(paths, id) {
       }
     },
     read() {
-      if (!existsSync10(path)) return [];
-      return readFileSync9(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      if (!existsSync9(path)) return [];
+      return readFileSync8(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
         try {
           return [JSON.parse(line)];
         } catch {
@@ -3580,9 +3458,9 @@ async function sessionCommand(context) {
   context.print(`  Ask anything. /help for commands, /exit to leave.
 `);
   const readline = createInterface2({ input: process.stdin, output: process.stdout });
-  const ask = (prompt) => new Promise((resolve9) => {
-    readline.question(prompt, resolve9);
-    readline.once("close", () => resolve9(void 0));
+  const ask = (prompt) => new Promise((resolve8) => {
+    readline.question(prompt, resolve8);
+    readline.once("close", () => resolve8(void 0));
   });
   const root = process.cwd();
   let running = true;
@@ -3766,7 +3644,7 @@ async function write2(args) {
 }
 
 // src/commands/memory.ts
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 
 // src/spaces.ts
 async function spacesFor(context, client, env = process.env) {
@@ -3830,7 +3708,7 @@ async function rememberCommand(context) {
   let text;
   if (file) {
     try {
-      text = readFileSync10(file, "utf8");
+      text = readFileSync9(file, "utf8");
     } catch {
       context.error(`Could not read ${file}.`);
       return 1;