@cryer/star-cli 0.1.0 → 0.1.1

package/dist/main.js

@@ -126,6 +126,42 @@ function compactMessages(messages, maxTokens) {
 
 // src/permissions/gate.ts
 import path from "path";
+
+// src/permissions/allow.ts
+function parseAllowRule(rule) {
+  const match = /^([\w-]+)(?:\((.*)\))?$/.exec(rule.trim());
+  if (!match) return null;
+  return { toolName: match[1], pattern: match[2] };
+}
+function globMatch(pattern, value) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+function requestTarget(req) {
+  if (typeof req.args !== "object" || req.args === null) return void 0;
+  const args = req.args;
+  const key = req.toolName === "bash" ? "command" : "path";
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function matchAllowRule(rule, req) {
+  if (rule.toolName !== req.toolName) return false;
+  if (rule.pattern === void 0) return true;
+  const target = requestTarget(req);
+  return target !== void 0 && globMatch(rule.pattern, target);
+}
+function isAllowedByRules(rules, req) {
+  return rules.some((raw) => {
+    const rule = parseAllowRule(raw);
+    return rule !== null && matchAllowRule(rule, req);
+  });
+}
+function buildAllowRule(req) {
+  const target = requestTarget(req);
+  return target !== void 0 ? `${req.toolName}(${target})` : req.toolName;
+}
+
+// src/permissions/gate.ts
 var FILE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "read_file"]);
 var DANGEROUS_COMMAND_PATTERNS = [
   /rm\s+-rf\s+\/(?:\s|$|;|&)/i,
@@ -163,7 +199,7 @@ function isSensitivePath(p) {
   }
   return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
 }
