@cryer/star-cli 0.2.0 → 0.2.1

package/README.md

@@ -73,7 +73,14 @@ apiKeyEnv = "OPENAI_API_KEY"
 name = "gpt"
 provider = "openai"
 model = "gpt-4o"
-# optional per-model pricing (USD per 1M tokens) — enables the $ estimate in /cost and /usage
+# optional per-model context window — overrides the top-level contextMaxTokens
+# for compaction and the ctx % in the status bar
+# contextMaxTokens = 272000
+# optional per-model pricing in USD per 1M tokens — enables the $ estimate in
+# /cost and /usage. promptPrice prices input tokens (system prompt, history,
+# @file contents, tool results — resent every turn, so the bulk of usage);
+# completionPrice prices output tokens (the model's replies and tool calls —
+# less volume, usually the pricier rate). BOTH fields are required together.
 promptPrice = 2.5
 completionPrice = 10
 
@@ -135,6 +142,7 @@ star --clear-sessions all     delete every stored session
 | `/rewind [n]` | list file-change checkpoints, or rewind to just before checkpoint `n`: restore every file changed since then and retract the matching conversation messages (asks for confirmation first) |
 | `/init [force]` | scan the project and generate an AGENTS.md (LLM-polished when a model is available) |
 | `/doctor` | environment self-check (Node, shell, config, API key status, sessions dir writability) |
+| `/skills` | list available skills (project scope overrides user scope) |
 | `/commit [instructions]` | analyze uncommitted changes and let the agent stage + commit them with a Conventional Commits message (git add/commit runs through the normal permission gate) |
 | `/diff` | show uncommitted changes client-side: `git status --short` plus a colored staged/unstaged diff (no model call; huge diffs are truncated at 2000 lines) |
 | `/copy [all]` | copy the last assistant reply to the clipboard (`all`: the whole conversation as plain text) |
