spacecode 2.5.4 → 2.5.6

package/dist/repl.mjs

@@ -4949,6 +4949,187 @@ var init_command_file = __esm({
   }
 });
 
+// ../agent/src/import/skill-file.ts
+function parseSkillFile(text) {
+  const lines2 = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines2[0] !== "---") return { ok: false, error: "missing frontmatter" };
+  const endIdx = lines2.indexOf("---", 1);
+  if (endIdx === -1) return { ok: false, error: "missing frontmatter" };
+  const front = lines2.slice(1, endIdx);
+  let name;
+  let description;
+  const blockIndicators = /* @__PURE__ */ new Set([">", "|", ">-", "|-"]);
+  for (let i = 0; i < front.length; i++) {
+    const raw = front[i];
+    if (!raw.trim() || raw.trim().startsWith("#") || /^\s/.test(raw)) continue;
+    if (!raw.includes(":")) return { ok: false, error: `malformed frontmatter line: ${raw}` };
+    const [rawKey, ...rest] = raw.split(":");
+    const key = rawKey.trim();
+    let value = rest.join(":").trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+    if (key === "description" && blockIndicators.has(value)) {
+      const block = [];
+      let j2 = i + 1;
+      while (j2 < front.length && /^\s/.test(front[j2])) block.push(front[j2++].replace(/^\s+/, ""));
+      description = block.join(" ").trim();
+      i = j2 - 1;
+      continue;
+    }
+    if (key === "name") name = value;
+    else if (key === "description") description = value;
+  }
+  if (!name || name.trim() === "") return { ok: false, error: "missing name" };
+  if (!description || description.trim() === "") return { ok: false, error: "missing description" };
+  return { ok: true, name: name.trim(), description: description.trim(), body: lines2.slice(endIdx + 1).join("\n").replace(/^(?:[ \t]*\n)*/, "") };
+}
+var init_skill_file = __esm({
+  "../agent/src/import/skill-file.ts"() {
+    "use strict";
+  }
+});
+
+// ../agent/src/import/tool-names.ts
+function translateToolNames(text) {
+  const counts = /* @__PURE__ */ new Map();
+  const names = Object.keys(TOOL_NAME_MAP).join("|");
+  const re3 = new RegExp("`(" + names + ")(\\([^`)]*\\))?`", "g");
+  const out = text.replace(re3, (_m, name, args) => {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+    return "`" + TOOL_NAME_MAP[name] + (args ?? "") + "`";
+  });
+  return { text: out, replaced: [...counts].map(([from, count]) => ({ from, to: TOOL_NAME_MAP[from], count })) };
+}
+function findUnsupported(text) {
+  return UNSUPPORTED.filter((u3) => u3.re.test(text)).map((u3) => u3.label);
+}
+var TOOL_NAME_MAP, UNSUPPORTED;
+var init_tool_names = __esm({
+  "../agent/src/import/tool-names.ts"() {
+    "use strict";
+    TOOL_NAME_MAP = {
+      Read: "read_file",
+      Write: "write_file",
+      Edit: "edit_file",
+      MultiEdit: "edit_file",
+      Glob: "list_directory",
+      Grep: "search",
+      Bash: "bash",
+      TodoWrite: "todo_write"
+    };
+    UNSUPPORTED = [
+      { label: "hooks", re: /\bhooks?\b.*\.(sh|json)|\bPreToolUse\b|\bPostToolUse\b|\bSessionStart\b|\bUserPromptSubmit\b/i },
+      { label: "ToolSearch / deferred tools", re: /\bToolSearch\b|deferred tools?/i },
+      { label: "Claude Code's Task/subagent tools", re: /\bsubagents?\b|\bAgent tool\b|`Task`|subagent_type/i },
+      { label: "Claude Code skills / slash commands", re: /\bSkill tool\b|invoke (?:the )?\w+ skill|\/ship\b|\/handoff\b/i },
+      { label: "MCP tool names (mcp__*)", re: /\bmcp__[A-Za-z0-9_-]+/ },
+      { label: "WebFetch/WebSearch/NotebookEdit tools", re: /`(?:WebFetch|WebSearch|NotebookEdit)`/ },
+      { label: "plan mode / worktree tools", re: /\bEnterPlanMode\b|\bExitPlanMode\b|\bEnterWorktree\b/ }
+    ];
+  }
+});
+
+// ../agent/src/import/skill-tool.ts
+function safeSkillPath(rel) {
+  if (rel === "" || rel.length > 200 || rel.startsWith("/") || rel.includes("\\") || rel.includes("\0")) return null;
+  const parts = rel.split("/");
+  return parts.every((p) => p !== "" && p !== "." && p !== "..") ? parts.join("/") : null;
+}
+function formatSkillBody(name, body, scripts) {
+  const parsed = parseSkillFile(body);
+  const t = translateToolNames(parsed.ok ? parsed.body : body);
+  const unsupported = findUnsupported(t.text);
+  const head = [`# Skill: ${name}`];
+  if (t.replaced.length) head.push(`Tool names translated: ${t.replaced.map((r) => `${r.from} -> ${r.to}`).join(", ")}.`);
+  if (unsupported.length) head.push(`Not supported here (skip those parts): ${unsupported.join("; ")}.`);
+  if (scripts) head.push("This skill ships scripts: they are not runnable until permitted (they run through `bash` and its permission rules).");
+  return `${head.join("\n")}
+
+${t.text}`;
+}
+function createSkillTool(source) {
+  return async (input) => {
+    const name = typeof input.name === "string" ? input.name.trim() : "";
+    if (!NAME_RE.test(name)) return { output: 'skill needs a "name" from the skills list', is_error: true };
+    try {
+      if (typeof input.file === "string" && input.file !== "") {
+        const rel = safeSkillPath(input.file);
+        if (!rel) return { output: `skill file path "${input.file}" must be relative to the skill, with no ".." segments`, is_error: true };
+        const text = await source.file(name, rel);
+        return text === null ? { output: `Skill "${name}" has no file "${rel}".`, is_error: true } : { output: text };
+      }
+      const body = await source.body(name);
+      if (body === null) return { output: `No skill named "${name}". Use a name from the skills list.`, is_error: true };
+      const scripts = (await source.list()).find((s) => s.name === name)?.scripts ?? false;
+      return { output: formatSkillBody(name, body, scripts) };
+    } catch (err) {
+      return { output: `skill failed: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
+    }
+  };
+}
+var SKILL_TOOL, NAME_RE;
+var init_skill_tool = __esm({
+  "../agent/src/import/skill-tool.ts"() {
+    "use strict";
+    init_tool_names();
+    init_skill_file();
+    SKILL_TOOL = {
+      name: "skill",
+      description: 'Load an imported skill by name (listed under "Skills (imported)" in your instructions) and follow it. Pass `file` to read a supporting file that ships with the skill (a path relative to the skill, e.g. "reference.md"). Skill text is written for Claude Code: tool names in it are translated, and lines under "Not supported here" name features that do not exist in this REPL.',
+      input_schema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "The skill name exactly as listed." },
+          file: { type: "string", description: 'Optional path of a sibling file inside the skill, e.g. "scripts/run.sh" or "reference.md".' }
+        },
+        required: ["name"]
+      }
+    };
+    NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+  }
+});
+
+// ../agent/src/import/skill-source.ts
+function siblingAssetName(skill, rel) {
+  return `${skill}.${rel.replace(/[^A-Za-z0-9_-]/g, "_")}`.slice(0, 100);
+}
+function isScriptPath(rel) {
+  return SCRIPT_RE.test(rel);
+}
+function createProfileSkillSource(client) {
+  const entries = async () => ((await client.index())?.assets ?? []).filter((a) => a.kind === "skill");
+  return {
+    async list() {
+      const all = await entries();
+      return all.filter((a) => NAME_RE2.test(a.name)).map((a) => ({
+        name: a.name,
+        description: a.description,
+        scope: "user",
+        scripts: all.some((s) => s.name.startsWith(`${a.name}.`) && s.description.startsWith(SIBLING_PREFIX) && isScriptPath(s.description.slice(SIBLING_PREFIX.length)))
+      }));
+    },
+    async body(name) {
+      return (await client.get("skill", name))?.content ?? null;
+    },
+    async file(name, rel) {
+      const safe = safeSkillPath(rel);
+      if (!safe) return null;
+      const all = await entries();
+      const hit = all.find((a) => a.name.startsWith(`${name}.`) && a.description === `${SIBLING_PREFIX}${safe}`);
+      return hit ? (await client.get("skill", hit.name))?.content ?? null : null;
+    }
+  };
+}
+var SIBLING_PREFIX, NAME_RE2, SCRIPT_RE;
+var init_skill_source = __esm({
+  "../agent/src/import/skill-source.ts"() {
+    "use strict";
+    init_skill_tool();
+    SIBLING_PREFIX = "file:";
+    NAME_RE2 = /^[A-Za-z0-9_-]{1,64}$/;
+    SCRIPT_RE = /^(scripts\/|.*\.(sh|py|js|mjs|ts|rb|pl)$)/;
+  }
+});
+
 // ../agent/src/import/claude-sources.ts
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
@@ -4987,6 +5168,7 @@ async function readClaudeAssets({ fs: fs6, home, projectDirs }) {
     if (/^@\S+/m.test(globalText)) report.notes.push("CLAUDE.md contains @path includes; they are kept as plain text and not expanded in v1");
   }
   await readCommands(fs6, home, report);
+  await readSkills(fs6, home, report);
   for (const dir of projectDirs) {
     const memDir = `${home}/.claude/projects/${claudeProjectSlug(dir)}/memory`;
     let entries;
@@ -5006,7 +5188,7 @@ async function readClaudeAssets({ fs: fs6, home, projectDirs }) {
       if (text === null) continue;
       const base = entry === "MEMORY.md" ? "index" : entry.slice(0, -3).replace(/[^A-Za-z0-9._-]/g, "_");
       const name = `${key}.${base}`;
-      if (!NAME_RE.test(name)) {
+      if (!NAME_RE3.test(name)) {
         report.errors.push({ path: path12, message: `cannot derive a valid asset name from "${entry}"` });
         continue;
       }
@@ -5063,14 +5245,84 @@ async function readCommands(fs6, home, report) {
     report.assets.push({ kind: "command", name, description: parseCommandFile(text).description, content: text, source: path12 });
   }
 }
-var MAX_ASSET_BYTES, NAME_RE, COMMAND_NAME_RE;
+async function listFiles(fs6, dir, rel, out, report) {
+  let entries;
+  try {
+    entries = await fs6.readdir(dir);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOTDIR") out.push(rel);
+    else if (code !== "ENOENT") report.errors.push({ path: dir, message: err instanceof Error ? err.message : String(err) });
+    return;
+  }
+  for (const e of [...entries].sort()) {
+    if (e.startsWith(".")) continue;
+    await listFiles(fs6, `${dir}/${e}`, rel === "" ? e : `${rel}/${e}`, out, report);
+  }
+}
+async function readSkills(fs6, home, report) {
+  const root = `${home}/.claude/skills`;
+  let dirs;
+  try {
+    dirs = await fs6.readdir(root);
+  } catch (err) {
+    if (!isEnoent(err)) report.errors.push({ path: root, message: err instanceof Error ? err.message : String(err) });
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of [...dirs].sort()) {
+    if (dir.startsWith(".")) continue;
+    const skillPath = `${root}/${dir}/SKILL.md`;
+    const text = await readOptional(fs6, skillPath, report);
+    if (text === null) continue;
+    const parsed = parseSkillFile(text);
+    if (!parsed.ok) {
+      report.errors.push({ path: skillPath, message: `malformed skill: ${parsed.error}` });
+      continue;
+    }
+    if (!SKILL_NAME_RE.test(parsed.name) || seen.has(parsed.name.toLowerCase())) {
+      report.errors.push({ path: skillPath, message: seen.has(parsed.name.toLowerCase()) ? `skill name collision on "${parsed.name}"` : `skill name "${parsed.name}" must use only letters, digits, - and _` });
+      continue;
+    }
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > MAX_ASSET_BYTES) {
+      report.errors.push({ path: skillPath, message: `skill skipped: SKILL.md is ${bytes} bytes, over the ${MAX_ASSET_BYTES} byte asset limit` });
+      continue;
+    }
+    seen.add(parsed.name.toLowerCase());
+    const files = [];
+    await listFiles(fs6, `${root}/${dir}`, "", files, report);
+    const siblings = [];
+    const slugs = /* @__PURE__ */ new Set();
+    for (const rel of files.filter((f) => f !== "SKILL.md")) {
+      const path12 = `${root}/${dir}/${rel}`;
+      const content = await readOptional(fs6, path12, report);
+      if (content === null) continue;
+      const size = Buffer.byteLength(content, "utf8");
+      const name = siblingAssetName(parsed.name, rel);
+      if (size > MAX_ASSET_BYTES || slugs.has(name) || siblings.length >= MAX_SKILL_FILES || content.includes("\0")) {
+        report.notes.push(`Skill ${parsed.name}: ${rel} not imported (${content.includes("\0") ? "binary file" : size > MAX_ASSET_BYTES ? `${size} bytes, over the ${MAX_ASSET_BYTES} byte limit` : slugs.has(name) ? "name collision" : `more than ${MAX_SKILL_FILES} files`}); the skill still loads without it`);
+        continue;
+      }
+      slugs.add(name);
+      siblings.push({ kind: "skill", name, description: `${SIBLING_PREFIX}${rel}`, content, source: path12 });
+    }
+    if (siblings.some((s) => isScriptPath(s.description.slice(SIBLING_PREFIX.length)))) report.notes.push(`Skill ${parsed.name}: ships scripts, not runnable until permitted (they run through bash and its permission rules)`);
+    report.assets.push({ kind: "skill", name: parsed.name, description: parsed.description, content: text, source: skillPath }, ...siblings);
+  }
+}
+var MAX_ASSET_BYTES, NAME_RE3, COMMAND_NAME_RE, SKILL_NAME_RE, MAX_SKILL_FILES;
 var init_claude_sources = __esm({
   "../agent/src/import/claude-sources.ts"() {
     "use strict";
     init_command_file();
+    init_skill_file();
+    init_skill_source();
     MAX_ASSET_BYTES = 256 * 1024;
-    NAME_RE = /^[A-Za-z0-9._-]{1,100}$/;
+    NAME_RE3 = /^[A-Za-z0-9._-]{1,100}$/;
     COMMAND_NAME_RE = /^[A-Za-z][A-Za-z0-9_-]*$/;
+    SKILL_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+    MAX_SKILL_FILES = 40;
   }
 });
 
@@ -5120,6 +5372,16 @@ function createProfileClient({ baseUrl, apiKey, fetch: doFetch, timeoutMs = 8e3
       const res = await call("POST", "/adapt", { body: { sections }, timeoutMs: ADAPT_TIMEOUT_MS });
       return await res.json();
     },
+    /** Deletes one asset; false when it did not exist. */
+    async delete(kind, name) {
+      try {
+        await call("DELETE", `/assets/${enc(kind)}/${enc(name)}`);
+        return true;
+      } catch (err) {
+        if (err instanceof ProfileApiError && err.status === 404) return false;
+        throw err;
+      }
+    },
     async put(kind, name, input) {
       const res = await call("PUT", `/assets/${enc(kind)}/${enc(name)}`, {
         body: { content: input.content, description: input.description ?? "", base_version: input.baseVersion }
@@ -5302,46 +5564,6 @@ var init_instruction_sections = __esm({
   }
 });
 
-// ../agent/src/import/tool-names.ts
-function translateToolNames(text) {
-  const counts = /* @__PURE__ */ new Map();
-  const names = Object.keys(TOOL_NAME_MAP).join("|");
-  const re3 = new RegExp("`(" + names + ")(\\([^`)]*\\))?`", "g");
-  const out = text.replace(re3, (_m, name, args) => {
-    counts.set(name, (counts.get(name) ?? 0) + 1);
-    return "`" + TOOL_NAME_MAP[name] + (args ?? "") + "`";
-  });
-  return { text: out, replaced: [...counts].map(([from, count]) => ({ from, to: TOOL_NAME_MAP[from], count })) };
-}
-function findUnsupported(text) {
-  return UNSUPPORTED.filter((u3) => u3.re.test(text)).map((u3) => u3.label);
-}
-var TOOL_NAME_MAP, UNSUPPORTED;
-var init_tool_names = __esm({
-  "../agent/src/import/tool-names.ts"() {
-    "use strict";
-    TOOL_NAME_MAP = {
-      Read: "read_file",
-      Write: "write_file",
-      Edit: "edit_file",
-      MultiEdit: "edit_file",
-      Glob: "list_directory",
-      Grep: "search",
-      Bash: "bash",
-      TodoWrite: "todo_write"
-    };
-    UNSUPPORTED = [
-      { label: "hooks", re: /\bhooks?\b.*\.(sh|json)|\bPreToolUse\b|\bPostToolUse\b|\bSessionStart\b|\bUserPromptSubmit\b/i },
-      { label: "ToolSearch / deferred tools", re: /\bToolSearch\b|deferred tools?/i },
-      { label: "Claude Code's Task/subagent tools", re: /\bsubagents?\b|\bAgent tool\b|`Task`|subagent_type/i },
-      { label: "Claude Code skills / slash commands", re: /\bSkill tool\b|invoke (?:the )?\w+ skill|\/ship\b|\/handoff\b/i },
-      { label: "MCP tool names (mcp__*)", re: /\bmcp__[A-Za-z0-9_-]+/ },
-      { label: "WebFetch/WebSearch/NotebookEdit tools", re: /`(?:WebFetch|WebSearch|NotebookEdit)`/ },
-      { label: "plan mode / worktree tools", re: /\bEnterPlanMode\b|\bExitPlanMode\b|\bEnterWorktree\b/ }
-    ];
-  }
-});
-
 // ../agent/src/import/coverage.ts
 function extractRuleLines(text) {
   const out = [];
@@ -5850,6 +6072,69 @@ var init_command_registry = __esm({
   }
 });
 
+// ../agent/src/import/skill-prompt.ts
+function buildSkillsSection(skills, budget = SKILLS_BUDGET_CHARS) {
+  if (skills.length === 0) return { text: "", trimmed: [], omitted: [] };
+  const header = "\n## Skills (imported)\nCall the `skill` tool with a skill name to load its full instructions before doing work it covers.\n";
+  const clean = skills.map((s) => ({ name: s.name, full: s.description.replace(/\s+/g, " ").trim() }));
+  const descs = new Map(clean.map((s) => [s.name, s.full]));
+  const line = (n) => `- ${n}: ${descs.get(n)}
+`;
+  const size = (names2) => header.length + names2.reduce((a, n) => a + line(n).length, 0);
+  let names = clean.map((s) => s.name);
+  const trimmed = /* @__PURE__ */ new Set();
+  while (size(names) > budget) {
+    const longest = [...names].sort((a, b2) => descs.get(b2).length - descs.get(a).length)[0];
+    const d = descs.get(longest);
+    if (d.length <= MIN_DESC) break;
+    descs.set(longest, `${d.slice(0, Math.max(MIN_DESC, Math.floor(d.length * 0.7)) - 1)}\u2026`);
+    trimmed.add(longest);
+  }
+  const omitted = [];
+  while (size(names) > budget && names.length > 0) omitted.unshift(names.pop());
+  return { text: names.length ? header + names.map(line).join("") : "", trimmed: [...trimmed], omitted };
+}
+var SKILLS_BUDGET_CHARS, MIN_DESC;
+var init_skill_prompt = __esm({
+  "../agent/src/import/skill-prompt.ts"() {
+    "use strict";
+    SKILLS_BUDGET_CHARS = 4e3;
+    MIN_DESC = 20;
+  }
+});
+
+// ../agent/src/import/mcp-json-summary.ts
+function listMcpSpawns(text) {
+  const result = [];
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return result;
+  }
+  if (typeof data !== "object" || data === null) return result;
+  const mcpServers = data["mcpServers"];
+  if (typeof mcpServers !== "object" || mcpServers === null) return result;
+  for (const [name, value] of Object.entries(mcpServers)) {
+    if (typeof value !== "object" || value === null) continue;
+    const entry = value;
+    const command = entry["command"];
+    if (typeof command !== "string") continue;
+    const argsRaw = entry["args"];
+    const args = Array.isArray(argsRaw) ? argsRaw.filter((a) => typeof a === "string") : [];
+    const envRaw = entry["env"];
+    const envNames = typeof envRaw === "object" && envRaw !== null ? Object.keys(envRaw).sort() : [];
+    result.push({ name, command, args, envNames });
+  }
+  result.sort((a, b2) => a.name.localeCompare(b2.name));
+  return result;
+}
+var init_mcp_json_summary = __esm({
+  "../agent/src/import/mcp-json-summary.ts"() {
+    "use strict";
+  }
+});
+
 // ../agent/src/index.ts
 var init_src = __esm({
   "../agent/src/index.ts"() {
@@ -5894,6 +6179,11 @@ var init_src = __esm({
     init_command_file();
     init_command_registry();
     init_claude_sources();
+    init_skill_file();
+    init_skill_prompt();
+    init_skill_tool();
+    init_skill_source();
+    init_mcp_json_summary();
   }
 });
 
@@ -5934,14 +6224,241 @@ var init_api_key = __esm({
   }
 });
 
+// src/import-gate.ts
+var import_gate_exports = {};
+__export(import_gate_exports, {
+  REPO_SOURCE_FILES: () => REPO_SOURCE_FILES,
+  createNodeTrustStore: () => createNodeTrustStore,
+  importGateStatus: () => importGateStatus,
+  nodeTrustFs: () => nodeTrustFs,
+  readRepoSources: () => readRepoSources,
+  sha256: () => sha256,
+  writeTextAtomic: () => writeTextAtomic
+});
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, readdir, realpath, rename, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join as join2 } from "node:path";
+async function readOrNull(path12) {
+  try {
+    return await readFile(path12, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeTextAtomic(path12, text) {
+  await mkdir(dirname3(path12), { recursive: true });
+  const tmp = `${path12}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(tmp, text, { mode: 384 });
+  await chmod(tmp, 384);
+  await rename(tmp, path12);
+}
+async function readRepoSources(cwd2) {
+  const files = {};
+  for (const name of REPO_SOURCE_FILES) {
+    const text = await readOrNull(join2(cwd2, name));
+    if (text !== null) files[name] = text;
+  }
+  let entries = [];
+  try {
+    entries = await readdir(join2(cwd2, ".claude", "commands"));
+  } catch (err) {
+    if (err.code !== "ENOENT" && err.code !== "ENOTDIR") throw err;
+  }
+  for (const e of entries.filter((x2) => x2.endsWith(".md")).sort()) {
+    const text = await readOrNull(join2(cwd2, ".claude", "commands", e));
+    if (text !== null) files[`.claude/commands/${e}`] = text;
+  }
+  await readRepoSkillFiles(cwd2, files);
+  return files;
+}
+async function readRepoSkillFiles(cwd2, files) {
+  const root = join2(cwd2, ".claude", "skills");
+  let count = 0;
+  const walk = async (dir, rel) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT" || code === "ENOTDIR") return;
+      throw err;
+    }
+    for (const e of entries.sort((a, b2) => a.name < b2.name ? -1 : 1)) {
+      if (e.name.startsWith(".") || e.isSymbolicLink()) continue;
+      const key = `${rel}/${e.name}`;
+      if (e.isDirectory()) await walk(join2(dir, e.name), key);
+      else if (e.isFile() && count < MAX_REPO_SKILL_FILES) {
+        const text = await readOrNull(join2(dir, e.name));
+        if (text !== null && !text.includes("\0") && Buffer.byteLength(text, "utf8") <= MAX_REPO_SKILL_BYTES) {
+          files[key] = text;
+          count++;
+        }
+      }
+    }
+  };
+  await walk(root, ".claude/skills");
+}
+function nodeTrustFs() {
+  return { readText: readOrNull, writeTextAtomic, realPath: (p) => realpath(p) };
+}
+function createNodeTrustStore(configDir) {
+  let store = trustStores.get(configDir);
+  if (!store) {
+    store = new TrustStore({ fs: nodeTrustFs(), path: join2(configDir, "trust.json"), hash: sha256 });
+    trustStores.set(configDir, store);
+  }
+  return store;
+}
+async function importGateStatus(deps) {
+  const lines2 = [];
+  const configPath = join2(deps.configDir, "imports.json");
+  try {
+    const loaded = parseImportsConfig(await readOrNull(configPath), configPath);
+    if (loaded.error) lines2.push(`imports: ${loaded.error} (every category off)`);
+    else {
+      const on = IMPORT_CATEGORIES.filter((c) => loaded.config.categories[c]);
+      lines2.push(on.length ? `imports: on for ${on.join(", ")}` : "imports: every category off (default)");
+    }
+  } catch (err) {
+    lines2.push(`imports: not read (${err instanceof Error ? err.message : String(err)}); every category off`);
+  }
+  try {
+    const files = await readRepoSources(deps.cwd);
+    const found = Object.keys(files);
+    if (found.length === 0) return lines2;
+    const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, files);
+    const names = found.join(", ");
+    if (status === "trusted" || status === "session") lines2.push(`repo sources: ${names} (trusted${status === "session" ? " for this session" : ""})`);
+    else if (status === "never") lines2.push(`repo sources: ${names} NOT loaded (marked never trust)`);
+    else lines2.push(`repo sources: ${names} NOT loaded (untrusted${deps.interactive ? "" : ", non-interactive run"})`);
+  } catch (err) {
+    lines2.push(`repo sources: NOT loaded (trust check failed: ${err instanceof Error ? err.message : String(err)})`);
+  }
+  return lines2;
+}
+var REPO_SOURCE_FILES, MAX_REPO_SKILL_FILES, MAX_REPO_SKILL_BYTES, sha256, trustStores;
+var init_import_gate = __esm({
+  "src/import-gate.ts"() {
+    "use strict";
+    init_src();
+    REPO_SOURCE_FILES = [".mcp.json", ".claude/settings.json", ".claude/settings.local.json", "CLAUDE.local.md"];
+    MAX_REPO_SKILL_FILES = 200;
+    MAX_REPO_SKILL_BYTES = 256 * 1024;
+    sha256 = (text) => createHash("sha256").update(text).digest("hex");
+    trustStores = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/skills-loader.ts
+import { join as join3 } from "node:path";
+function repoSkillSource(sources, parse, problems) {
+  const dirs = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(sources).filter((k2) => k2.startsWith(REPO_PREFIX) && k2.endsWith("/SKILL.md") && k2.split("/").length === 4)) {
+    const parsed = parse(sources[key]);
+    if (!parsed.ok) problems.push(`${key}: malformed skill (${parsed.error})`);
+    else if (dirs.has(parsed.name)) problems.push(`${key}: duplicate skill name "${parsed.name}"`);
+    else dirs.set(parsed.name, { dir: key.split("/")[2], description: parsed.description });
+  }
+  const prefix = (name) => `${REPO_PREFIX}${dirs.get(name)?.dir}/`;
+  return {
+    async list() {
+      return [...dirs].map(([name, d]) => ({
+        name,
+        description: d.description,
+        scope: "repo",
+        scripts: Object.keys(sources).some((k2) => k2.startsWith(prefix(name)) && SCRIPT_RE2.test(k2.slice(prefix(name).length)))
+      }));
+    },
+    async body(name) {
+      return dirs.has(name) ? sources[`${prefix(name)}SKILL.md`] ?? null : null;
+    },
+    async file(name, rel) {
+      const safe = safeSkillPath(rel);
+      return dirs.has(name) && safe ? sources[`${prefix(name)}${safe}`] ?? null : null;
+    }
+  };
+}
+function mergeSkillSources(repo, user) {
+  return {
+    async list() {
+      const r = await repo?.list() ?? [];
+      const names = new Set(r.map((s) => s.name));
+      return [...r, ...(await user?.list() ?? []).filter((s) => !names.has(s.name))];
+    },
+    async body(name) {
+      return await repo?.body(name) ?? null ?? await user?.body(name) ?? null;
+    },
+    async file(name, rel) {
+      if (await repo?.body(name) != null) return repo.file(name, rel);
+      return await user?.file(name, rel) ?? null;
+    }
+  };
+}
+async function loadSkills(deps) {
+  const configPath = join3(deps.configDir, "imports.json");
+  try {
+    const loaded = parseImportsConfig(await deps.readFile(configPath).catch((err) => {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }), configPath);
+    if (loaded.error) return NONE("skills: off (imports.json unreadable)");
+    if (!loaded.config.categories.skills) return NONE("skills: off (imports.json has skills off)");
+  } catch (err) {
+    return NONE(`skills: off (imports.json not read: ${err instanceof Error ? err.message : String(err)})`);
+  }
+  const lines2 = [];
+  const problems = [];
+  let repo = null;
+  try {
+    const sources = await readRepoSources(deps.cwd);
+    if (Object.keys(sources).some((k2) => k2.startsWith(REPO_PREFIX))) {
+      const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, sources);
+      if (status === "trusted" || status === "session") repo = repoSkillSource(sources, deps.parse, problems);
+      else lines2.push(`skills: repo skills NOT loaded (${status === "never" ? "marked never trust" : "untrusted repo"})`);
+    }
+  } catch (err) {
+    lines2.push(`skills: repo skills NOT loaded (${err instanceof Error ? err.message : String(err)})`);
+  }
+  let user = null;
+  if (deps.client) {
+    const source2 = createProfileSkillSource(deps.client);
+    try {
+      await source2.list();
+      user = source2;
+    } catch (err) {
+      lines2.push(`skills: user skills NOT loaded (${err instanceof Error ? err.message : String(err)})`);
+    }
+  } else lines2.push("skills: user skills NOT loaded (not signed in)");
+  const source = mergeSkillSources(repo, user);
+  const all = await source.list();
+  const shadowed = repo && user ? (await user.list()).filter((u3) => all.some((a) => a.name === u3.name && a.scope === "repo")).map((u3) => u3.name) : [];
+  for (const p of problems) lines2.push(`skills: ${p}`);
+  const section2 = buildSkillsSection(all);
+  lines2.unshift(`skills: ${all.filter((s) => s.scope === "user").length} user, ${all.filter((s) => s.scope === "repo").length} repo${shadowed.length ? `; repo shadows user: ${shadowed.join(", ")}` : ""}${section2.trimmed.length ? `; descriptions trimmed: ${section2.trimmed.join(", ")}` : ""}${section2.omitted.length ? `; NOT listed (over the 4k prompt budget): ${section2.omitted.join(", ")}` : ""}`);
+  if (all.length === 0) return { ...NONE(lines2[0]), statusLines: lines2, source };
+  return { promptSection: section2.text, tools: [SKILL_TOOL], handlers: { skill: createSkillTool(source) }, statusLines: lines2, source };
+}
+var NONE, REPO_PREFIX, SCRIPT_RE2;
+var init_skills_loader = __esm({
+  "src/skills-loader.ts"() {
+    "use strict";
+    init_src();
+    init_import_gate();
+    NONE = (line) => ({ promptSection: "", tools: [], handlers: {}, statusLines: [line], source: null });
+    REPO_PREFIX = ".claude/skills/";
+    SCRIPT_RE2 = /^(scripts\/|.*\.(sh|py|js|mjs|ts|rb|pl)$)/;
+  }
+});
+
 // src/profile-runtime.ts
-import { join as join2 } from "node:path";
+import { join as join4 } from "node:path";
 function backendUrl(env3) {
   return env3.SPACECODE_BACKEND_URL?.trim() || env3.SPACECODE_API_URL?.trim() || DEFAULT_BACKEND_URL;
 }
 function fileCache(deps) {
-  const dir = join2(deps.env.SPACECODE_CONFIG_DIR?.trim() || join2(deps.homedir(), ".spacecode"));
-  const file = join2(dir, "profile-cache.json");
+  const dir = join4(deps.env.SPACECODE_CONFIG_DIR?.trim() || join4(deps.homedir(), ".spacecode"));
+  const file = join4(dir, "profile-cache.json");
   return {
     async read() {
       let raw;
@@ -5987,8 +6504,15 @@ async function prepareProfileUnsafe(deps) {
   const root = await deps.gitRoot?.() ?? null;
   const keys = [.../* @__PURE__ */ new Set([projectKey(deps.cwd), ...root ? [projectKey(root)] : []])];
   const client = createProfileClient({ baseUrl: backendUrl(deps.env), apiKey, fetch: deps.fetch, timeoutMs: 3e3 });
+  const skills = await loadSkills({
+    configDir: deps.env.SPACECODE_CONFIG_DIR?.trim() || join4(deps.homedir(), ".spacecode"),
+    cwd: deps.cwd,
+    readFile: deps.readFile,
+    client,
+    parse: parseSkillFile
+  });
   const result = await loadProfile({ client, cache: fileCache(deps), projectKeys: keys });
-  if (!result.profile) return EMPTY([`profile: not loaded (${result.error ?? "unknown error"})`]);
+  if (!result.profile) return { ...EMPTY([`profile: not loaded (${result.error ?? "unknown error"})`, ...skills.statusLines]), promptSection: skills.promptSection, tools: skills.tools, handlers: skills.handlers, skills: skills.source };
   const key = result.profile.projectKey;
   const hasMemory = result.profile.memoryIndex !== null && key !== null;
   const hasSections = result.profile.instructions?.includes("## More instructions (on demand)") ?? false;
@@ -5997,10 +6521,13 @@ async function prepareProfileUnsafe(deps) {
     `profile: v${result.profile.version} ${result.source === "cache" ? "(STALE: served from cache)" : "(live)"}${result.profile.instructions ? ", instructions" : ""}${hasSections ? ", adapted (on-demand sections)" : ""}${hasMemory ? `, memory "${key}"` : ""}${section2.truncated ? ", TRUNCATED to fit the prompt budget" : ""}`
   ];
   if (result.error) lines2.push(`profile warning: ${result.error}`);
+  lines2.push(...skills.statusLines);
   return {
-    promptSection: section2.text,
-    tools: [...hasMemory ? [MEMORY_READ_TOOL] : [], ...hasSections ? [INSTRUCTIONS_READ_TOOL] : []],
+    promptSection: section2.text + skills.promptSection,
+    skills: skills.source,
+    tools: [...hasMemory ? [MEMORY_READ_TOOL] : [], ...hasSections ? [INSTRUCTIONS_READ_TOOL] : [], ...skills.tools],
     handlers: {
+      ...skills.handlers,
       ...hasMemory ? { memory_read: createMemoryReadTool(client, key) } : {},
       ...hasSections ? { instructions_read: createInstructionsReadTool(client) } : {}
     },
@@ -6013,6 +6540,8 @@ var init_profile_runtime = __esm({
     "use strict";
     init_src();
     init_api_key();
+    init_skills_loader();
+    init_src();
     DEFAULT_BACKEND_URL = "https://backend.spacecode.app";
     EMPTY = (statusLines) => ({ promptSection: "", tools: [], handlers: {}, statusLines });
   }
@@ -6226,6 +6755,86 @@ var init_import_claude = __esm({
   }
 });
 
+// src/repo-trust-prompt.ts
+var repo_trust_prompt_exports = {};
+__export(repo_trust_prompt_exports, {
+  describeRepoSources: () => describeRepoSources,
+  promptRepoTrust: () => promptRepoTrust
+});
+function ruleLists(path12, text, lines2, warnings) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (err) {
+    if (!(err instanceof SyntaxError)) throw err;
+    warnings.push(`${path12}: not valid JSON, nothing from it loads`);
+    return;
+  }
+  const perms = typeof data === "object" && data !== null ? data.permissions : void 0;
+  if (typeof perms !== "object" || perms === null) return;
+  for (const effect of ["allow", "deny", "ask"]) {
+    const list2 = perms[effect];
+    if (!Array.isArray(list2)) continue;
+    for (const rule of list2) if (typeof rule === "string") lines2.push(`  ${effect}: ${show(rule)}  (${path12})`);
+  }
+}
+function describeRepoSources(files) {
+  const out = [];
+  const warnings = [];
+  if (files[".mcp.json"] !== void 0) {
+    let valid = true;
+    try {
+      JSON.parse(files[".mcp.json"]);
+    } catch (err) {
+      if (!(err instanceof SyntaxError)) throw err;
+      valid = false;
+      warnings.push(".mcp.json: not valid JSON, nothing from it loads");
+    }
+    for (const s of valid ? listMcpSpawns(files[".mcp.json"]) : []) {
+      const env3 = s.envNames.length ? `  env: ${s.envNames.join(", ")}` : "";
+      out.push(`  spawn: ${show(s.command)} ${s.args.map(show).join(" ")}  [server ${show(s.name)}]${env3}`);
+    }
+  }
+  for (const p of [".claude/settings.json", ".claude/settings.local.json"]) {
+    if (files[p] !== void 0) ruleLists(p, files[p], out, warnings);
+  }
+  const names = Object.keys(files).sort();
+  for (const k2 of names) {
+    const m2 = /^\.claude\/commands\/([^/]+)\.md$/.exec(k2);
+    if (m2) out.push(`  command: /${show(m2[1]).slice(1, -1)}`);
+  }
+  const skills = /* @__PURE__ */ new Set();
+  for (const k2 of names) {
+    const m2 = /^\.claude\/skills\/([^/]+)\//.exec(k2);
+    if (m2) skills.add(m2[1]);
+  }
+  for (const s of [...skills].sort()) out.push(`  skill: ${show(s)}`);
+  if (files["CLAUDE.local.md"] !== void 0) out.push("  instructions: CLAUDE.local.md");
+  return [...warnings.map((w2) => `  warning: ${w2}`), ...out];
+}
+async function promptRepoTrust(cwd2, files, io) {
+  io.write(`
+This repository has Claude Code sources that can run code or change permissions:
+  ${cwd2}
+${describeRepoSources(files).join("\n")}
+
+`);
+  io.write("  1) Trust (remembered until these files change)\n  2) Trust for this session only\n  3) Never trust this repo\n  4) Skip (load nothing, ask again next time)\n");
+  const answer = (await io.ask("Choose 1-4 [4]: "))?.trim() ?? "";
+  if (answer === "1") return "trusted";
+  if (answer === "2") return "session";
+  if (answer === "3") return "never";
+  return "skip";
+}
+var show;
+var init_repo_trust_prompt = __esm({
+  "src/repo-trust-prompt.ts"() {
+    "use strict";
+    init_src();
+    show = (s) => JSON.stringify(s);
+  }
+});
+
 // ../../node_modules/es-toolkit/dist/function/debounce.mjs
 function debounce(func, debounceMs, { signal, edges } = {}) {
   let pendingThis = void 0;
@@ -41385,7 +41994,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join8(regexps, separator = "|") {
+    function join9(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex2) => {
         numCaptures += 1;
@@ -41689,7 +42298,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join8(terminators), true);
+          this.matcherRe = langRe(join9(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -99195,7 +99804,7 @@ var init_credential_filter = __esm({
 });
 
 // src/session/session-store.ts
-import { chmod, mkdir, open, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, open, readdir as readdir2, readFile as readFile2, rename as rename2, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import path3 from "node:path";
 function redactCredentials(value) {
@@ -99284,11 +99893,11 @@ var init_session_store = __esm({
         }
         const tmp = `${file}.${process.pid}.tmp`;
         try {
-          await mkdir(this.dir, { recursive: true, mode: 448 });
-          await chmod(this.dir, 448);
-          await writeFile(tmp, body, { mode: 384 });
-          await chmod(tmp, 384);
-          await rename(tmp, file);
+          await mkdir2(this.dir, { recursive: true, mode: 448 });
+          await chmod2(this.dir, 448);
+          await writeFile2(tmp, body, { mode: 384 });
+          await chmod2(tmp, 384);
+          await rename2(tmp, file);
         } catch (err) {
           throw new SessionError(file, `Could not save session: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
         }
@@ -99301,7 +99910,7 @@ var init_session_store = __esm({
           if (size > MAX_SESSION_BYTES) {
             throw new SessionError(file, `Session is ${size} bytes, over the ${MAX_SESSION_BYTES}-byte cap; not loaded`);
           }
-          text = await readFile(file, "utf8");
+          text = await readFile2(file, "utf8");
         } catch (err) {
           if (err instanceof SessionError) throw err;
           throw new SessionError(file, `Could not read session: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
@@ -99314,7 +99923,7 @@ var init_session_store = __esm({
       async list() {
         let names;
         try {
-          names = await readdir(this.dir);
+          names = await readdir2(this.dir);
         } catch (err) {
           if (err.code === "ENOENT") return { sessions: [], errors: [] };
           throw new SessionError(this.dir, `Could not list sessions: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
@@ -100492,6 +101101,7 @@ var init_slash_commands = __esm({
       { name: "model", description: "List gateway models; /model <n|id> switches for this session" },
       { name: "turns", description: "Browse earlier turns and open their steps (shortcut: ctrl+o)" },
       { name: "commands", description: "List the slash commands imported from Claude Code" },
+      { name: "skills", description: "List imported skills; /skills show <name> [file], /skills delete <name>" },
       { name: "tools", description: "List the tools available to the agent" },
       { name: "exit", description: "Quit the REPL (alias: /quit)" },
       { name: "quit", description: "Quit the REPL" }
@@ -100508,7 +101118,7 @@ function validateSubmission(text, extra = []) {
 function withCursor(row, col) {
   return `${row.slice(0, col)}\x1B[7m${row[col] ?? " "}\x1B[27m${row.slice(col + 1)}`;
 }
-function PromptEditor({ onSubmit, disabled, history, listFiles: listFiles2, onTab, locked = false, promptGlyph: promptGlyph2 = ">", onEmptyEnter, unicode = true, fullWidth = false, extraCommands = [] }) {
+function PromptEditor({ onSubmit, disabled, history, listFiles: listFiles3, onTab, locked = false, promptGlyph: promptGlyph2 = ">", onEmptyEnter, unicode = true, fullWidth = false, extraCommands = [] }) {
   const { exit } = use_app_default();
   const { columns } = useTerminalSize();
   const { isRawModeSupported } = use_stdin_default();
@@ -100544,15 +101154,15 @@ function PromptEditor({ onSubmit, disabled, history, listFiles: listFiles2, onTa
   const mention = shell ? null : activeMention(buf.text, buf.cursor);
   const mentionOpen = mention !== null;
   (0, import_react29.useEffect)(() => {
-    if (!mentionOpen || !listFiles2 || filesRef.current !== null || loadingFiles.current) return;
+    if (!mentionOpen || !listFiles3 || filesRef.current !== null || loadingFiles.current) return;
     loadingFiles.current = true;
-    listFiles2().then((f) => {
+    listFiles3().then((f) => {
       filesRef.current = f;
       setFiles(f);
     }).catch((err) => fail("Could not list files", err)).finally(() => {
       loadingFiles.current = false;
     });
-  }, [mentionOpen, listFiles2, fail]);
+  }, [mentionOpen, listFiles3, fail]);
   const chooseSel = (n) => {
     selRef.current = n;
     setSel(n);
@@ -100787,24 +101397,24 @@ var init_history_store = __esm({
 });
 
 // src/editor/history-file-io.ts
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
 import path4 from "node:path";
 function createFileHistoryIO(file) {
   return {
     async read() {
       try {
-        return await readFile2(file, "utf8");
+        return await readFile3(file, "utf8");
       } catch (err) {
         if (err.code === "ENOENT") return null;
         throw err;
       }
     },
     async write(content) {
-      await mkdir2(path4.dirname(file), { recursive: true, mode: 448 });
+      await mkdir3(path4.dirname(file), { recursive: true, mode: 448 });
       const tmp = `${file}.${process.pid}.tmp`;
-      await writeFile2(tmp, content, { mode: 384 });
-      await chmod2(tmp, 384);
-      await rename2(tmp, file);
+      await writeFile3(tmp, content, { mode: 384 });
+      await chmod3(tmp, 384);
+      await rename3(tmp, file);
     }
   };
 }
@@ -101013,7 +101623,7 @@ var init_shell_turn = __esm({
 });
 
 // src/editor/file-list.ts
-async function listFiles(readDir, opts = {}) {
+async function listFiles2(readDir, opts = {}) {
   const max = opts.maxFiles ?? DEFAULT_MAX_LISTED_FILES;
   const files = [];
   const queue = [""];
@@ -101240,18 +101850,18 @@ var init_mention_resolver = __esm({
 });
 
 // src/editor/node-mention-fs.ts
-import { open as open2, realpath, stat as stat2 } from "node:fs/promises";
+import { open as open2, realpath as realpath2, stat as stat2 } from "node:fs/promises";
 import path6 from "node:path";
 function isInside(root, target) {
   return target === root || target.startsWith(root.endsWith(path6.sep) ? root : root + path6.sep);
 }
 function createNodeMentionFS(cwd2) {
   let rootPromise;
-  const root = () => rootPromise ??= realpath(cwd2);
+  const root = () => rootPromise ??= realpath2(cwd2);
   async function confined(abs) {
     let real;
     try {
-      real = await realpath(abs);
+      real = await realpath2(abs);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -101287,11 +101897,11 @@ var init_node_mention_fs = __esm({
 });
 
 // src/editor/node-read-dir.ts
-import { readdir as readdir2 } from "node:fs/promises";
+import { readdir as readdir3 } from "node:fs/promises";
 import path7 from "node:path";
 function createNodeReadDir(cwd2) {
   return async (rel) => {
-    const entries = await readdir2(path7.join(cwd2, rel), { withFileTypes: true });
+    const entries = await readdir3(path7.join(cwd2, rel), { withFileTypes: true });
     return entries.map((e) => ({ name: e.name, isFile: e.isFile(), isDirectory: e.isDirectory() }));
   };
 }
@@ -101302,11 +101912,11 @@ var init_node_read_dir = __esm({
 });
 
 // src/editor/node-mentions.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import path8 from "node:path";
 async function readGitignore(cwd2) {
   try {
-    return createGitignoreMatcher(await readFile3(path8.join(cwd2, ".gitignore"), "utf8"));
+    return createGitignoreMatcher(await readFile4(path8.join(cwd2, ".gitignore"), "utf8"));
   } catch (err) {
     if (err.code === "ENOENT") return () => false;
     throw err;
@@ -101320,7 +101930,7 @@ function createNodeMentions(cwd2) {
       return formatMentionPrompt(text, result);
     },
     async list() {
-      return listFiles(createNodeReadDir(cwd2), { ignored: await readGitignore(cwd2) });
+      return listFiles2(createNodeReadDir(cwd2), { ignored: await readGitignore(cwd2) });
     }
   };
 }
@@ -101336,89 +101946,48 @@ var init_node_mentions = __esm({
   }
 });
 
-// src/import-gate.ts
-import { createHash, randomUUID } from "node:crypto";
-import { chmod as chmod3, mkdir as mkdir3, readFile as readFile4, readdir as readdir3, realpath as realpath2, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join4 } from "node:path";
-async function readOrNull(path12) {
-  try {
-    return await readFile4(path12, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-}
-async function writeTextAtomic(path12, text) {
-  await mkdir3(dirname3(path12), { recursive: true });
-  const tmp = `${path12}.${process.pid}.${randomUUID()}.tmp`;
-  await writeFile3(tmp, text, { mode: 384 });
-  await chmod3(tmp, 384);
-  await rename3(tmp, path12);
-}
-async function readRepoSources(cwd2) {
-  const files = {};
-  for (const name of REPO_SOURCE_FILES) {
-    const text = await readOrNull(join4(cwd2, name));
-    if (text !== null) files[name] = text;
-  }
-  let entries = [];
-  try {
-    entries = await readdir3(join4(cwd2, ".claude", "commands"));
-  } catch (err) {
-    if (err.code !== "ENOENT" && err.code !== "ENOTDIR") throw err;
-  }
-  for (const e of entries.filter((x2) => x2.endsWith(".md")).sort()) {
-    const text = await readOrNull(join4(cwd2, ".claude", "commands", e));
-    if (text !== null) files[`.claude/commands/${e}`] = text;
-  }
-  return files;
-}
-function nodeTrustFs() {
-  return { readText: readOrNull, writeTextAtomic, realPath: (p) => realpath2(p) };
-}
-function createNodeTrustStore(configDir) {
-  return new TrustStore({ fs: nodeTrustFs(), path: join4(configDir, "trust.json"), hash: sha256 });
-}
-async function importGateStatus(deps) {
-  const lines2 = [];
-  const configPath = join4(deps.configDir, "imports.json");
-  try {
-    const loaded = parseImportsConfig(await readOrNull(configPath), configPath);
-    if (loaded.error) lines2.push(`imports: ${loaded.error} (every category off)`);
-    else {
-      const on = IMPORT_CATEGORIES.filter((c) => loaded.config.categories[c]);
-      lines2.push(on.length ? `imports: on for ${on.join(", ")}` : "imports: every category off (default)");
-    }
-  } catch (err) {
-    lines2.push(`imports: not read (${err instanceof Error ? err.message : String(err)}); every category off`);
-  }
-  try {
-    const files = await readRepoSources(deps.cwd);
-    const found = Object.keys(files);
-    if (found.length === 0) return lines2;
-    const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, files);
-    const names = found.join(", ");
-    if (status === "trusted" || status === "session") lines2.push(`repo sources: ${names} (trusted${status === "session" ? " for this session" : ""})`);
-    else if (status === "never") lines2.push(`repo sources: ${names} NOT loaded (marked never trust)`);
-    else lines2.push(`repo sources: ${names} NOT loaded (untrusted${deps.interactive ? "" : ", non-interactive run"})`);
-  } catch (err) {
-    lines2.push(`repo sources: NOT loaded (trust check failed: ${err instanceof Error ? err.message : String(err)})`);
+// src/skills-command.ts
+async function runSkillsCommand(args, deps) {
+  const [sub, name, file] = args.trim().split(/\s+/);
+  if (!deps.source) return `Skills are not available.
+${deps.statusLines.map((l) => `  ${l}`).join("\n")}`;
+  const all = await deps.source.list();
+  if (!sub) {
+    if (all.length === 0) return "No imported skills.";
+    return `Imported skills:
+${all.map((s) => `  ${s.name}  (${s.scope}${s.scripts ? ", ships scripts: not runnable until permitted" : ""})  ${s.description}`).join("\n")}
+
+Skills are loaded on demand with the skill tool; bodies are not in the prompt. /skills show <name> [file], /skills delete <name>.`;
+  }
+  if (sub === "show") {
+    if (!name) return "Usage: /skills show <name> [file]";
+    const text = file ? await deps.source.file(name, file) : await deps.source.body(name);
+    return text ?? `No ${file ? `file "${file}" in skill` : "skill named"} "${name}".`;
+  }
+  if (sub === "delete") {
+    if (!name) return "Usage: /skills delete <name>";
+    const skill = all.find((s) => s.name === name);
+    if (!skill) return `No skill named "${name}".`;
+    if (skill.scope === "repo") return `"${name}" is a repo skill (${".claude/skills"}); delete it from the repo, not the profile.`;
+    if (!deps.client) return "Not signed in: cannot delete from the profile.";
+    const assets = ((await deps.client.index())?.assets ?? []).filter(
+      (a) => a.kind === "skill" && (a.name === name || a.name.startsWith(`${name}.`) && a.description.startsWith(SIBLING_PREFIX))
+    );
+    for (const a of assets) await deps.client.delete("skill", a.name);
+    return `Deleted skill "${name}" and ${assets.length - 1} file(s) from the profile. Re-running import-claude would import it again.`;
   }
-  return lines2;
+  return "Usage: /skills | /skills show <name> [file] | /skills delete <name>";
 }
-var REPO_SOURCE_FILES, sha256;
-var init_import_gate = __esm({
-  "src/import-gate.ts"() {
+var init_skills_command = __esm({
+  "src/skills-command.ts"() {
     "use strict";
     init_src();
-    REPO_SOURCE_FILES = [".mcp.json", ".claude/settings.json", ".claude/settings.local.json", "CLAUDE.local.md"];
-    sha256 = (text) => createHash("sha256").update(text).digest("hex");
   }
 });
 
 // src/permission-rules-loader.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function readOrNull2(path12) {
   try {
     return await readFile5(path12, "utf8");
@@ -101429,7 +101998,7 @@ async function readOrNull2(path12) {
 }
 async function loadPermissionRules(deps) {
   const none = (line) => ({ rules: void 0, defaultMode: void 0, statusLines: [line] });
-  const configPath = join5(deps.configDir, "imports.json");
+  const configPath = join6(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await readOrNull2(configPath), configPath);
     if (loaded.error) return none("permission rules: off (imports.json unreadable)");
@@ -101438,13 +102007,13 @@ async function loadPermissionRules(deps) {
     return none(`permission rules: off (imports.json not read: ${err instanceof Error ? err.message : String(err)})`);
   }
   const lines2 = [];
-  const files = [{ scope: "user", path: join5(deps.homeDir, ".claude", "settings.json") }];
+  const files = [{ scope: "user", path: join6(deps.homeDir, ".claude", "settings.json") }];
   try {
     const sources2 = await readRepoSources(deps.cwd);
     if (sources2[".claude/settings.json"] !== void 0 || sources2[".claude/settings.local.json"] !== void 0) {
       const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, sources2);
       if (status === "trusted" || status === "session") {
-        files.push({ scope: "repo", path: join5(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join5(deps.cwd, ".claude", "settings.local.json") });
+        files.push({ scope: "repo", path: join6(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join6(deps.cwd, ".claude", "settings.local.json") });
       } else lines2.push(`permission rules: repo settings NOT loaded (${status === "never" ? "marked never trust" : "untrusted repo"})`);
     }
   } catch (err) {
@@ -101486,7 +102055,7 @@ var init_permission_rules_loader = __esm({
 });
 
 // src/command-loader.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 async function userCommands(deps, lines2) {
   try {
     const apiKey = await resolveApiKey({ env: deps.env, readFile: deps.readFile, homedir: deps.homedir });
@@ -101541,7 +102110,7 @@ async function repoCommands(deps, lines2) {
   }
 }
 async function loadCommands(deps) {
-  const configPath = join6(deps.configDir, "imports.json");
+  const configPath = join7(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await deps.readFile(configPath).catch((err) => {
       if (err.code === "ENOENT") return null;
@@ -101576,7 +102145,7 @@ var init_command_loader = __esm({
 // src/useReplController.ts
 import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir4 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mentionsOpt, sessions, resumeLatest: resumeLatest2, onViewTurns, onViewResume, isEscOwned }) {
   const { exit } = use_app_default();
@@ -101623,7 +102192,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   (0, import_react30.useEffect)(() => {
     let live = true;
     loadCommands({
-      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join7(homedir2(), ".spacecode"),
+      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join8(homedir2(), ".spacecode"),
       cwd: process.cwd(),
       env: process.env,
       readFile: (p) => readFile6(p, "utf-8"),
@@ -101954,6 +102523,13 @@ ${commandsLoaded.statusLines.map((l) => `  ${l}`).join("\n")}`.trim() : `Importe
 ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.description}` : ""}`).join("\n")}`);
           return;
         }
+        case "skills": {
+          const state = profileRef.current;
+          const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile6(p, "utf-8"), homedir: homedir2 }).catch(() => null);
+          const client = apiKey2 ? createProfileClient({ baseUrl: backendUrl(process.env), apiKey: apiKey2, fetch }) : null;
+          notice(await runSkillsCommand(slash.args, { source: state?.skills ?? null, client, statusLines: state?.statusLines.filter((l) => l.startsWith("skills")) ?? ["skills: not loaded yet (loads on your first message)"] }));
+          return;
+        }
         case "tools": {
           const tools = toolsetRef.current?.tools ?? createLocalToolset({ cwd: process.cwd(), permissions, onTodos: setTodos }).tools;
           notice(`Tools:
@@ -102016,7 +102592,7 @@ ${tools.map((t) => `  ${t.name}`).join("\n")}`);
         cwd: process.cwd(),
         gitRoot: gitTopLevel,
         importGate: async () => {
-          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join7(homedir2(), ".spacecode");
+          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join8(homedir2(), ".spacecode");
           const gate = await importGateStatus({ configDir, cwd: process.cwd(), interactive: Boolean(process.stdin.isTTY) });
           const loaded = await loadPermissionRules({ configDir, homeDir: homedir2(), cwd: process.cwd() });
           rulesRef.current = loaded.rules;
@@ -102149,6 +102725,8 @@ var init_useReplController = __esm({
     init_node_mentions();
     init_api_key();
     init_profile_runtime();
+    init_skills_command();
+    init_src();
     init_import_gate();
     init_permission_rules_loader();
     init_command_loader();
@@ -102772,6 +103350,40 @@ var rawCount = process.env.LAUNCH_COUNT ? parseInt(process.env.LAUNCH_COUNT, 10)
 var launchCount = rawCount !== void 0 && Number.isNaN(rawCount) ? void 0 : rawCount;
 var yolo = process.argv.includes("--yolo");
 var resumeLatest = process.argv.includes("--continue");
+if (process.stdin.isTTY && process.stdout.isTTY) {
+  try {
+    const { readRepoSources: readRepoSources2, createNodeTrustStore: createNodeTrustStore2 } = await Promise.resolve().then(() => (init_import_gate(), import_gate_exports));
+    const { promptRepoTrust: promptRepoTrust2 } = await Promise.resolve().then(() => (init_repo_trust_prompt(), repo_trust_prompt_exports));
+    const files = await readRepoSources2(process.cwd());
+    if (Object.keys(files).length > 0) {
+      const store = createNodeTrustStore2(process.env.SPACECODE_CONFIG_DIR?.trim() || path11.join(os5.homedir(), ".spacecode"));
+      if (await store.repoStatus(process.cwd(), files) === "untrusted") {
+        const { createInterface } = await import("node:readline/promises");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+          const decision = await promptRepoTrust2(process.cwd(), files, {
+            write: (t) => {
+              process.stdout.write(t);
+            },
+            ask: async (q2) => {
+              try {
+                return await rl.question(q2);
+              } catch {
+                return null;
+              }
+            }
+          });
+          if (decision !== "skip") await store.setRepo(process.cwd(), files, decision);
+        } finally {
+          rl.close();
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`Repo trust check failed (${err instanceof Error ? err.message : String(err)}); repo sources stay untrusted.
+`);
+  }
+}
 var restoreCiVariables = hideCiVariables(process.env, Boolean(process.stdout.isTTY));
 var render2;
 var App3;