@cryer/star-cli 0.2.0 → 0.2.2

package/dist/{chunk-RLQXGX3N.js → chunk-GN236FD4.js}

@@ -10,23 +10,31 @@ import { generateText } from "ai";
 var CHARS_PER_TOKEN = 4;
 var MESSAGE_OVERHEAD = 4;
 var IMAGE_PART_TOKENS = 1024;
+var CJK_RE = /[\u3000-\u30FF\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF\uFF00-\uFFEF]/;
+function textWeight(text) {
+  let cjk = 0;
+  for (const ch of text) {
+    if (CJK_RE.test(ch)) cjk++;
+  }
+  return text.length + cjk * (CHARS_PER_TOKEN - 1);
+}
 function contentCharLength(message) {
   if (message.role === "tool") {
     let chars2 = 0;
     for (const part of message.content) {
-      chars2 += JSON.stringify(part.result ?? null).length;
+      chars2 += textWeight(JSON.stringify(part.result ?? null));
     }
     return chars2;
   }
   if (typeof message.content === "string") {
-    return message.content.length;
+    return textWeight(message.content);
   }
   let chars = 0;
   for (const part of message.content) {
     if (part.type === "text" || part.type === "reasoning") {
-      chars += part.text.length;
+      chars += textWeight(part.text);
     } else if (part.type === "tool-call") {
-      chars += part.toolName.length + JSON.stringify(part.args ?? null).length;
+      chars += textWeight(part.toolName) + textWeight(JSON.stringify(part.args ?? null));
     }
   }
   return chars;
@@ -425,6 +433,12 @@ function matchAllowRule(rule, req) {
   return target !== void 0 && globMatch(rule.pattern, target);
 }
 function isAllowedByRules(rules, req) {
+  return matchesAnyRule(rules, req);
+}
+function isDeniedByRules(rules, req) {
+  return matchesAnyRule(rules, req);
+}
+function matchesAnyRule(rules, req) {
   return rules.some((raw) => {
     const rule = parseAllowRule(raw);
     return rule !== null && matchAllowRule(rule, req);
@@ -476,7 +490,7 @@ function isSensitivePath(p) {
   }
   return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
 }
-function checkPermission(mode, req, ctx, allowRules = []) {
+function checkPermission(mode, req, ctx, allowRules = [], denyRules = []) {
   if (mode === "yolo") {
     return "allow";
   }
@@ -496,6 +510,9 @@ function checkPermission(mode, req, ctx, allowRules = []) {
       return "deny";
     }
   }
+  if (isDeniedByRules(denyRules, req)) {
+    return "deny";
+  }
   if (mode === "auto") {
     return "allow";
   }
@@ -720,14 +737,153 @@ ${body}`;
   return block;
 }
 
+// src/agent/skills.ts
+import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
+import path5 from "path";
+import { z } from "zod";
+
+// 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 userMemoryPath() {
+  return path4.join(starHome(), "MEMORY.md");
+}
+function projectConfigPath(cwd) {
+  return path4.join(cwd, ".star", "config.toml");
+}
+
+// src/agent/skills.ts
+var SKILL_FILE = "SKILL.md";
+var SKILL_MAX_CHARS = 32 * 1024;
+var NAME_PATTERN = /^[a-z0-9-]+$/;
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return null;
+  const meta = {};
+  for (const line of (match[1] ?? "").split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (kv?.[1]) meta[kv[1]] = (kv[2] ?? "").trim();
+  }
+  return { meta, body: raw.slice(match[0].length).trim() };
+}
+var cache2 = /* @__PURE__ */ new Map();
+function parseSkillFile(filePath, dirName, scope) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync2(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache2.get(filePath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.skill;
+  let skill = null;
+  try {
+    const parsed = parseFrontmatter(readFileSync2(filePath, "utf8"));
+    const name = parsed?.meta.name || dirName;
+    const description = parsed?.meta.description;
+    if (parsed && NAME_PATTERN.test(name) && description) {
+      skill = { name, description, filePath, dir: path5.dirname(filePath), scope };
+    }
+  } catch {
+    skill = null;
+  }
+  cache2.set(filePath, { mtimeMs, skill });
+  return skill;
+}
+function scanDir(base, scope, into) {
+  let entries;
+  try {
+    entries = readdirSync(base);
+  } catch {
+    return;
+  }
+  for (const entry of entries.sort()) {
+    if (!NAME_PATTERN.test(entry)) continue;
+    const parsed = parseSkillFile(path5.join(base, entry, SKILL_FILE), entry, scope);
+    if (parsed) into.set(parsed.name, parsed);
+  }
+}
+function discoverSkills(cwd, home = starHome()) {
+  const byName = /* @__PURE__ */ new Map();
+  scanDir(path5.join(home, "skills"), "user", byName);
+  scanDir(path5.join(cwd, ".star", "skills"), "project", byName);
+  return [...byName.values()];
+}
+function formatSkillsBlock(skills) {
+  const lines = skills.map((s) => `- ${s.name}: ${s.description}`);
+  return [
+    "# Available skills",
+    "When the user's request matches one of these skills, call the skill tool with its name to load the full instructions before proceeding:",
+    ...lines
+  ].join("\n");
+}
+function loadSkillBody(skill) {
+  let parsed = null;
+  try {
+    parsed = parseFrontmatter(readFileSync2(skill.filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed?.body) return null;
+  if (parsed.body.length > SKILL_MAX_CHARS) {
+    return `${parsed.body.slice(0, SKILL_MAX_CHARS)}
+
+[skill truncated to ${SKILL_MAX_CHARS} characters]`;
+  }
+  return parsed.body;
+}
+function createSkillTool(deps) {
+  return {
+    name: "skill",
+    description: "Load the full instructions of a skill by name. Available skills are listed in the system prompt when present; call this before starting work that matches one of them.",
+    permission: "read",
+    parameters: z.object({
+      name: z.string().describe("Name of the skill to load, as listed in the system prompt.")
+    }),
+    async execute(args) {
+      const skills = discoverSkills(deps.cwd, deps.home);
+      const skill = skills.find((s) => s.name === args.name);
+      if (!skill) {
+        const available = skills.map((s) => s.name).join(", ") || "none";
+        return {
+          content: `Unknown skill: "${args.name}". Available skills: ${available}`,
+          isError: true
+        };
+      }
+      const body = loadSkillBody(skill);
+      if (!body) {
+        return { content: `Skill "${skill.name}" is empty or unreadable.`, isError: true };
+      }
+      return {
+        content: [
+          `# Skill: ${skill.name}`,
+          "",
+          body,
+          "",
+          `Base directory for relative file references in this skill: ${skill.dir}`
+        ].join("\n")
+      };
+    }
+  };
+}
+
 // src/agent/subagent.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/tools/bash.ts
 import { spawn as spawn3 } from "child_process";
 import { existsSync } from "fs";