-function checkPermission(mode, req, ctx) {
+function checkPermission(mode, req, ctx, allowRules = []) {
   const command = getStringArg(req.args, "command");
   const filePath = getStringArg(req.args, "path");
   if (req.toolName === "bash" && command !== void 0 && DANGEROUS_COMMAND_PATTERNS.some((pattern) => pattern.test(command))) {
@@ -186,6 +222,9 @@ function checkPermission(mode, req, ctx) {
   if (mode === "readonly") {
     return req.level === "read" ? "allow" : "deny";
   }
+  if (isAllowedByRules(allowRules, req)) {
+    return "allow";
+  }
   return req.level === "read" ? "allow" : "ask";
 }
 
@@ -209,10 +248,12 @@ var AgentLoop = class {
   async persist(message) {
     await this.opts.sessionStore?.append(message);
   }
-  async *stream(input, signal) {
+  async *stream(input, signal, opts) {
     const userMessage = { role: "user", content: input };
     this.messages.push(userMessage);
-    await this.persist(userMessage);
+    await this.persist(
+      opts?.persistAs !== void 0 ? { role: "user", content: opts.persistAs } : userMessage
+    );
     const { config, registry, cwd } = this.opts;
     const aiTools = this.buildAiTools();
     for (let step = 0; step < config.maxSteps; step++) {
@@ -335,7 +376,8 @@ ${summary}`
     const decision = checkPermission(
       config.permissionMode,
       { toolName: call.name, args: call.args, level: tool.permission },
-      { cwd }
+      { cwd },
+      config.permissions.allow
     );
     if (decision === "deny") {
       return { content: `Permission denied for tool "${call.name}".`, isError: true };
@@ -368,10 +410,215 @@ ${summary}`
   }
 };
 
+// src/cli/mentions.ts
+import { readFile, stat as stat2 } from "fs/promises";
+import path3 from "path";
+
+// src/tools/fs/util.ts
+import { readdir, stat } from "fs/promises";
+import path2 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+async function walkFiles(root, skipDirs = SKIP_DIRS) {
+  const out = [];
+  async function walk(dir, relBase) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path2.join(dir, entry.name);
+      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          await walk(abs, rel);
+        }
+      } else if (entry.isFile()) {
+        try {
+          const st = await stat(abs);
+          out.push({ abs, rel, mtimeMs: st.mtimeMs });
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(root, "");
+  return out;
+}
+var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
+function globToRegExp(pattern) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern.charAt(i);
+    if (c === "*") {
+      if (pattern.charAt(i + 1) === "*") {
+        i += 2;
+        if (pattern.charAt(i) === "/") {
+          i += 1;
+          re += "(?:[^/]+/)*";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i += 1;
+    } else {
+      re += c.replace(REGEX_SPECIALS, "\\$&");
+      i += 1;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchesGlob(pattern, relPath) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (!normalized.includes("/")) {
+    const base = relPath.split("/").pop() ?? relPath;
+    return globToRegExp(normalized).test(base);
+  }
+  return globToRegExp(normalized).test(relPath);
+}
+function isSensitivePath2(filePath) {
+  const base = path2.basename(filePath);
+  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
+    return false;
+  }
+  if (base === ".env" || base.startsWith(".env.")) {
+    return true;
+  }
+  if (base === "id_rsa" || base.endsWith(".pem")) {
+    return true;
+  }
+  return false;
+}
+
+// src/cli/mentions.ts
+var MAX_MENTION_BYTES = 100 * 1024;
+var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\]*|[A-Za-z0-9._\-/\\]+)/g;
+function parseMentions(text) {
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ranges = [];
+  for (const match of text.matchAll(MENTION_RE)) {
+    const mention = match[1];
+    const full = match[0];
+    if (mention === void 0 || full === void 0) continue;
+    ranges.push([match.index, match.index + full.length]);
+    if (!seen.has(mention)) {
+      seen.add(mention);
+      mentions.push(mention);
+    }
+  }
+  if (ranges.length === 0) {
+    return { cleanText: text, mentions };
+  }
+  let clean = "";
+  let last = 0;
+  for (const [start, end] of ranges) {
+    clean += text.slice(last, start);
+    last = end;
+  }
+  clean += text.slice(last);
+  const cleanText = clean.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return { cleanText, mentions };
+}
+function isBinaryContent(buf) {
+  const probe = buf.subarray(0, 8e3);
+  return probe.includes(0);
+}
+async function resolveMentions(text, cwd) {
+  const { cleanText, mentions } = parseMentions(text);
+  if (mentions.length === 0) {
+    return { input: text, attached: [], skipped: [] };
+  }
+  const blocks = [];
+  const attached = [];
+  const skipped = [];
+  for (const mention of mentions) {
+    const abs = path3.resolve(cwd, mention);
+    if (isSensitivePath2(abs)) {
+      skipped.push({ path: mention, reason: "sensitive file" });
+      continue;
+    }
+    const st = await stat2(abs).catch(() => null);
+    if (!st) {
+      skipped.push({ path: mention, reason: "file not found" });
+      continue;
+    }
+    if (st.isDirectory()) {
+      skipped.push({ path: mention, reason: "is a directory" });
+      continue;
+    }
+    if (st.size > MAX_MENTION_BYTES) {
+      skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
+      continue;
+    }
+    const buf = await readFile(abs).catch(() => null);
+    if (!buf) {
+      skipped.push({ path: mention, reason: "unreadable" });
+      continue;
+    }
+    if (isBinaryContent(buf)) {
+      skipped.push({ path: mention, reason: "binary file" });
+      continue;
+    }
+    attached.push(mention);
+    blocks.push(`--- @${mention} ---
+${buf.toString("utf8")}
+--- end ---`);
+  }
+  const input = [cleanText, ...blocks].filter((s) => s.length > 0).join("\n\n") || text;
+  return { input, attached, skipped };
+}
+
 // src/cli/repl.tsx
 import { Box as Box7, render, useApp, useInput as useInput3 } from "ink";
 import { useCallback, useEffect, useMemo, useRef as useRef2, useState as useState2 } from "react";
 
+// src/config/save.ts
+import fs from "fs";
+import path5 from "path";
+import { parse, stringify } from "smol-toml";
+
+// src/config/paths.ts
+import os from "os";
+import path4 from "path";
+function starHome() {
+  return process.env.STAR_HOME ?? path4.join(os.homedir(), ".star-cli");
+}
+function globalConfigPath() {
+  return path4.join(starHome(), "config.toml");
+}
+function sessionsDir() {
+  return path4.join(starHome(), "sessions");
+}
+function projectConfigPath(cwd) {
+  return path4.join(cwd, ".star", "config.toml");
+}
+
+// src/config/save.ts
+async function addAllowRule(rule) {
+  const filePath = globalConfigPath();
+  let raw = {};
+  try {
+    const content = await fs.promises.readFile(filePath, "utf8");
+    raw = parse(content);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const permissions = typeof raw.permissions === "object" && raw.permissions !== null ? raw.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  if (allow.includes(rule)) return false;
+  permissions.allow = [...allow, rule];
+  raw.permissions = permissions;
+  await fs.promises.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, stringify(raw), "utf8");
+  return true;
+}
+
 // src/llm/provider.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -435,26 +682,8 @@ function createModel(config, modelName) {
 }
 
 // src/session/store.ts
-import fs from "fs/promises";
-import path3 from "path";
-
-// src/config/paths.ts
-import os from "os";
-import path2 from "path";
-function starHome() {
-  return process.env.STAR_HOME ?? path2.join(os.homedir(), ".star-cli");
-}
-function globalConfigPath() {
-  return path2.join(starHome(), "config.toml");
-}
-function sessionsDir() {
-  return path2.join(starHome(), "sessions");
-}
-function projectConfigPath(cwd) {
-  return path2.join(cwd, ".star", "config.toml");
-}
-
-// src/session/store.ts
+import fs2 from "fs/promises";
+import path6 from "path";
 function generateId(now) {
   const pad = (n) => String(n).padStart(2, "0");
   const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
@@ -476,13 +705,13 @@ var SessionStore = class _SessionStore {
   initialized = false;
   constructor(id) {
     this.id = id;
-    this.dir = path3.join(sessionsDir(), id);
+    this.dir = path6.join(sessionsDir(), id);
   }
   metaPath() {
-    return path3.join(this.dir, "meta.json");
+    return path6.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path3.join(this.dir, "messages.jsonl");
+    return path6.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
     const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
@@ -492,7 +721,7 @@ var SessionStore = class _SessionStore {
   static async open(id) {
     const store = new _SessionStore(id);
     try {
-      const raw = await fs.readFile(store.metaPath(), "utf8");
+      const raw = await fs2.readFile(store.metaPath(), "utf8");
       const meta = JSON.parse(raw);
       if (meta.id !== id) return null;
       store.initialized = true;
@@ -504,14 +733,14 @@ var SessionStore = class _SessionStore {
   static async list(cwd) {
     let entries;
     try {
-      entries = await fs.readdir(sessionsDir());
+      entries = await fs2.readdir(sessionsDir());
     } catch {
       return [];
     }
     const metas = [];
     for (const entry of entries) {
       try {
-        const raw = await fs.readFile(path3.join(sessionsDir(), entry, "meta.json"), "utf8");
+        const raw = await fs2.readFile(path6.join(sessionsDir(), entry, "meta.json"), "utf8");
         const meta = JSON.parse(raw);
         if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
       } catch {
@@ -526,7 +755,7 @@ var SessionStore = class _SessionStore {
       this.initialized = true;
       return;
     }
-    await fs.mkdir(this.dir, { recursive: true });
+    await fs2.mkdir(this.dir, { recursive: true });
     const meta = {
       id: this.id,
       title: "",
@@ -535,24 +764,33 @@ var SessionStore = class _SessionStore {
       createdAt: pending.createdAt,
       updatedAt: pending.createdAt
     };
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
     this.initialized = true;
   }
   async append(message) {
     await this.ensureInitialized();
-    await fs.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+    await fs2.appendFile(this.messagesPath(), `${JSON.stringify(message)}
 `);
     const meta = await this.meta();
     meta.updatedAt = Date.now();
     if (!meta.title && message.role === "user") {
       meta.title = messageText(message).slice(0, 60);
     }
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+  }
+  async replaceMessages(messages) {
+    await this.ensureInitialized();
+    const content = messages.map((message) => JSON.stringify(message)).join("\n");
+    await fs2.writeFile(this.messagesPath(), content ? `${content}
+` : "");
+    const meta = await this.meta();
+    meta.updatedAt = Date.now();
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async messages() {
     let raw;
     try {
-      raw = await fs.readFile(this.messagesPath(), "utf8");
+      raw = await fs2.readFile(this.messagesPath(), "utf8");
     } catch {
       return [];
     }
@@ -569,7 +807,7 @@ var SessionStore = class _SessionStore {
   }
   async meta() {
     await this.ensureInitialized();
-    const raw = await fs.readFile(this.metaPath(), "utf8");
+    const raw = await fs2.readFile(this.metaPath(), "utf8");
     return JSON.parse(raw);
   }
   async setTitle(title) {
@@ -577,7 +815,7 @@ var SessionStore = class _SessionStore {
     const meta = await this.meta();
     meta.title = title;
     meta.updatedAt = Date.now();
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
   async addUsage(delta) {
     await this.ensureInitialized();
@@ -593,7 +831,7 @@ var SessionStore = class _SessionStore {
     usage.completionTokens += delta.completionTokens;
     usage.totalTokens += delta.totalTokens;
     meta.usage = usage;
-    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    await fs2.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
   }
 };
 
@@ -627,17 +865,17 @@ function formatSessionList(metas) {
 // src/tools/bash.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
-import path4 from "path";
+import path7 from "path";
 import { z } from "zod";
 var MAX_OUTPUT = 3e4;
 var DEFAULT_TIMEOUT = 120;
 var MAX_TIMEOUT = 600;
 function findOnPath(exe, exclude) {
-  for (const dir of (process.env.PATH ?? "").split(path4.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path7.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path4.join(dir, exe);
+    const full = path7.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -655,7 +893,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path4.join(path4.dirname(path4.dirname(gitExe)), "bin", "bash.exe");
+    const sibling = path7.join(path7.dirname(path7.dirname(gitExe)), "bin", "bash.exe");
     if (existsSync(sibling)) {
       return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
     }
@@ -762,9 +1000,46 @@ Command timed out after ${timeoutSeconds}s`,
 };
 
 // src/tools/fs/edit.ts
-import { readFile, writeFile } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
 import { z as z2 } from "zod";
+
+// src/tools/fs/snapshots.ts
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import path8 from "path";
+var MAX_SNAPSHOTS = 50;
+var stack = [];
+async function captureSnapshot(filePath, toolName) {
+  let content = null;
+  let existed = false;
+  try {
+    content = await readFile2(filePath, "utf8");
+    existed = true;
+  } catch {
+  }
+  return { path: filePath, existed, content, toolName, timestamp: Date.now() };
+}
+function pushSnapshot(snapshot) {
+  stack.push(snapshot);
+  if (stack.length > MAX_SNAPSHOTS) {
+    stack.splice(0, stack.length - MAX_SNAPSHOTS);
+  }
+}
+async function undoLastSnapshot() {
+  const snapshot = stack.pop();
+  if (!snapshot) {
+    return "Nothing to undo.";
+  }
+  if (snapshot.existed && snapshot.content !== null) {
+    await mkdir(path8.dirname(snapshot.path), { recursive: true });
+    await writeFile(snapshot.path, snapshot.content, "utf8");
+    return `Restored ${snapshot.path} to its state before ${snapshot.toolName}.`;
+  }
+  await rm(snapshot.path, { force: true });
+  return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
+}
+
+// src/tools/fs/edit.ts
 var schema2 = z2.object({
   path: z2.string().describe("File path, absolute or relative to the working directory"),
   old_string: z2.string().min(1).describe("Exact text to replace"),
@@ -777,10 +1052,10 @@ var editFileTool = {
   permission: "write",
   parameters: schema2,
   async execute(args, ctx) {
-    const filePath = path5.resolve(ctx.cwd, args.path);
+    const filePath = path9.resolve(ctx.cwd, args.path);
     let content;
     try {
-      content = await readFile(filePath, "utf8");
+      content = await readFile3(filePath, "utf8");
     } catch (err) {
       return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
     }
@@ -800,97 +1075,25 @@ var editFileTool = {
       };
     }
     const updated = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
-    await writeFile(filePath, updated, "utf8");
+    try {
+      await writeFile2(filePath, updated, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    pushSnapshot({
+      path: filePath,
+      existed: true,
+      content,
+      toolName: "edit_file",
+      timestamp: Date.now()
+    });
     return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
   }
 };
 
 // src/tools/fs/glob.ts
-import path7 from "path";
+import path10 from "path";
 import { z as z3 } from "zod";
-
-// src/tools/fs/util.ts
-import { readdir, stat } from "fs/promises";
-import path6 from "path";
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
-async function walkFiles(root, skipDirs = SKIP_DIRS) {
-  const out = [];
-  async function walk(dir, relBase) {
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (!entries) {
-      return;
-    }
-    for (const entry of entries) {
-      const abs = path6.join(dir, entry.name);
-      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
-          await walk(abs, rel);
-        }
-      } else if (entry.isFile()) {
-        try {
-          const st = await stat(abs);
-          out.push({ abs, rel, mtimeMs: st.mtimeMs });
-        } catch {
-        }
-      }
-    }
-  }
-  await walk(root, "");
-  return out;
-}
-var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
-function globToRegExp(pattern) {
-  let re = "";
-  let i = 0;
-  while (i < pattern.length) {
-    const c = pattern.charAt(i);
-    if (c === "*") {
-      if (pattern.charAt(i + 1) === "*") {
-        i += 2;
-        if (pattern.charAt(i) === "/") {
-          i += 1;
-          re += "(?:[^/]+/)*";
-        } else {
-          re += ".*";
-        }
-      } else {
-        re += "[^/]*";
-        i += 1;
-      }
-    } else if (c === "?") {
-      re += "[^/]";
-      i += 1;
-    } else {
-      re += c.replace(REGEX_SPECIALS, "\\$&");
-      i += 1;
-    }
-  }
-  return new RegExp(`^${re}$`);
-}
-function matchesGlob(pattern, relPath) {
-  const normalized = pattern.replace(/\\/g, "/");
-  if (!normalized.includes("/")) {
-    const base = relPath.split("/").pop() ?? relPath;
-    return globToRegExp(normalized).test(base);
-  }
-  return globToRegExp(normalized).test(relPath);
-}
-function isSensitivePath2(filePath) {
-  const base = path6.basename(filePath);
-  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
-    return false;
-  }
-  if (base === ".env" || base.startsWith(".env.")) {
-    return true;
-  }
-  if (base === "id_rsa" || base.endsWith(".pem")) {
-    return true;
-  }
-  return false;
-}
-
-// src/tools/fs/glob.ts
 var MAX_RESULTS = 100;
 var schema3 = z3.object({
   pattern: z3.string().describe(
@@ -904,7 +1107,7 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path7.resolve(ctx.cwd, args.path ?? ".");
+    const root = path10.resolve(ctx.cwd, args.path ?? ".");
     const files = await walkFiles(root);
     const matched = files.filter((f) => matchesGlob(args.pattern, f.rel)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
     if (matched.length === 0) {
@@ -915,8 +1118,8 @@ var globTool = {
 };
 
 // src/tools/fs/grep.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import path11 from "path";
 import { z as z4 } from "zod";
 var MAX_MATCHES = 250;
 var schema4 = z4.object({
@@ -937,12 +1140,12 @@ var grepTool = {
     } catch (err) {
       return { content: `Invalid regular expression: ${err.message}`, isError: true };
     }
-    const root = path8.resolve(ctx.cwd, args.path ?? ".");
+    const root = path11.resolve(ctx.cwd, args.path ?? ".");
     let files;
     try {
-      const st = await stat2(root);
+      const st = await stat3(root);
       if (st.isFile()) {
-        files = [{ abs: root, rel: path8.basename(root), mtimeMs: st.mtimeMs }];
+        files = [{ abs: root, rel: path11.basename(root), mtimeMs: st.mtimeMs }];
       } else {
         files = await walkFiles(root);
       }
@@ -958,7 +1161,7 @@ var grepTool = {
     outer: for (const file of files) {
       let buf;
       try {
-        buf = await readFile2(file.abs);
+        buf = await readFile4(file.abs);
       } catch {
         continue;
       }
@@ -988,8 +1191,8 @@ var grepTool = {
 };
 
 // src/tools/fs/read.ts
-import { readFile as readFile3, stat as stat3 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile5, stat as stat4 } from "fs/promises";
+import path12 from "path";
 import { z as z5 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var MAX_CHARS = 100 * 1024;
@@ -1004,18 +1207,18 @@ var readFileTool = {
   permission: "read",
   parameters: schema5,
   async execute(args, ctx) {
-    const filePath = path9.resolve(ctx.cwd, args.path);
+    const filePath = path12.resolve(ctx.cwd, args.path);
     if (isSensitivePath2(filePath)) {
       return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
     }
-    const st = await stat3(filePath).catch(() => null);
+    const st = await stat4(filePath).catch(() => null);
     if (!st) {
       return { content: `File not found: ${args.path}`, isError: true };
     }
     if (st.isDirectory()) {
       return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
     }
-    const raw = await readFile3(filePath, "utf8");
+    const raw = await readFile5(filePath, "utf8");
     const lines = raw.split("\n");
     const start = args.offset ?? 1;
     const limit = args.limit ?? DEFAULT_LIMIT;
@@ -1049,8 +1252,8 @@ var readFileTool = {
 };
 
 // src/tools/fs/write.ts
-import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import path13 from "path";
 import { z as z6 } from "zod";
 var schema6 = z6.object({
   path: z6.string().describe("File path, absolute or relative to the working directory"),
@@ -1062,20 +1265,22 @@ var writeFileTool = {
   permission: "write",
   parameters: schema6,
   async execute(args, ctx) {
-    const filePath = path10.resolve(ctx.cwd, args.path);
+    const filePath = path13.resolve(ctx.cwd, args.path);
+    const snapshot = await captureSnapshot(filePath, "write_file");
     try {
-      await mkdir(path10.dirname(filePath), { recursive: true });
-      await writeFile2(filePath, args.content, "utf8");
+      await mkdir2(path13.dirname(filePath), { recursive: true });
+      await writeFile3(filePath, args.content, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
     }
+    pushSnapshot(snapshot);
     return { content: `Wrote ${Buffer.byteLength(args.content, "utf8")} bytes to ${args.path}` };
   }
 };
 
 // src/tools/todo.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import path11 from "path";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import path14 from "path";
 import { z as z7 } from "zod";
 var todoItemSchema = z7.object({
   id: z7.number().int(),
@@ -1087,7 +1292,7 @@ var writeSchema = z7.object({
 });
 var readSchema = z7.object({});
 function fileFor(cwd) {
-  return path11.join(cwd, ".star", "todos.json");
+  return path14.join(cwd, ".star", "todos.json");
 }
 var TodoStore = class {
   items = /* @__PURE__ */ new Map();
@@ -1103,7 +1308,7 @@ var TodoStore = class {
   async load(cwd) {
     let raw;
     try {
-      raw = await readFile4(fileFor(cwd), "utf8");
+      raw = await readFile6(fileFor(cwd), "utf8");
     } catch {
       return;
     }
@@ -1116,8 +1321,8 @@ var TodoStore = class {
     }
   }
   async save(cwd) {
-    await mkdir2(path11.join(cwd, ".star"), { recursive: true });
-    await writeFile3(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
+    await mkdir3(path14.join(cwd, ".star"), { recursive: true });
+    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
 `);
   }
 };
@@ -1302,6 +1507,121 @@ var webFetchTool = {
   }
 };
 
+// src/tools/web/search.ts
+import { z as z9 } from "zod";
+var TIMEOUT_MS2 = 15e3;
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS_LIMIT = 10;
+var SEARCH_URL = "https://html.duckduckgo.com/html/?q=";
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+var schema8 = z9.object({
+  query: z9.string().min(1).describe("The search query"),
+  maxResults: z9.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+    `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
+  )
+});
+function stripTags(s) {
+  return decodeEntities(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function normalizeUrl(href) {
+  const decoded = decodeEntities(href);
+  const uddg = decoded.match(/[?&]uddg=([^&]+)/);
+  if (uddg?.[1]) {
+    try {
+      return decodeURIComponent(uddg[1]);
+    } catch {
+      return decoded;
+    }
+  }
+  if (decoded.startsWith("//")) {
+    return `https:${decoded}`;
+  }
+  return decoded;
+}
+function parseResults(html) {
+  const results = [];
+  const anchorRe = /<a\b[^>]*\bclass\s*=\s*"[^"]*\bresult__a\b[^"]*"[^>]*>[\s\S]*?<\/a>/gi;
+  const anchors = [...html.matchAll(anchorRe)];
+  for (const [i, anchor] of anchors.entries()) {
+    const full = anchor[0];
+    const hrefMatch = full.match(/href\s*=\s*"([^"]*)"/i);
+    if (!hrefMatch?.[1]) {
+      continue;
+    }
+    const url = normalizeUrl(hrefMatch[1]);
+    const title = stripTags(full.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>\s*$/i, ""));
+    const blockStart = (anchor.index ?? 0) + full.length;
+    const blockEnd = i + 1 < anchors.length ? anchors[i + 1]?.index ?? html.length : html.length;
+    const block = html.slice(blockStart, blockEnd);
+    const snippetMatch = block.match(
+      /<(?:a|div)\b[^>]*\bclass\s*=\s*"[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i
+    );
+    const snippet = snippetMatch?.[1] ? stripTags(snippetMatch[1]) : "";
+    if (title && url) {
+      results.push({ title, url, snippet });
+    }
+  }
+  return results;
+}
+var webSearchTool = {
+  name: "web_search",
+  description: "Search the web using DuckDuckGo and return a numbered list of results with title, URL and snippet. No API key required. Use web_fetch to read a result's full page.",
+  permission: "read",
+  parameters: schema8,
+  async execute(args, ctx) {
+    const maxResults = Math.min(args.maxResults ?? DEFAULT_MAX_RESULTS, MAX_RESULTS_LIMIT);
+    const url = `${SEARCH_URL}${encodeURIComponent(args.query)}`;
+    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS2);
+    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+    let res;
+    try {
+      res = await fetch(url, {
+        signal,
+        redirect: "follow",
+        headers: { "user-agent": USER_AGENT, accept: "text/html" }
+      });
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) {
+        return { content: "ERROR: request aborted", isError: true };
+      }
+      const name = err instanceof Error ? err.name : "";
+      if (timeoutSignal.aborted || name === "TimeoutError") {
+        return { content: `ERROR: search timed out after ${TIMEOUT_MS2 / 1e3}s`, isError: true };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: search request failed: ${message}`, isError: true };
+    }
+    if (!res.ok) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: HTTP ${res.status} ${res.statusText} from DuckDuckGo`,
+        isError: true
+      };
+    }
+    let html;
+    try {
+      html = await res.text();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to read search response: ${message}`, isError: true };
+    }
+    const results = parseResults(html).slice(0, maxResults);
+    if (results.length === 0) {
+      return {
+        content: `ERROR: no results found for "${args.query}" (the response may have been blocked or the page layout changed)`,
+        isError: true
+      };
+    }
+    const lines = results.map(
+      (r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`
+    );
+    return { content: lines.join("\n") };
+  }
+};
+
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -1314,6 +1634,7 @@ var ToolRegistry = class {
       grepTool,
       bashTool,
       webFetchTool,
+      webSearchTool,
       ...createTodoTools()
     ]) {
       this.register(tool);
@@ -1342,6 +1663,137 @@ function createDefaultRegistry() {
   return registry;
 }
 
+// src/cli/commands/actions.ts
+import fs3 from "fs/promises";
+import path15 from "path";
+var MIN_COMPACT_MESSAGES = 4;
+async function compactSession(opts) {
+  const { backend, sessionStore, config, model } = opts;
+  if (!(backend instanceof AgentLoop)) {
+    return { message: "Current backend does not support compaction.", compacted: false };
+  }
+  const messages = [...backend.getMessages()];
+  if (messages.length < MIN_COMPACT_MESSAGES) {
+    return {
+      message: `Nothing to compact: history has only ${messages.length} message(s).`,
+      compacted: false
+    };
+  }
+  const beforeTokens = estimateTokens(messages);
+  const compacted = compactMessages(messages, config.contextMaxTokens);
+  if (!compacted.compacted) {
+    return {
+      message: `Nothing to compact: ~${beforeTokens} estimated tokens, below the limit of ${config.contextMaxTokens}.`,
+      compacted: false
+    };
+  }
+  const next = await applyCompactionSummary(messages, compacted, config, model);
+  await backend.loadMessages(next);
+  await sessionStore?.replaceMessages(next);
+  const afterTokens = estimateTokens(next);
+  return {
+    message: `Compacted context: ${messages.length} -> ${next.length} messages (~${beforeTokens} -> ~${afterTokens} estimated tokens).`,
+    compacted: true,
+    messages: next
+  };
+}
+async function applyCompactionSummary(original, compacted, config, model) {
+  if (config.contextCompaction !== "summary" || !model) {
+    return compacted.messages;
+  }
+  const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
+  const dropped = original.slice(headCount, headCount + compacted.droppedCount);
+  try {
+    const summary = await summarizeMessages(dropped, model);
+    const messages = compacted.messages.slice();
+    messages[headCount] = {
+      role: "user",
+      content: `[earlier conversation summarized]
+${summary}`
+    };
+    return messages;
+  } catch {
+    return compacted.messages;
+  }
+}
+async function exportSession(opts) {
+  const { backend, sessionStore, cwd, arg } = opts;
+  if (!(backend instanceof AgentLoop)) {
+    return "Current backend does not support exporting sessions.";
+  }
+  const messages = [...backend.getMessages()];
+  if (messages.length === 0) {
+    return "Nothing to export: the session has no messages.";
+  }
+  const sessionId = sessionStore?.id ?? `unknown-${Date.now()}`;
+  const target = arg ? path15.resolve(cwd, arg) : path15.resolve(cwd, `star-session-${sessionId}.md`);
+  const existed = await fileExists(target);
+  await fs3.mkdir(path15.dirname(target), { recursive: true });
+  await fs3.writeFile(target, renderSessionMarkdown(sessionId, messages));
+  return existed ? `Exported ${messages.length} messages to ${target} (overwrote existing file).` : `Exported ${messages.length} messages to ${target}.`;
+}
+async function fileExists(target) {
+  try {
+    await fs3.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderSessionMarkdown(sessionId, messages, exportedAt = /* @__PURE__ */ new Date()) {
+  const lines = [
+    `# Star CLI Session ${sessionId}`,
+    "",
+    `_Exported at ${exportedAt.toISOString()}_`,
+    ""
+  ];
+  for (const message of messages) {
+    lines.push(`## ${roleHeading(message.role)}`, "");
+    lines.push(...renderContent(message), "");
+  }
+  return lines.join("\n");
+}
+function roleHeading(role) {
+  return role.charAt(0).toUpperCase() + role.slice(1);
+}
+function renderContent(message) {
+  const content = message.content;
+  if (typeof content === "string") return [content];
+  const lines = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      lines.push(part.text, "");
+    } else if (part.type === "tool-call") {
+      lines.push(
+        `**Tool call: ${part.toolName}**`,
+        "",
+        "```json",
+        JSON.stringify(part.args, null, 2),
+        "```",
+        ""
+      );
+    } else if (part.type === "tool-result") {
+      lines.push(
+        `**Tool result: ${part.toolName}**`,
+        "",
+        "```",
+        stringifyPart(part.result),
+        "```",
+        ""
+      );
+    } else if (part.type === "reasoning") {
+      lines.push(part.text, "");
+    } else {
+      lines.push(`[${part.type}]`, "");
+    }
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function stringifyPart(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+
 // src/cli/commands/builtin.ts
 function registerBuiltinCommands(registry) {
   registry.register({
@@ -1429,6 +1881,30 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(ctx.describeConfig());
     }
   });
+  registry.register({
+    name: "compact",
+    description: "Compact the conversation history to free up context",
+    usage: "/compact",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.compactContext());
+    }
+  });
+  registry.register({
+    name: "export",
+    description: "Export the current session to a Markdown file",
+    usage: "/export [path]",
+    async run(args, ctx) {
+      ctx.addSystemMessage(await ctx.exportSession(args));
+    }
+  });
+  registry.register({
+    name: "undo",
+    description: "Revert the last file change made by write_file or edit_file",
+    usage: "/undo",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.undo());
+    }
+  });
 }
 
 // src/cli/commands/registry.ts
@@ -1463,16 +1939,46 @@ function parseSlashCommand(input) {
 // src/cli/components/InputBox.tsx
 import { Box, Text, useInput } from "ink";
 import { useRef, useState } from "react";
+
+// src/cli/commands/suggest.ts
+var MAX_SUGGESTIONS = 5;
+function filterCommands(input, commands) {
+  if (!input.startsWith("/")) return [];
+  if (/\s/.test(input)) return [];
+  const prefix = input.slice(1).toLowerCase();
+  return commands.filter((cmd) => cmd.name.toLowerCase().startsWith(prefix)).sort((a, b) => a.name.localeCompare(b.name)).slice(0, MAX_SUGGESTIONS);
+}
+
+// src/cli/components/InputBox.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
-function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
+function InputBox({
+  isStreaming,
+  disabled,
+  commands,
+  onSubmit,
+  onInterrupt,
+  onExit
+}) {
   const [value, setValue] = useState("");
   const [cursor, setCursor] = useState(0);
   const [history, setHistory] = useState([]);
+  const [highlight, setHighlight] = useState(0);
+  const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
   const historyIndexRef = useRef(null);
   const draftRef = useRef("");
   const edit = (next, nextCursor) => {
     setValue(next);
     setCursor(Math.max(0, Math.min(nextCursor, next.length)));
+    setHighlight(0);
+    setSuggestionsDismissed(false);
+  };
+  const suggestions = isStreaming || disabled || suggestionsDismissed || !commands ? [] : filterCommands(value, commands);
+  const activeIndex = suggestions.length === 0 ? 0 : Math.min(highlight, suggestions.length - 1);
+  const completeHighlighted = () => {
+    const cmd = suggestions[activeIndex];
+    if (!cmd) return;
+    const text = `/${cmd.name} `;
+    edit(text, text.length);
   };
   useInput((input, key) => {
     if (key.ctrl && input === "c") {
@@ -1489,6 +1995,10 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       return;
     }
     if (isStreaming || disabled) return;
+    if (key.escape) {
+      if (suggestions.length > 0) setSuggestionsDismissed(true);
+      return;
+    }
     if (key.return) {
       const text = value.trim();
       if (text.length > 0) {
@@ -1500,7 +2010,16 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       draftRef.current = "";
       return;
     }
-    if (key.upArrow) {
+    if (key.tab) {
+      if (suggestions.length > 0) {
+        completeHighlighted();
+        return;
+      }
+    } else if (key.upArrow) {
+      if (suggestions.length > 0) {
+        setHighlight((prev) => (prev - 1 + suggestions.length) % suggestions.length);
+        return;
+      }
       if (history.length === 0) return;
       if (historyIndexRef.current === null) {
         draftRef.current = value;
@@ -1511,8 +2030,11 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
       const entry = history[historyIndexRef.current] ?? "";
       edit(entry, entry.length);
       return;
-    }
-    if (key.downArrow) {
+    } else if (key.downArrow) {
+      if (suggestions.length > 0) {
+        setHighlight((prev) => (prev + 1) % suggestions.length);
+        return;
+      }
       if (historyIndexRef.current === null) return;
       if (historyIndexRef.current < history.length - 1) {
         historyIndexRef.current += 1;
@@ -1523,13 +2045,15 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
         edit(draftRef.current, draftRef.current.length);
       }
       return;
-    }
-    if (key.leftArrow) {
+    } else if (key.leftArrow) {
       setCursor((prev) => Math.max(0, prev - 1));
       return;
-    }
-    if (key.rightArrow) {
-      setCursor((prev) => Math.min(value.length, prev + 1));
+    } else if (key.rightArrow) {
+      if (suggestions.length > 0 && cursor === value.length) {
+        completeHighlighted();
+      } else {
+        setCursor((prev) => Math.min(value.length, prev + 1));
+      }
       return;
     }
     if (key.ctrl && input === "a") {
@@ -1567,11 +2091,19 @@ function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
   const before = value.slice(0, cursor);
   const at = value[cursor] ?? " ";
   const after = value.slice(cursor + 1);
-  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
-    /* @__PURE__ */ jsx(Text, { color: "cyan", children: "> " }),
-    /* @__PURE__ */ jsx(Text, { children: before }),
-    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
-    /* @__PURE__ */ jsx(Text, { children: after })
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "> " }),
+      /* @__PURE__ */ jsx(Text, { children: before }),
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+      /* @__PURE__ */ jsx(Text, { children: after })
+    ] }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 2, children: suggestions.map(
+      (cmd, index) => index === activeIndex ? /* @__PURE__ */ jsx(Text, { bold: true, inverse: true, children: `/${cmd.name} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: `/${cmd.name}` }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` - ${cmd.description}` })
+      ] }, cmd.name)
+    ) })
   ] });
 }
 
@@ -1589,7 +2121,8 @@ function MessageList({ messages }) {
     const style = roleStyles[message.role];
     return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
       /* @__PURE__ */ jsx2(Text2, { bold: true, color: style.color, children: style.label }),
-      /* @__PURE__ */ jsx2(Text2, { color: style.color, children: message.text })
+      /* @__PURE__ */ jsx2(Text2, { color: style.color, children: message.text }),
+      message.note && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: message.note })
     ] }, message.id);
   } });
 }
@@ -1663,7 +2196,7 @@ function PermissionPrompt({ request, onDecision }) {
       ")"
     ] }),
     /* @__PURE__ */ jsx3(Text3, { children: summarizeArgs(request.args) }),
-    /* @__PURE__ */ jsx3(Text3, { children: "[y] allow [n] deny [a] always" })
+    /* @__PURE__ */ jsx3(Text3, { children: "[y] allow [n] deny [a] always (saved to config)" })
   ] });
 }
 
@@ -1763,8 +2296,8 @@ function Repl({
   const alwaysAllowedRef = useRef2(/* @__PURE__ */ new Set());
   const modelNameRef = useRef2(model);
   const usageRef = useRef2(initialUsage ? { ...initialUsage } : emptyUsage());
-  const pushMessage = useCallback((role, text) => {
-    setMessages((prev) => [...prev, { id: nextIdRef.current++, role, text }]);
+  const pushMessage = useCallback((role, text, note) => {
+    setMessages((prev) => [...prev, { id: nextIdRef.current++, role, text, note }]);
   }, []);
   const setPendingPermission = useCallback((p) => {
     pendingRef.current = p;
@@ -1773,7 +2306,7 @@ function Repl({
   const attachConfirmHandler = useCallback(
     (target) => {
       target.confirmHandler = (req) => {
-        if (alwaysAllowedRef.current.has(req.toolName)) {
+        if (isAllowedByRules([...alwaysAllowedRef.current], req)) {
           return Promise.resolve(true);
         }
         return new Promise((resolve) => {
@@ -1807,12 +2340,21 @@ function Repl({
       const p = pendingRef.current;
       if (!p) return;
       if (decision === "always") {
-        alwaysAllowedRef.current.add(p.request.toolName);
+        const rule = buildAllowRule(p.request);
+        alwaysAllowedRef.current.add(rule);
+        void addAllowRule(rule).then((added) => {
+          pushMessage(
+            "system",
+            added ? `Always allow ${rule} \u2014 saved to config` : `Always allow ${rule} (already in config)`
+          );
+        }).catch(() => {
+          pushMessage("system", `Always allow ${rule} for this session (failed to save)`);
+        });
       }
       setPendingPermission(null);
       p.resolve(decision !== "no");
     },
-    [setPendingPermission]
+    [setPendingPermission, pushMessage]
   );
   const switchModel = useCallback(
     async (name) => {
@@ -1887,22 +2429,54 @@ ${lines.join("\n")}`;
         return formatTodos(store.list());
       },
       showUsage: () => formatUsage(usageRef.current),
+      compactContext: async () => {
+        let summaryModel = null;
+        try {
+          summaryModel = createModel(config, modelNameRef.current);
+        } catch {
+          summaryModel = null;
+        }
+        const result = await compactSession({
+          backend: backendRef.current,
+          sessionStore,
+          config,
+          model: summaryModel
+        });
+        if (result.compacted && result.messages) {
+          const display = buildDisplayMessages(result.messages);
+          nextIdRef.current = display.length;
+          setMessages(display);
+          setEpoch((e) => e + 1);
+        }
+        return result.message;
+      },
+      exportSession: (arg) => exportSession({ backend: backendRef.current, sessionStore, cwd, arg }),
+      undo: () => undoLastSnapshot(),
       describeConfig: () => [
         `defaultModel: ${config.defaultModel || "(none)"}`,
         `permissionMode: ${config.permissionMode}`,
         `providers (${config.providers.length}): ${config.providers.map((p) => p.name).join(", ") || "(none)"}`,
         `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
         `maxSteps: ${config.maxSteps}`,
-        `contextMaxTokens: ${config.contextMaxTokens}`
+        `contextMaxTokens: ${config.contextMaxTokens}`,
+        `permissions.allow (${config.permissions.allow.length}): ${config.permissions.allow.join(", ") || "(none)"}`
       ].join("\n")
     };
     const reg = new CommandRegistry();
     registerBuiltinCommands(reg);
     return Object.assign(reg, { ctx });
-  }, [pushMessage, exit, config, cwd, switchModel, resume]);
+  }, [pushMessage, exit, config, cwd, switchModel, resume, sessionStore]);
   const runStream = useCallback(
     async (input) => {
-      pushMessage("user", input);
+      const resolved = await resolveMentions(input, cwd);
+      pushMessage(
+        "user",
+        input,
+        resolved.attached.length > 0 ? `attached: ${resolved.attached.join(", ")}` : void 0
+      );
+      for (const skip of resolved.skipped) {
+        pushMessage("system", `Skipped @${skip.path}: ${skip.reason}`);
+      }
       const controller = new AbortController();
       abortRef.current = controller;
       streamedRef.current = "";
@@ -1912,7 +2486,9 @@ ${lines.join("\n")}`;
         setStreamingText(streamedRef.current);
       }, FLUSH_INTERVAL_MS);
       try {
-        for await (const event of backendRef.current.stream(input, controller.signal)) {
+        for await (const event of backendRef.current.stream(resolved.input, controller.signal, {
+          persistAs: input
+        })) {
           if (event.type === "text-delta") {
             streamedRef.current += event.text;
           } else if (event.type === "tool-call") {
@@ -1976,7 +2552,7 @@ ${lines.join("\n")}`;
         }
       }
     },
-    [pushMessage, setPendingPermission, sessionStore]
+    [pushMessage, setPendingPermission, sessionStore, cwd]
   );
   const handleSubmit = useCallback(
     (text) => {
@@ -1995,10 +2571,14 @@ ${lines.join("\n")}`;
     },
     [registry, pushMessage, runStream]
   );
+  const commandHints = useMemo(
+    () => registry.list().map((cmd) => ({ name: cmd.name, description: cmd.description })),
+    [registry]
+  );
   const cards = [...toolCardsRef.current.values()];
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx6(MessageList, { messages }, epoch),
-    cards.length > 0 && /* @__PURE__ */ jsx6(Box7, { flexDirection: "column", children: cards.map((card) => /* @__PURE__ */ jsx6(ToolCallCard, { card }, card.id)) }, cardsVersion),
+    /* @__PURE__ */ jsx6(MessageList, { messages }, `messages-${epoch}`),
+    cards.length > 0 && /* @__PURE__ */ jsx6(Box7, { flexDirection: "column", children: cards.map((card) => /* @__PURE__ */ jsx6(ToolCallCard, { card }, card.id)) }, `cards-${cardsVersion}`),
     streamingText !== null && /* @__PURE__ */ jsx6(StreamingMessage, { text: streamingText }),
     pending && /* @__PURE__ */ jsx6(PermissionPrompt, { request: pending.request, onDecision: handleDecision }),
     /* @__PURE__ */ jsx6(
@@ -2006,6 +2586,7 @@ ${lines.join("\n")}`;
       {
         isStreaming,
         disabled: pending !== null,
+        commands: commandHints,
         onSubmit: handleSubmit,
         onInterrupt: interrupt,
         onExit: exit
@@ -2018,7 +2599,7 @@ ${lines.join("\n")}`;
         permissionMode,
         tokens: usageRef.current.totalTokens
       },
-      usageVersion
+      `status-${usageVersion}`
     )
   ] });
 }
@@ -2041,33 +2622,37 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs2 from "fs";
-import { parse } from "smol-toml";
+import fs4 from "fs";
+import { parse as parse2 } from "smol-toml";
 
 // src/config/schema.ts
-import { z as z9 } from "zod";
-var ProviderConfigSchema = z9.object({
-  name: z9.string(),
-  protocol: z9.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z9.string(),
-  apiKeyEnv: z9.string().optional(),
-  apiKey: z9.string().optional(),
-  headers: z9.record(z9.string()).optional()
+import { z as z10 } from "zod";
+var ProviderConfigSchema = z10.object({
+  name: z10.string(),
+  protocol: z10.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z10.string(),
+  apiKeyEnv: z10.string().optional(),
+  apiKey: z10.string().optional(),
+  headers: z10.record(z10.string()).optional()
 });
-var ModelConfigSchema = z9.object({
-  name: z9.string(),
-  provider: z9.string(),
-  model: z9.string(),
-  maxTokens: z9.number().int().positive().optional()
+var ModelConfigSchema = z10.object({
+  name: z10.string(),
+  provider: z10.string(),
+  model: z10.string(),
+  maxTokens: z10.number().int().positive().optional()
 });
-var ConfigSchema = z9.object({
-  defaultModel: z9.string().default(""),
-  permissionMode: z9.enum(["auto", "ask", "readonly"]).default("ask"),
-  providers: z9.array(ProviderConfigSchema).default([]),
-  models: z9.array(ModelConfigSchema).default([]),
-  maxSteps: z9.number().int().positive().default(50),
-  contextMaxTokens: z9.number().int().positive().default(1e5),
-  contextCompaction: z9.enum(["summary", "truncate"]).default("summary")
+var PermissionsConfigSchema = z10.object({
+  allow: z10.array(z10.string()).default([])
+});
+var ConfigSchema = z10.object({
+  defaultModel: z10.string().default(""),
+  permissionMode: z10.enum(["auto", "ask", "readonly"]).default("ask"),
+  providers: z10.array(ProviderConfigSchema).default([]),
+  models: z10.array(ModelConfigSchema).default([]),
+  maxSteps: z10.number().int().positive().default(50),
+  contextMaxTokens: z10.number().int().positive().default(1e5),
+  contextCompaction: z10.enum(["summary", "truncate"]).default("summary"),
+  permissions: PermissionsConfigSchema.default({ allow: [] })
 });
 
 // src/config/loader.ts
@@ -2075,7 +2660,7 @@ var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
   let raw;
   try {
-    raw = parse(content);
+    raw = parse2(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to parse TOML in ${filePath}: ${message}`);
@@ -2097,8 +2682,8 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs2.existsSync(filePath)) return {};
-  const content = fs2.readFileSync(filePath, "utf8");
+  if (!fs4.existsSync(filePath)) return {};
+  const content = fs4.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {
@@ -2125,15 +2710,26 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     sessionStore
   });
 }
-async function printMode(loop, prompt) {
+async function printMode(loop, prompt, cwd) {
   const controller = new AbortController();
   process.on("SIGINT", () => controller.abort());
+  const resolved = await resolveMentions(prompt, cwd);
+  if (resolved.attached.length > 0) {
+    process.stderr.write(`[attached] ${resolved.attached.join(", ")}
+`);
+  }
+  for (const skip of resolved.skipped) {
+    process.stderr.write(`[skipped] @${skip.path}: ${skip.reason}
+`);
+  }
   let requests = 0;
   let promptTokens = 0;
   let completionTokens = 0;
   let totalTokens = 0;
   let exitCode = 0;
-  for await (const event of loop.stream(prompt, controller.signal)) {
+  for await (const event of loop.stream(resolved.input, controller.signal, {
+    persistAs: prompt
+  })) {
     switch (event.type) {
       case "text-delta":
         process.stdout.write(event.text);
@@ -2215,7 +2811,7 @@ program.name("star").description("Star CLI \u2014 an AI agent command-line inter
     await loop.loadMessages(resumed.messages);
   }
   if (opts.print) {
-    process.exitCode = await printMode(loop, opts.print);
+    process.exitCode = await printMode(loop, opts.print, cwd);
     return;
   }
   renderRepl(loop, {