@@ -146,7 +154,7 @@ Keys: `ESC` / `Ctrl+C` interrupts the current stream; on a permission prompt: `y
 
 While the model is working, a spinner (`- \ | /`) shows `star is thinking…`; reasoning models also stream a dimmed tail of their thinking (last ~200 chars), which collapses to a one-line summary once the answer starts.
 
-The status bar shows the working directory (full path on wide terminals), the git branch, the model, the permission mode, context usage as a percentage of `contextMaxTokens`, the session cost when the model has pricing configured, and total tokens.
+The status bar shows the working directory (full path on wide terminals), the git branch, the model, the permission mode, context usage as a percentage of the model's context window (its own `contextMaxTokens` when set, else the top-level one), the session cost when the model has pricing configured, and total tokens.
 
 ## !shell passthrough
 
@@ -217,6 +225,19 @@ Review the following code and list concrete issues: $ARGUMENTS
 
 The REPL also checks npm for a newer release on startup (async, non-blocking; disable with `STAR_NO_UPDATE_CHECK=1`).
 
+## Skills
+
+Skills are reusable instruction packs the agent loads on demand. Drop a `SKILL.md` into `.star/skills/<name>/` (project) or `~/.star-cli/skills/<name>/` (user); project skills override user skills of the same name. Each `SKILL.md` starts with frontmatter (`name` optional, defaults to the directory name; `description` required), followed by the instructions body:
+
+```markdown
+---
+description: Review code for common issues
+---
+Check error handling, naming, and test coverage. Report concrete findings with file:line references.
+```
+
+Available skills are listed in the system prompt (name + description only, so they cost almost no tokens until used). When a request matches one, the agent calls the read-level `skill` tool to load the full body — supporting files next to the `SKILL.md` (scripts, templates, examples) are resolved relative to the skill's directory. Skills added mid-session are picked up on the next turn; `/skills` lists what's currently visible. Bodies are capped at 32KB.
+
 ## @file mentions
 
 Prefix a path with `@` in any prompt to attach its content (REPL and print mode alike):
@@ -237,7 +258,7 @@ Missing, binary, oversized (>100KB for text, >5MB for images), or sensitive file
 
 ## Built-in tools
 
-`read_file`, `write_file`, `edit_file`, `glob`, `grep`, `bash`, `web_fetch`, `web_search` (DuckDuckGo, no API key needed), `todo_read`, `todo_write`, `task_list`, `task_output`, `task_kill`, `subagent` — each declares a permission level (`read` / `write` / `exec`) enforced by the permission gate. Hard safety rules (dangerous shell commands, paths outside the working directory, secret files like `.env` / private keys) are denied in `ask` / `auto` / `readonly` and cannot be overridden by allow-rules.
+`read_file`, `write_file`, `edit_file`, `glob`, `grep`, `bash`, `web_fetch`, `web_search` (DuckDuckGo, no API key needed), `todo_read`, `todo_write`, `task_list`, `task_output`, `task_kill`, `subagent`, `skill` — each declares a permission level (`read` / `write` / `exec`) enforced by the permission gate. Hard safety rules (dangerous shell commands, paths outside the working directory, secret files like `.env` / private keys) are denied in `ask` / `auto` / `readonly` and cannot be overridden by allow-rules.
 
 The `subagent` tool (`exec` level, so it is hidden in plan mode and denied in readonly) spawns a child agent loop with the same built-in tools to handle a focused, self-contained subtask — research, exploration, or an isolated change — and returns the child's final report as the tool result. Subagents run one level deep (a subagent cannot spawn further subagents), share the parent's permission mode and confirmation prompt, and their conversation is not persisted to the session.
 

package/dist/{chunk-RLQXGX3N.js → chunk-MJ2O7NWI.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;
@@ -720,14 +728,150 @@ ${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 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 +990,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 +1012,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 +1029,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 +1136,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 +1150,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,12 +1193,12 @@ 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 { 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) {
   const out = [];
@@ -1064,7 +1208,7 @@ 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)) {
@@ -1120,7 +1264,7 @@ function matchesGlob(pattern, relPath) {
   return globToRegExp(normalized).test(relPath);
 }
 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 +1279,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,7 +1291,7 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path7.resolve(ctx.cwd, args.path ?? ".");
+    const root = path9.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) {
@@ -1159,14 +1303,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,12 +1324,12 @@ 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);
       }
@@ -1232,14 +1376,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 +1391,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 +1437,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 +1449,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 +1463,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 +1509,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 +1559,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 +1600,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 +1653,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 +1787,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 +1954,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-R3RQCNFT.js");
       const child = new AgentLoop2({
         model: deps.model,
         registry: createDefaultRegistry(),
@@ -1896,6 +2040,7 @@ var AgentLoop = class {
     if (opts.sessionStore) {
       this.bindSnapshotHooks(opts.sessionStore);
     }
+    opts.registry?.register(createSkillTool({ cwd: opts.cwd }));
     const depth = opts.subagentDepth ?? 0;
     if (opts.registry && depth < MAX_SUBAGENT_DEPTH) {
       opts.registry.register(
@@ -2029,7 +2174,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);
       }
@@ -2140,7 +2286,9 @@ var AgentLoop = class {
   // (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.
+  // readProjectMemory caches 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 +2297,8 @@ var AgentLoop = class {
     if (plan) parts.push(PLAN_MODE_PROMPT.trim());
     const memory = readProjectMemory(this.opts.cwd);
     if (memory) parts.push(memory);
+    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;
@@ -2297,6 +2447,11 @@ export {
   hydrateSnapshots,
   undoTurnSnapshots,
   rewindToSnapshot,
+  starHome,
+  globalConfigPath,
+  sessionsDir,
+  projectConfigPath,
+  discoverSkills,
   defaultTaskManager,
   resolveShell,
   bashTool,
@@ -2311,4 +2466,4 @@ export {
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-RLQXGX3N.js.map
+//# sourceMappingURL=chunk-MJ2O7NWI.js.map