-import path4 from "path";
-import { z } from "zod";
+import path6 from "path";
+import { z as z2 } from "zod";
 
 // src/tasks/manager.ts
 import { spawn as spawn2 } from "child_process";
@@ -846,11 +1002,11 @@ 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(path6.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path4.join(dir, exe);
+    const full = path6.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -868,7 +1024,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path4.join(path4.dirname(path4.dirname(gitExe)), "bin", "bash.exe");
+    const sibling = path6.join(path6.dirname(path6.dirname(gitExe)), "bin", "bash.exe");
     if (existsSync(sibling)) {
       return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
     }
@@ -885,11 +1041,11 @@ function resolveShell() {
   const comspec = process.env.ComSpec ?? "cmd.exe";
   return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
 }
-var schema = z.object({
-  command: z.string().describe("Shell command to execute"),
-  timeout: z.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
-  description: z.string().optional().describe("Short description of what the command does"),
-  run_in_background: z.boolean().optional().describe(
+var schema = z2.object({
+  command: z2.string().describe("Shell command to execute"),
+  timeout: z2.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
+  description: z2.string().optional().describe("Short description of what the command does"),
+  run_in_background: z2.boolean().optional().describe(
     "Run the command in the background and return a task id immediately (default false). Use task_output/task_kill to inspect or stop it."
   )
 });
@@ -992,13 +1148,13 @@ Command timed out after ${timeoutSeconds}s`,
 
 // src/tools/fs/edit.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
-import { z as z2 } from "zod";
-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"),
-  new_string: z2.string().describe("Replacement text"),
-  replace_all: z2.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
+import path7 from "path";
+import { z as z3 } from "zod";
+var schema2 = z3.object({
+  path: z3.string().describe("File path, absolute or relative to the working directory"),
+  old_string: z3.string().min(1).describe("Exact text to replace"),
+  new_string: z3.string().describe("Replacement text"),
+  replace_all: z3.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
 });
 var editFileTool = {
   name: "edit_file",
@@ -1006,7 +1162,7 @@ var editFileTool = {
   permission: "write",
   parameters: schema2,
   async execute(args, ctx) {
-    const filePath = path5.resolve(ctx.cwd, args.path);
+    const filePath = path7.resolve(ctx.cwd, args.path);
     let content;
     try {
       content = await readFile2(filePath, "utf8");
@@ -1049,14 +1205,15 @@ var editFileTool = {
 };
 
 // src/tools/fs/glob.ts
-import path7 from "path";
-import { z as z3 } from "zod";
+import path9 from "path";
+import { z as z4 } from "zod";
 
 // src/tools/fs/util.ts
+import { readFileSync as readFileSync3, statSync as statSync3 } from "fs";
 import { readdir, stat } from "fs/promises";
-import path6 from "path";
+import path8 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
-async function walkFiles(root, skipDirs = SKIP_DIRS) {
+async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
   const out = [];
   async function walk(dir, relBase) {
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
@@ -1064,13 +1221,17 @@ async function walkFiles(root, skipDirs = SKIP_DIRS) {
       return;
     }
     for (const entry of entries) {
-      const abs = path6.join(dir, entry.name);
+      const abs = path8.join(dir, entry.name);
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
-          await walk(abs, rel);
+        if (skipDirs.has(entry.name) || options.ignore?.(abs, true)) {
+          continue;
         }
+        await walk(abs, rel);
       } else if (entry.isFile()) {
+        if (options.ignore?.(abs, false)) {
+          continue;
+        }
         try {
           const st = await stat(abs);
           out.push({ abs, rel, mtimeMs: st.mtimeMs });
@@ -1119,8 +1280,71 @@ function matchesGlob(pattern, relPath) {
   }
   return globToRegExp(normalized).test(relPath);
 }
+var IGNORE_FILE = ".starignore";
+var ignoreCache = /* @__PURE__ */ new Map();
+function parseIgnorePatterns(body) {
+  const out = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line.endsWith("/")) {
+      const pattern = line.slice(0, -1);
+      if (pattern) {
+        out.push({ pattern, dirOnly: true });
+      }
+    } else {
+      out.push({ pattern: line, dirOnly: false });
+    }
+  }
+  return out;
+}
+function loadIgnorePatterns(dir) {
+  const file = path8.join(dir, IGNORE_FILE);
+  let mtimeMs;
+  try {
+    mtimeMs = statSync3(file).mtimeMs;
+  } catch {
+    return [];
+  }
+  const hit = ignoreCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) {
+    return hit.patterns;
+  }
+  let patterns = [];
+  try {
+    patterns = parseIgnorePatterns(readFileSync3(file, "utf8"));
+  } catch {
+    patterns = [];
+  }
+  ignoreCache.set(file, { mtimeMs, patterns });
+  return patterns;
+}
+function createIgnorePredicate(cwd) {
+  const patterns = loadIgnorePatterns(cwd);
+  if (patterns.length === 0) {
+    return void 0;
+  }
+  const root = path8.resolve(cwd);
+  return (absPath, isDir) => {
+    const rel = path8.relative(root, absPath).split(path8.sep).join("/");
+    if (!rel || rel.startsWith("..")) {
+      return false;
+    }
+    for (const { pattern, dirOnly } of patterns) {
+      if (dirOnly && !isDir) {
+        continue;
+      }
+      if (matchesGlob(pattern, rel)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
 function isSensitivePath2(filePath) {
-  const base = path6.basename(filePath);
+  const base = path8.basename(filePath);
   if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
     return false;
   }
@@ -1135,11 +1359,11 @@ function isSensitivePath2(filePath) {
 
 // src/tools/fs/glob.ts
 var MAX_RESULTS = 100;
-var schema3 = z3.object({
-  pattern: z3.string().describe(
+var schema3 = z4.object({
+  pattern: z4.string().describe(
     "Glob pattern, e.g. 'src/**/*.ts'. Supports **, * and ?. A bare pattern like '*.ts' matches basenames recursively."
   ),
-  path: z3.string().optional().describe("Directory to search, defaults to the working directory")
+  path: z4.string().optional().describe("Directory to search, defaults to the working directory")
 });
 var globTool = {
   name: "glob",
@@ -1147,8 +1371,8 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path7.resolve(ctx.cwd, args.path ?? ".");
-    const files = await walkFiles(root);
+    const root = path9.resolve(ctx.cwd, args.path ?? ".");
+    const files = await walkFiles(root, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
     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) {
       return { content: `No files matched pattern: ${args.pattern}` };
@@ -1159,14 +1383,14 @@ var globTool = {
 
 // src/tools/fs/grep.ts
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import path8 from "path";
-import { z as z4 } from "zod";
+import path10 from "path";
+import { z as z5 } from "zod";
 var MAX_MATCHES = 250;
-var schema4 = z4.object({
-  pattern: z4.string().describe("Regular expression to search for"),
-  path: z4.string().optional().describe("File or directory to search, defaults to the working directory"),
-  glob: z4.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
-  ignoreCase: z4.boolean().optional().describe("Case-insensitive matching")
+var schema4 = z5.object({
+  pattern: z5.string().describe("Regular expression to search for"),
+  path: z5.string().optional().describe("File or directory to search, defaults to the working directory"),
+  glob: z5.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
+  ignoreCase: z5.boolean().optional().describe("Case-insensitive matching")
 });
 var grepTool = {
   name: "grep",
@@ -1180,14 +1404,14 @@ var grepTool = {
     } catch (err) {
       return { content: `Invalid regular expression: ${err.message}`, isError: true };
     }
-    const root = path8.resolve(ctx.cwd, args.path ?? ".");
+    const root = path10.resolve(ctx.cwd, args.path ?? ".");
     let files;
     try {
       const st = await stat2(root);
       if (st.isFile()) {
-        files = [{ abs: root, rel: path8.basename(root), mtimeMs: st.mtimeMs }];
+        files = [{ abs: root, rel: path10.basename(root), mtimeMs: st.mtimeMs }];
       } else {
-        files = await walkFiles(root);
+        files = await walkFiles(root, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
       }
     } catch {
       return { content: `Path not found: ${args.path ?? "."}`, isError: true };
@@ -1232,14 +1456,14 @@ var grepTool = {
 
 // src/tools/fs/read.ts
 import { readFile as readFile4, stat as stat3 } from "fs/promises";
-import path9 from "path";
-import { z as z5 } from "zod";
+import path11 from "path";
+import { z as z6 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var MAX_CHARS = 100 * 1024;
-var schema5 = z5.object({
-  path: z5.string().describe("File path, absolute or relative to the working directory"),
-  offset: z5.number().int().positive().optional().describe("1-based line number to start reading from"),
-  limit: z5.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+var schema5 = z6.object({
+  path: z6.string().describe("File path, absolute or relative to the working directory"),
+  offset: z6.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z6.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
 });
 var readFileTool = {
   name: "read_file",
@@ -1247,7 +1471,7 @@ var readFileTool = {
   permission: "read",
   parameters: schema5,
   async execute(args, ctx) {
-    const filePath = path9.resolve(ctx.cwd, args.path);
+    const filePath = path11.resolve(ctx.cwd, args.path);
     if (isSensitivePath2(filePath)) {
       return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
     }
@@ -1293,11 +1517,11 @@ var readFileTool = {
 
 // src/tools/fs/write.ts
 import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import path10 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"),
-  content: z6.string().describe("Full content to write to the file")
+import path12 from "path";
+import { z as z7 } from "zod";
+var schema6 = z7.object({
+  path: z7.string().describe("File path, absolute or relative to the working directory"),
+  content: z7.string().describe("Full content to write to the file")
 });
 var writeFileTool = {
   name: "write_file",
@@ -1305,10 +1529,10 @@ var writeFileTool = {
   permission: "write",
   parameters: schema6,
   async execute(args, ctx) {
-    const filePath = path10.resolve(ctx.cwd, args.path);
+    const filePath = path12.resolve(ctx.cwd, args.path);
     const snapshot = await captureSnapshot(filePath, "write_file");
     try {
-      await mkdir2(path10.dirname(filePath), { recursive: true });
+      await mkdir2(path12.dirname(filePath), { recursive: true });
       await writeFile3(filePath, args.content, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
@@ -1319,7 +1543,7 @@ var writeFileTool = {
 };
 
 // src/tools/tasks.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/tasks/format.ts
 function formatDuration(startedAt, endedAt) {
@@ -1365,14 +1589,14 @@ function formatTaskFinished(task) {
 }
 
 // src/tools/tasks.ts
-var idSchema = z7.object({
-  id: z7.string().describe("Task id, e.g. task-1")
+var idSchema = z8.object({
+  id: z8.string().describe("Task id, e.g. task-1")
 });
 var taskListTool = {
   name: "task_list",
   description: "List background shell tasks with status, runtime, and exit code.",
   permission: "read",
-  parameters: z7.object({}),
+  parameters: z8.object({}),
   execute() {
     return Promise.resolve({ content: formatTaskList(defaultTaskManager.list()) });
   }
@@ -1415,19 +1639,19 @@ var taskKillTool = {
 
 // src/tools/todo.ts
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import path11 from "path";
-import { z as z8 } from "zod";
-var todoItemSchema = z8.object({
-  id: z8.number().int(),
-  title: z8.string(),
-  status: z8.enum(["pending", "in_progress", "done"])
+import path13 from "path";
+import { z as z9 } from "zod";
+var todoItemSchema = z9.object({
+  id: z9.number().int(),
+  title: z9.string(),
+  status: z9.enum(["pending", "in_progress", "done"])
 });
-var writeSchema = z8.object({
-  todos: z8.array(todoItemSchema).describe("The full todo list, replacing the current one")
+var writeSchema = z9.object({
+  todos: z9.array(todoItemSchema).describe("The full todo list, replacing the current one")
 });
-var readSchema = z8.object({});
+var readSchema = z9.object({});
 function fileFor(cwd) {
-  return path11.join(cwd, ".star", "todos.json");
+  return path13.join(cwd, ".star", "todos.json");
 }
 var TodoStore = class {
   items = /* @__PURE__ */ new Map();
@@ -1456,7 +1680,7 @@ var TodoStore = class {
     }
   }
   async save(cwd) {
-    await mkdir3(path11.join(cwd, ".star"), { recursive: true });
+    await mkdir3(path13.join(cwd, ".star"), { recursive: true });
     await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
 `);
   }
@@ -1509,13 +1733,13 @@ function createTodoTools(store = defaultStore) {
 }
 
 // src/tools/web/fetch.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var DEFAULT_MAX_CHARS = 2e4;
 var MAX_BYTES = 2 * 1024 * 1024;
 var TIMEOUT_MS = 3e4;
-var schema7 = z9.object({
-  url: z9.string().describe("The http(s) URL to fetch"),
-  maxChars: z9.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+var schema7 = z10.object({
+  url: z10.string().describe("The http(s) URL to fetch"),
+  maxChars: z10.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
 });
 function decodeEntities(s) {
   return s.replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&#x([0-9a-fA-F]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16))).replace(/&(quot|lt|gt|nbsp);/g, (m) => {
@@ -1643,15 +1867,15 @@ var webFetchTool = {
 };
 
 // src/tools/web/search.ts
-import { z as z10 } from "zod";
+import { z as z11 } 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 = z10.object({
-  query: z10.string().min(1).describe("The search query"),
-  maxResults: z10.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
+var schema8 = z11.object({
+  query: z11.string().min(1).describe("The search query"),
+  maxResults: z11.number().int().min(1).max(MAX_RESULTS_LIMIT).optional().describe(
     `Maximum number of results to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`
   )
 });
@@ -1810,12 +2034,12 @@ function createSubagentTool(deps) {
     name: "subagent",
     description: "Spawn a subagent with its own agent loop to handle a focused subtask (research, exploration, or an isolated change). The subagent has the same tools but cannot spawn further subagents. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation.",
     permission: "exec",
-    parameters: z11.object({
-      prompt: z11.string().describe("Complete, self-contained instructions for the subagent."),
-      description: z11.string().optional().describe("Short label for the subtask, shown in the result header.")
+    parameters: z12.object({
+      prompt: z12.string().describe("Complete, self-contained instructions for the subagent."),
+      description: z12.string().optional().describe("Short label for the subtask, shown in the result header.")
     }),
     async execute(args, ctx) {
-      const { AgentLoop: AgentLoop2 } = await import("./loop-XIILV7GY.js");
+      const { AgentLoop: AgentLoop2 } = await import("./loop-ADVWZA62.js");
       const child = new AgentLoop2({
         model: deps.model,
         registry: createDefaultRegistry(),
@@ -1872,6 +2096,64 @@ ${report || "(subagent produced no text output)"}` };
   };
 }
 
+// src/agent/user-memory.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import path14 from "path";
+import { z as z13 } from "zod";
+var USER_MEMORY_MAX_CHARS = 32 * 1024;
+var REMEMBER_TEXT_MAX_CHARS = 500;
+var cache3 = /* @__PURE__ */ new Map();
+function readUserMemory(home = starHome()) {
+  const file = path14.join(home, "MEMORY.md");
+  let mtimeMs;
+  try {
+    mtimeMs = statSync4(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache3.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.block;
+  let block = null;
+  try {
+    let body = readFileSync4(file, "utf8").trim();
+    if (body) {
+      if (body.length > USER_MEMORY_MAX_CHARS) {
+        body = `${body.slice(0, USER_MEMORY_MAX_CHARS)}
+
+[MEMORY.md truncated to ${USER_MEMORY_MAX_CHARS} characters]`;
+      }
+      block = [
+        "# User memory (MEMORY.md)",
+        "The following notes were saved by the user across sessions. Respect them unless they conflict with the current request.",
+        body
+      ].join("\n");
+    }
+  } catch {
+    block = null;
+  }
+  cache3.set(file, { mtimeMs, block });
+  return block;
+}
+function appendUserMemory(text, home = starHome()) {
+  mkdirSync(home, { recursive: true });
+  appendFileSync(path14.join(home, "MEMORY.md"), `- ${text}
+`, "utf8");
+}
+function createRememberTool(deps = {}) {
+  return {
+    name: "remember",
+    description: `Save a note to the user's long-term memory (${userMemoryPath()}), injected into every future session. ONLY use when the user explicitly asks to remember or save something. Never use autonomously.`,
+    permission: "write",
+    parameters: z13.object({
+      text: z13.string().max(REMEMBER_TEXT_MAX_CHARS).describe("The note to save, as a single concise sentence.")
+    }),
+    async execute(args) {
+      appendUserMemory(args.text, deps.home);
+      return { content: `Saved to user memory: ${args.text}` };
+    }
+  };
+}
+
 // src/agent/loop.ts
 var PLAN_MODE_PROMPT = "\n\nYou are currently in PLAN MODE. Research the task using only the read-only tools available to you, then present a concrete, step-by-step implementation plan as your final answer. You must not modify files, run shell commands, or otherwise change the system \u2014 write/exec tools are unavailable in this mode. Do not ask the user to run commands for you; note manual steps in the plan instead. The user will review your plan and approve it before any execution begins.";
 var AgentLoop = class {
@@ -1896,6 +2178,8 @@ var AgentLoop = class {
     if (opts.sessionStore) {
       this.bindSnapshotHooks(opts.sessionStore);
     }
+    opts.registry?.register(createSkillTool({ cwd: opts.cwd }));
+    opts.registry?.register(createRememberTool());
     const depth = opts.subagentDepth ?? 0;
     if (opts.registry && depth < MAX_SUBAGENT_DEPTH) {
       opts.registry.register(
@@ -2029,7 +2313,8 @@ var AgentLoop = class {
     const { config, registry, cwd } = this.opts;
     const aiTools = this.buildAiTools();
     for (let step = 0; step < config.maxSteps; step++) {
-      const compacted = compactMessages([...this.messages], config.contextMaxTokens);
+      const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
+      const compacted = compactMessages([...this.messages], maxTokens);
       if (compacted.compacted) {
         this.messages = await this.applyCompactionSummary(compacted);
       }
@@ -2139,8 +2424,11 @@ var AgentLoop = class {
   // /model switch) replaced the history with one that has none. Git context
   // (branch, dirty count, recent commits) is refreshed here too, so the model
   // always sees the current repo state; any git failure is silently skipped.
-  // Project memory (AGENTS.md in the cwd) is appended as a delimited block;
-  // readProjectMemory caches by mtime, so this stays cheap per turn.
+  // Project memory (AGENTS.md in the cwd) and user memory (~/.star-cli/
+  // MEMORY.md) are appended as delimited blocks; both cache by mtime, so this
+  // stays cheap per turn. The
+  // skills listing is refreshed here as well, so skills added mid-session
+  // show up in the next turn's system prompt.
   syncSystemMessage() {
     const base = this.opts.system;
     const plan = this.opts.config.permissionMode === "plan";
@@ -2149,6 +2437,10 @@ var AgentLoop = class {
     if (plan) parts.push(PLAN_MODE_PROMPT.trim());
     const memory = readProjectMemory(this.opts.cwd);
     if (memory) parts.push(memory);
+    const userMemory = readUserMemory();
+    if (userMemory) parts.push(userMemory);
+    const skills = discoverSkills(this.opts.cwd);
+    if (skills.length > 0) parts.push(formatSkillsBlock(skills));
     const git = getGitSummary(this.opts.cwd);
     if (git) parts.push(formatGitSummary(git));
     if (parts.length === 0) return;
@@ -2228,7 +2520,8 @@ ${summary}`
       config.permissionMode,
       { toolName: call.name, args: call.args, level: tool.permission },
       { cwd },
-      config.permissions.allow
+      config.permissions.allow,
+      config.permissions.deny
     );
     if (decision === "deny") {
       return { content: `Permission denied for tool "${call.name}".`, isError: true };
@@ -2297,10 +2590,17 @@ export {
   hydrateSnapshots,
   undoTurnSnapshots,
   rewindToSnapshot,
+  starHome,
+  globalConfigPath,
+  sessionsDir,
+  userMemoryPath,
+  projectConfigPath,
+  discoverSkills,
   defaultTaskManager,
   resolveShell,
   bashTool,
   SKIP_DIRS,
+  createIgnorePredicate,
   isSensitivePath2 as isSensitivePath,
   formatTaskList,
   formatTaskStarted,
@@ -2308,7 +2608,8 @@ export {
   TodoStore,
   formatTodos,
   createDefaultRegistry,
+  appendUserMemory,
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-RLQXGX3N.js.map
+//# sourceMappingURL=chunk-GN236FD4.js.map