lshed 0.3.0 → 0.6.0

package/dist/cli.js

@@ -3,12 +3,12 @@
 // src/cli.ts
 import { Command } from "commander";
 import { createRequire } from "module";
-import os2 from "os";
-import path15 from "path";
+import os3 from "os";
+import path19 from "path";
 
 // src/adapters/claude-code.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
+import { promises as fs4 } from "fs";
+import path4 from "path";
 import os from "os";
 
 // src/installers/claude-plugin.ts
@@ -166,79 +166,14 @@ var pluginInstaller = {
   }
 };
 
-// src/adapters/claude-code.ts
-var CATEGORIES = [
-  { name: "skills", root: "skills", kind: "dir" },
-  { name: "agents", root: "agents", kind: "file" },
-  { name: "commands", root: "commands", kind: "file" }
-  // instructions 는 단일 파일(CLAUDE.md)이라 스캔 대상이 아니라 생성 대상이다 (§3.3)
-];
-var ClaudeCodeAdapter = class {
-  name = "claude-code";
-  root;
-  constructor(root) {
-    this.root = root ?? path2.join(os.homedir(), ".claude");
-  }
-  categories() {
-    return CATEGORIES;
-  }
-  instructionsStrategy() {
-    return "import";
-  }
-  instructionsFileName() {
-    return "CLAUDE.md";
-  }
-  installers() {
-    return [marketplaceInstaller, pluginInstaller];
-  }
-  async scan() {
-    const out = [];
-    for (const cat of CATEGORIES) {
-      const dir = path2.join(this.root, cat.root);
-      let entries;
-      try {
-        entries = await fs2.readdir(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const e of entries) {
-        if (e.name.startsWith(".")) continue;
-        const full = path2.join(dir, e.name);
-        let st;
-        try {
-          st = await fs2.stat(full);
-        } catch {
-          continue;
-        }
-        if (cat.kind === "dir" && st.isDirectory()) {
-          out.push({ category: cat.name, id: e.name, path: full });
-        } else if (cat.kind === "file" && st.isFile() && e.name.endsWith(".md")) {
-          out.push({ category: cat.name, id: e.name.slice(0, -3), path: full });
-        }
-      }
-    }
-    return out;
-  }
-};
-
-// src/core/context.ts
-import { promises as fs6 } from "fs";
-import path8 from "path";
-import { spawn as spawn2 } from "child_process";
-
-// src/installers/git.ts
-import { promises as fs4 } from "fs";
-import path5 from "path";
-
-// src/git.ts
-import { execFile, spawn } from "child_process";
-import { promisify } from "util";
-import path4 from "path";
+// src/adapters/claude-mcp.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
 
 // src/fsutil.ts
-import { promises as fs3 } from "fs";
+import { promises as fs2 } from "fs";
 import { createHash } from "crypto";
-import path3 from "path";
+import path2 from "path";
 
 // src/ignore.ts
 var DEFAULT_IGNORE = [
@@ -263,7 +198,7 @@ function isIgnored(rel, patterns) {
 // src/fsutil.ts
 async function exists(p) {
   try {
-    await fs3.access(p);
+    await fs2.access(p);
     return true;
   } catch {
     return false;
@@ -271,7 +206,7 @@ async function exists(p) {
 }
 async function isDir(p) {
   try {
-    return (await fs3.stat(p)).isDirectory();
+    return (await fs2.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -280,48 +215,48 @@ async function listFiles(root, ignore = DEFAULT_IGNORE) {
   if (!await exists(root)) return [];
   if (!await isDir(root)) return [""];
   const out = [];
-  async function walk(dir, rel) {
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
+  async function walk2(dir, rel) {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
       const r = rel ? `${rel}/${e.name}` : e.name;
       if (isIgnored(r, ignore)) continue;
-      const full = path3.join(dir, e.name);
+      const full = path2.join(dir, e.name);
       let st;
       try {
-        st = await fs3.stat(full);
+        st = await fs2.stat(full);
       } catch {
         continue;
       }
-      if (st.isDirectory()) await walk(full, r);
+      if (st.isDirectory()) await walk2(full, r);
       else if (st.isFile()) out.push(r);
     }
   }
-  await walk(root, "");
+  await walk2(root, "");
   return out.sort();
 }
 async function hashFile(p) {
-  return createHash("sha256").update(await fs3.readFile(p)).digest("hex");
+  return createHash("sha256").update(await fs2.readFile(p)).digest("hex");
 }
 async function hashTree(root, ignore = DEFAULT_IGNORE) {
   if (!await exists(root)) return null;
   const h = createHash("sha256");
   for (const rel of await listFiles(root, ignore)) {
-    h.update(rel).update("\0").update(await fs3.readFile(rel ? path3.join(root, rel) : root)).update("\0");
+    h.update(rel).update("\0").update(await fs2.readFile(rel ? path2.join(root, rel) : root)).update("\0");
   }
   return h.digest("hex");
 }
 async function copyTree(src, dst, ignore = DEFAULT_IGNORE) {
-  await fs3.rm(dst, { recursive: true, force: true });
-  await fs3.mkdir(path3.dirname(dst), { recursive: true });
-  const srcRoot = path3.resolve(src);
-  await fs3.cp(src, dst, {
+  await fs2.rm(dst, { recursive: true, force: true });
+  await fs2.mkdir(path2.dirname(dst), { recursive: true });
+  const srcRoot = path2.resolve(src);
+  await fs2.cp(src, dst, {
     recursive: true,
     dereference: true,
     filter: async (from) => {
-      const rel = path3.relative(srcRoot, path3.resolve(from)).split(path3.sep).join("/");
+      const rel = path2.relative(srcRoot, path2.resolve(from)).split(path2.sep).join("/");
       if (isIgnored(rel, ignore)) return false;
       try {
-        if ((await fs3.lstat(from)).isSymbolicLink()) await fs3.stat(from);
+        if ((await fs2.lstat(from)).isSymbolicLink()) await fs2.stat(from);
       } catch {
         return false;
       }
@@ -330,15 +265,15 @@ async function copyTree(src, dst, ignore = DEFAULT_IGNORE) {
   });
 }
 async function removeTree(p) {
-  await fs3.rm(p, { recursive: true, force: true });
+  await fs2.rm(p, { recursive: true, force: true });
 }
 async function diffTrees(local, shed, ignore = DEFAULT_IGNORE) {
   const l = new Set(await listFiles(local, ignore));
   const s = new Set(await listFiles(shed, ignore));
   const out = [];
   for (const f of [.../* @__PURE__ */ new Set([...l, ...s])].sort()) {
-    const lp = f ? path3.join(local, f) : local;
-    const sp = f ? path3.join(shed, f) : shed;
+    const lp = f ? path2.join(local, f) : local;
+    const sp = f ? path2.join(shed, f) : shed;
     if (l.has(f) && !s.has(f)) out.push({ status: "A", file: f });
     else if (!l.has(f) && s.has(f)) out.push({ status: "D", file: f });
     else if (await hashFile(lp) !== await hashFile(sp)) out.push({ status: "M", file: f });
@@ -346,13 +281,127 @@ async function diffTrees(local, shed, ignore = DEFAULT_IGNORE) {
   return out;
 }
 
+// src/adapters/claude-mcp.ts
+var ClaudeMcpEntries = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  name = "mcp";
+  kind = "entry";
+  secretKeys = ["env", "headers"];
+  expandsEnv = true;
+  /** ~/.claude 의 형제 ~/.claude.json. CLAUDE_CONFIG_DIR 처럼 루트 안에 있으면 그것을 쓴다. */
+  async file() {
+    const inside = path3.join(this.root, ".claude.json");
+    return await exists(inside) ? inside : `${this.root}.json`;
+  }
+  async load() {
+    const p = await this.file();
+    try {
+      return JSON.parse(await fs3.readFile(p, "utf8"));
+    } catch (e) {
+      if (e.code === "ENOENT") return {};
+      throw new Error(`${p} \uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${e.message}`);
+    }
+  }
+  async read() {
+    const servers = (await this.load()).mcpServers;
+    return servers && typeof servers === "object" ? { ...servers } : {};
+  }
+  async write(id, value) {
+    const p = await this.file();
+    const all = await this.load();
+    const servers = { ...all.mcpServers ?? {} };
+    if (value === null) delete servers[id];
+    else servers[id] = value;
+    all.mcpServers = servers;
+    await fs3.mkdir(path3.dirname(p), { recursive: true });
+    const tmp = `${p}.lshed-${process.pid}.tmp`;
+    await fs3.writeFile(tmp, JSON.stringify(all, null, 2) + "\n");
+    await fs3.rename(tmp, p);
+  }
+};
+
+// src/adapters/claude-code.ts
+var CATEGORIES = [
+  { name: "skills", root: "skills", kind: "dir" },
+  { name: "agents", root: "agents", kind: "file" },
+  { name: "commands", root: "commands", kind: "file" }
+  // instructions 는 단일 파일(CLAUDE.md)이라 스캔 대상이 아니라 생성 대상이다 (§3.3)
+];
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  root;
+  mcp;
+  constructor(root) {
+    this.root = root ?? process.env.CLAUDE_CONFIG_DIR ?? path4.join(os.homedir(), ".claude");
+    this.mcp = new ClaudeMcpEntries(this.root);
+  }
+  entries() {
+    return [this.mcp];
+  }
+  categories() {
+    return CATEGORIES;
+  }
+  instructionsStrategy() {
+    return "import";
+  }
+  instructionsFileName() {
+    return "CLAUDE.md";
+  }
+  installers() {
+    return [marketplaceInstaller, pluginInstaller];
+  }
+  async scan() {
+    const out = [];
+    for (const cat of CATEGORIES) {
+      const dir = path4.join(this.root, cat.root);
+      let entries;
+      try {
+        entries = await fs4.readdir(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        if (e.name.startsWith(".")) continue;
+        const full = path4.join(dir, e.name);
+        let st;
+        try {
+          st = await fs4.stat(full);
+        } catch {
+          continue;
+        }
+        if (cat.kind === "dir" && st.isDirectory()) {
+          out.push({ category: cat.name, id: e.name, path: full });
+        } else if (cat.kind === "file" && st.isFile() && e.name.endsWith(".md")) {
+          out.push({ category: cat.name, id: e.name.slice(0, -3), path: full });
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/core/context.ts
+import { promises as fs7 } from "fs";
+import path9 from "path";
+import { spawn as spawn2 } from "child_process";
+
+// src/installers/git.ts
+import { promises as fs5 } from "fs";
+import path6 from "path";
+
 // src/git.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import path5 from "path";
 var x = promisify(execFile);
 async function git(args, cwd) {
   const { stdout } = await x("git", args, { cwd, maxBuffer: 1 << 24 });
   return stdout.trim();
 }
-var isRepo = (dir) => exists(path4.join(dir, ".git"));
+var isRepo = (dir) => exists(path5.join(dir, ".git"));
 var remoteUrl = (dir) => git(["remote", "get-url", "origin"], dir).catch(() => null);
 var head = (dir) => git(["rev-parse", "HEAD"], dir);
 var branch = async (dir) => {
@@ -373,7 +422,7 @@ function runShell(cmd, cwd) {
 // src/installers/git.ts
 function dirOf(ctx, pkg) {
   if (!pkg.into) throw new Error(`package ${pkg.id}: git \uACC4\uC5F4 \uD328\uD0A4\uC9C0\uB294 into \uAC00 \uD544\uC694\uD569\uB2C8\uB2E4`);
-  return path5.join(ctx.adapter.root, ...pkg.into.split("/"));
+  return path6.join(ctx.adapter.root, ...pkg.into.split("/"));
 }
 var gitInstaller = {
   name: "git",
@@ -385,7 +434,7 @@ var gitInstaller = {
       if (!await isRepo(f.path)) continue;
       const url = await remoteUrl(f.path);
       if (!url) continue;
-      const into = path5.relative(ctx.adapter.root, f.path).split(path5.sep).join("/");
+      const into = path6.relative(ctx.adapter.root, f.path).split(path6.sep).join("/");
       out.push({ id: f.id, into, source: sourceFromRemote(url, await branch(f.path)), rev: await head(f.path), path: f.path });
     }
     return out;
@@ -399,7 +448,7 @@ var gitInstaller = {
     const dir = dirOf(ctx, pkg);
     if (await exists(dir)) throw new Error(`package ${pkg.id}: ${dir} \uAC00 \uC788\uC9C0\uB9CC git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4. \uCE58\uC6B0\uAC70\uB098 into \uB97C \uBC14\uAFB8\uC138\uC694.`);
     const { url, ref } = cloneTarget(parseSource(pkg.source));
-    await fs4.mkdir(path5.dirname(dir), { recursive: true });
+    await fs5.mkdir(path6.dirname(dir), { recursive: true });
     await clone(url, dir, ref);
     if (locked) {
       await resetHard(dir, locked).catch(() => {
@@ -444,6 +493,8 @@ var ManifestSchema = z.object({
   agent: z.string().default("claude-code"),
   /** 창고에 담지 않을 이름들. 기본값(DEFAULT_IGNORE)에 더해진다. */
   ignore: z.array(z.string()).optional(),
+  /** 로컬에 있어도 창고에 넣지 않을 부품 ("id" 또는 "category/id"). init --exclude 가 적고 add/status 가 따른다. */
+  exclude: z.array(z.string()).optional(),
   components: ComponentsSchema.default({}),
   packages: z.array(PackageSchema).default([]),
   profiles: z.record(z.string(), ProfileSchema).default({})
@@ -506,13 +557,8 @@ ${problems.map((p) => "  " + p).join("\n")}`);
   return m;
 }
 function effectiveSource(category, c, kind = "dir") {
-  return c.source ?? `file:./${category}/${c.id}${kind === "file" ? ".md" : ""}`;
-}
-function stringifyManifest(m) {
-  const out = { ...m };
-  if (!m.packages.length) delete out.packages;
-  if (!m.ignore?.length) delete out.ignore;
-  return YAML.stringify(out, { lineWidth: 0 });
+  const ext = kind === "file" ? ".md" : kind === "entry" ? ".json" : "";
+  return c.source ?? `file:./${category}/${c.id}${ext}`;
 }
 function packagesOf(m, profile) {
   const ids = m.profiles[profile]?.[PACKAGES] ?? [];
@@ -520,10 +566,10 @@ function packagesOf(m, profile) {
 }
 
 // src/resolvers/file.ts
-import path6 from "path";
+import path7 from "path";
 function resolveSource(shed, raw) {
   const s = parseSource(raw);
-  if (s.scheme === "file") return path6.resolve(shed, s.path);
+  if (s.scheme === "file") return path7.resolve(shed, s.path);
   throw new Error(`"${raw}": ${s.scheme}: \uCD9C\uCC98\uB294 v0.2\uC5D0\uC11C \uC9C0\uC6D0\uB429\uB2C8\uB2E4. \uC9C0\uAE08\uC740 file: \uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`);
 }
 function isSaveable(raw) {
@@ -531,8 +577,8 @@ function isSaveable(raw) {
 }
 
 // src/state.ts
-import { promises as fs5 } from "fs";
-import path7 from "path";
+import { promises as fs6 } from "fs";
+import path8 from "path";
 import { z as z2 } from "zod";
 var StateSchema = z2.object({
   profile: z2.string(),
@@ -543,11 +589,11 @@ var StateSchema = z2.object({
 });
 var LSHED_DIR = "lshed";
 function statePath(adapter) {
-  return path7.join(adapter.root, LSHED_DIR, "state.json");
+  return path8.join(adapter.root, LSHED_DIR, "state.json");
 }
 async function readState(adapter) {
   try {
-    const raw = JSON.parse(await fs5.readFile(statePath(adapter), "utf8"));
+    const raw = JSON.parse(await fs6.readFile(statePath(adapter), "utf8"));
     return StateSchema.parse(raw);
   } catch (e) {
     if (e.code === "ENOENT") return null;
@@ -556,8 +602,8 @@ async function readState(adapter) {
 }
 async function writeState(adapter, state) {
   const p = statePath(adapter);
-  await fs5.mkdir(path7.dirname(p), { recursive: true });
-  await fs5.writeFile(p, JSON.stringify(state, null, 2) + "\n");
+  await fs6.mkdir(path8.dirname(p), { recursive: true });
+  await fs6.writeFile(p, JSON.stringify(state, null, 2) + "\n");
 }
 
 // src/core/context.ts
@@ -582,15 +628,15 @@ var MANIFEST_FILE = "lshed.yaml";
 var INSTRUCTIONS = "instructions";
 var FRAGMENTS_DIR = `${LSHED_DIR}/instructions`;
 function manifestPath(ctx) {
-  return path8.join(ctx.shed, MANIFEST_FILE);
+  return path9.join(ctx.shed, MANIFEST_FILE);
 }
 function knownCategories(adapter) {
-  return [...adapter.categories().map((c) => c.name), INSTRUCTIONS];
+  return [...adapter.categories().map((c) => c.name), ...adapter.entries().map((e) => e.name), INSTRUCTIONS];
 }
 async function loadManifest(ctx) {
   let text;
   try {
-    text = await fs6.readFile(manifestPath(ctx), "utf8");
+    text = await fs7.readFile(manifestPath(ctx), "utf8");
   } catch {
     throw new Error(`\uCC3D\uACE0\uC5D0 ${MANIFEST_FILE} \uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${ctx.shed}
   \uBA3C\uC800 'lshed init --shed ${ctx.shed}' \uB97C \uC2E4\uD589\uD558\uC138\uC694.`);
@@ -604,12 +650,22 @@ function ignoreOf(ctx) {
 }
 function targetRel(cat, id) {
   if (cat === INSTRUCTIONS) return `${FRAGMENTS_DIR}/${id}.md`;
+  if (cat.kind === "entry") return `${cat.name}:${id}`;
   return cat.kind === "dir" ? `${cat.root}/${id}` : `${cat.root}/${id}.md`;
 }
+function entryOf(ctx, rel) {
+  const i = rel.indexOf(":");
+  if (i <= 0) return void 0;
+  const cat = ctx.adapter.entries().find((e) => e.name === rel.slice(0, i));
+  return cat ? { cat, id: rel.slice(i + 1) } : void 0;
+}
+function kindOf(ctx, category) {
+  if (category === INSTRUCTIONS) return "file";
+  if (ctx.adapter.entries().some((e) => e.name === category)) return "entry";
+  return ctx.adapter.categories().find((k) => k.name === category)?.kind ?? "dir";
+}
 function sourcePath(ctx, category, c) {
-  const cat = ctx.adapter.categories().find((k) => k.name === category);
-  const kind = category === INSTRUCTIONS ? "file" : cat?.kind ?? "dir";
-  return resolveSource(ctx.shed, effectiveSource(category, c, kind));
+  return resolveSource(ctx.shed, effectiveSource(category, c, kindOf(ctx, category)));
 }
 function findComponent(m, category, id) {
   const c = (m.components[category] ?? []).find((x2) => x2.id === id);
@@ -625,28 +681,30 @@ function planProfile(ctx, m, profile) {
   const items = [];
   for (const [category, ids] of Object.entries(p)) {
     if (category === PACKAGES) continue;
-    const cat = category === INSTRUCTIONS ? INSTRUCTIONS : ctx.adapter.categories().find((k) => k.name === category);
+    const cat = category === INSTRUCTIONS ? INSTRUCTIONS : ctx.adapter.categories().find((k) => k.name === category) ?? ctx.adapter.entries().find((e) => e.name === category);
     if (!cat) throw new Error(`\uD504\uB85C\uD544 "${profile}": \uC5B4\uB311\uD130 ${ctx.adapter.name} \uC740 \uCE74\uD14C\uACE0\uB9AC "${category}" \uB97C \uBAA8\uB985\uB2C8\uB2E4`);
+    const entry = cat !== INSTRUCTIONS && cat.kind === "entry" ? cat : void 0;
     for (const id of ids) {
       const component = findComponent(m, category, id);
-      items.push({ category, id, rel: targetRel(cat, id), src: sourcePath(ctx, category, component), component });
+      items.push({ category, id, rel: targetRel(cat, id), src: sourcePath(ctx, category, component), component, entry });
     }
   }
   return items;
 }
 function abs(ctx, rel) {
-  return path8.join(ctx.adapter.root, ...rel.split("/"));
+  return path9.join(ctx.adapter.root, ...rel.split("/"));
 }
 
 // src/core/init.ts
-import { promises as fs9 } from "fs";
-import path12 from "path";
+import { promises as fs11 } from "fs";
+import path16 from "path";
+import YAML4 from "yaml";
 
 // src/core/instructions.ts
-import path9 from "path";
+import path10 from "path";
 var MARKER = "<!-- generated by lshed";
 function instructionsFile(ctx) {
-  return path9.join(ctx.adapter.root, ctx.adapter.instructionsFileName());
+  return path10.join(ctx.adapter.root, ctx.adapter.instructionsFileName());
 }
 function isGenerated(text) {
   return text.trimStart().startsWith(MARKER);
@@ -664,13 +722,9 @@ ${f.content.trimEnd()}
 `).join("\n");
 }
 
-// src/core/packages.ts
+// src/lock.ts
 import { promises as fs8 } from "fs";
 import path11 from "path";
-
-// src/lock.ts
-import { promises as fs7 } from "fs";
-import path10 from "path";
 import YAML2 from "yaml";
 import { z as z3 } from "zod";
 var EntrySchema = z3.object({ source: z3.string(), rev: z3.string().optional(), commit: z3.string().optional() }).transform((e) => ({ source: e.source, rev: e.rev ?? e.commit ?? "" }));
@@ -681,7 +735,7 @@ var LockSchema = z3.object({
 var LOCK_FILE = "lshed.lock";
 async function readLock(shed) {
   try {
-    return LockSchema.parse(YAML2.parse(await fs7.readFile(path10.join(shed, LOCK_FILE), "utf8")));
+    return LockSchema.parse(YAML2.parse(await fs8.readFile(path11.join(shed, LOCK_FILE), "utf8")));
   } catch (e) {
     if (e.code === "ENOENT") return { version: 1, packages: {} };
     throw new Error(`${LOCK_FILE} \uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${e.message}`);
@@ -689,10 +743,15 @@ async function readLock(shed) {
 }
 async function writeLock(shed, lock) {
   const sorted = { version: 1, packages: Object.fromEntries(Object.entries(lock.packages).sort()) };
-  await fs7.writeFile(path10.join(shed, LOCK_FILE), "# generated by lshed \u2014 do not edit; 'lshed update' refreshes it\n" + YAML2.stringify(sorted));
+  await fs8.writeFile(path11.join(shed, LOCK_FILE), "# generated by lshed \u2014 do not edit; 'lshed update' refreshes it\n" + YAML2.stringify(sorted));
 }
 
+// src/core/discover.ts
+import path13 from "path";
+
 // src/core/packages.ts
+import { promises as fs9 } from "fs";
+import path12 from "path";
 async function detectPackages(ctx, found) {
   const out = [];
   for (const inst of installersFor(ctx)) out.push(...await inst.detect(ctx, found));
@@ -702,26 +761,26 @@ async function detectGenerated(found, pkgs) {
   const out = /* @__PURE__ */ new Map();
   const located = pkgs.filter((p) => p.path);
   if (!located.length) return out;
-  const roots = await Promise.all(located.map(async (p) => ({ id: p.id, real: await fs8.realpath(p.path) })));
+  const roots = await Promise.all(located.map(async (p) => ({ id: p.id, real: await fs9.realpath(p.path) })));
   for (const f of found) {
     if (located.some((p) => p.path === f.path)) continue;
     let entries;
     try {
-      if (!(await fs8.stat(f.path)).isDirectory()) continue;
-      entries = await fs8.readdir(f.path);
+      if (!(await fs9.stat(f.path)).isDirectory()) continue;
+      entries = await fs9.readdir(f.path);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const p = path11.join(f.path, name);
+      const p = path12.join(f.path, name);
       let target;
       try {
-        if (!(await fs8.lstat(p)).isSymbolicLink()) continue;
-        target = await fs8.realpath(p).catch(async () => path11.resolve(f.path, await fs8.readlink(p)));
+        if (!(await fs9.lstat(p)).isSymbolicLink()) continue;
+        target = await fs9.realpath(p).catch(async () => path12.resolve(f.path, await fs9.readlink(p)));
       } catch {
         continue;
       }
-      const owner = roots.find((r) => target === r.real || target.startsWith(r.real + path11.sep));
+      const owner = roots.find((r) => target === r.real || target.startsWith(r.real + path12.sep));
       if (owner) {
         out.set(`${f.category}/${f.id}`, owner.id);
         break;
@@ -766,7 +825,7 @@ async function ensurePackages(ctx, pkgs, opts = {}) {
 async function maybeInstall(ctx, pkg, dir, opts, res) {
   if (!pkg.install) return;
   if (opts.yes) {
-    ctx.log(`  $ (${path11.relative(ctx.adapter.root, dir) || "."}) ${pkg.install}`);
+    ctx.log(`  $ (${path12.relative(ctx.adapter.root, dir) || "."}) ${pkg.install}`);
     await runShell(pkg.install, dir);
   } else {
     res.pendingInstalls.push({ id: pkg.id, dir, cmd: pkg.install });
@@ -807,93 +866,296 @@ async function updatePackages(ctx, pkgs, opts = {}) {
   return res;
 }
 
-// src/core/init.ts
-async function init(ctx, opts = {}) {
-  const profileName = opts.profile ?? "default";
-  const exclude = opts.exclude ?? [];
-  const skipped = [];
-  if (await exists(manifestPath(ctx))) {
-    throw new Error(`\uC774\uBBF8 \uCD08\uAE30\uD654\uB41C \uCC3D\uACE0\uC785\uB2C8\uB2E4: ${manifestPath(ctx)}
-  \uB2E4\uB978 \uD658\uACBD\uC758 \uC124\uC815\uC744 \uC774 \uCC3D\uACE0\uB85C \uAC00\uC838\uC624\uB824\uBA74 'lshed restore' \uD6C4 'lshed save' \uB97C \uC4F0\uC138\uC694.`);
-  }
-  const all = await ctx.adapter.scan();
-  const m = { version: 1, agent: ctx.adapter.name, components: {}, packages: [], profiles: { [profileName]: {} } };
+// src/core/discover.ts
+var keyOf = (f) => `${f.category}/${f.id}`;
+async function discover(ctx, exclude = []) {
   const isExcluded = (cat, id) => exclude.some((e) => e === id || e === `${cat}/${id}`);
-  const pkgs = (await detectPackages(ctx, all)).filter((p) => !isExcluded("", p.id));
-  const generated = await detectGenerated(all, pkgs);
-  const found = all.filter((f) => !pkgs.some((p) => p.path === f.path) && !generated.has(`${f.category}/${f.id}`));
-  for (const p of pkgs) {
-    m.packages.push(p.into ? { id: p.id, source: p.source, into: p.into } : { id: p.id, source: p.source });
-    const rev = /^[0-9a-f]{40}$/.test(p.rev) ? p.rev.slice(0, 7) : p.rev;
-    ctx.log(`  \u2261 package ${p.id}  ${p.source} @${rev}  (\uCC38\uC870\uB9CC \uAE30\uB85D)`);
-  }
-  if (pkgs.length) m.profiles[profileName][PACKAGES] = pkgs.map((p) => p.id);
-  for (const [key, by] of generated) ctx.log(`  \xB7 ${key}  (${by} \uAC00 \uC0DD\uC131\uD55C \uAC83 \u2192 \uAC74\uB108\uB700)`);
-  const managed = [];
-  let copied = 0;
+  const excluded = [];
+  const items = [];
+  const all = await ctx.adapter.scan();
+  const pkgs = await detectPackages(ctx, all);
+  const kept = pkgs.filter((p) => {
+    if (isExcluded("packages", p.id)) {
+      excluded.push(`packages/${p.id}`);
+      return false;
+    }
+    return true;
+  });
+  const generated = await detectGenerated(all, kept);
+  for (const p of kept) items.push({ kind: "package", category: "packages", id: p.id, pkg: p });
   for (const cat of ctx.adapter.categories()) {
-    const mine = found.filter((f) => f.category === cat.name && !isExcluded(f.category, f.id));
-    for (const f of found.filter((f2) => f2.category === cat.name && isExcluded(f2.category, f2.id))) {
-      skipped.push(`${f.category}/${f.id}`);
-      ctx.log(`  - ${f.category}/${f.id}  (--exclude)`);
+    for (const f of all.filter((f2) => f2.category === cat.name)) {
+      if (pkgs.some((p) => p.path === f.path) || generated.has(keyOf(f))) continue;
+      if (isExcluded(f.category, f.id)) {
+        excluded.push(keyOf(f));
+        continue;
+      }
+      items.push({ kind: "component", category: cat.name, id: f.id, path: f.path, cat });
+    }
+  }
+  for (const cat of ctx.adapter.entries()) {
+    const all2 = await cat.read();
+    for (const id of Object.keys(all2).sort()) {
+      if (isExcluded(cat.name, id)) {
+        excluded.push(`${cat.name}/${id}`);
+        continue;
+      }
+      if (!/^[\w.-]+$/.test(id)) {
+        ctx.log(`  ! ${cat.name}/${id}: \uC774\uB984\uC5D0 \uC4F8 \uC218 \uC5C6\uB294 \uBB38\uC790\uAC00 \uC788\uC5B4 \uAC74\uB108\uB700`);
+        continue;
+      }
+      items.push({ kind: "entry", category: cat.name, id, value: all2[id], cat });
+    }
+  }
+  return { items, generated, excluded };
+}
+function notInManifest(m, d) {
+  return d.items.filter(
+    (f) => f.kind === "package" ? !m.packages.some((p) => p.id === f.id) : !(m.components[f.category] ?? []).some((c) => c.id === f.id)
+  );
+}
+function inManifestNotInProfile(m, profile, d) {
+  const p = m.profiles[profile] ?? {};
+  return d.items.filter((f) => !notInManifest(m, d).includes(f)).filter((f) => !(p[f.category] ?? []).includes(f.id)).map(keyOf);
+}
+function shortRev(rev) {
+  return /^[0-9a-f]{40}$/.test(rev) ? rev.slice(0, 7) : rev;
+}
+
+// src/core/ingest.ts
+import path15 from "path";
+import { isSeq, isMap } from "yaml";
+
+// src/core/entries.ts
+import { promises as fs10 } from "fs";
+import path14 from "path";
+var SECRET_KEY_RE = /key|token|secret|pass|auth|credential|cookie|session/i;
+var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+function placeholdersIn(v) {
+  const out = /* @__PURE__ */ new Set();
+  walk(v, (s) => {
+    for (const m of s.matchAll(PLACEHOLDER_RE)) out.add(m[1]);
+    return s;
+  });
+  return [...out];
+}
+function walk(v, onString, keyPath = []) {
+  if (typeof v === "string") return onString(v, keyPath);
+  if (Array.isArray(v)) return v.map((x2, i) => walk(x2, onString, [...keyPath, String(i)]));
+  if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x2]) => [k, walk(x2, onString, [...keyPath, k])]));
+  return v;
+}
+var envName = (...parts) => parts.join("_").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+function mask(id, entry, cat) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+  const out = { ...entry };
+  for (const sk of cat.secretKeys) {
+    const sect = out[sk];
+    if (!sect || typeof sect !== "object" || Array.isArray(sect)) continue;
+    const masked = {};
+    for (const [k, v] of Object.entries(sect)) {
+      if (typeof v !== "string" || !SECRET_KEY_RE.test(k) || PLACEHOLDER_RE.test(v)) {
+        masked[k] = v;
+        PLACEHOLDER_RE.lastIndex = 0;
+        continue;
+      }
+      const name = sk === "env" ? envName(k) : envName(id, k);
+      const scheme = /^(\w+) \S+$/.exec(v);
+      masked[k] = scheme ? `${scheme[1]} \${${name}}` : `\${${name}}`;
+    }
+    out[sk] = masked;
+  }
+  return out;
+}
+function suspiciousStrings(entry) {
+  const out = [];
+  walk(entry, (s, kp) => {
+    if (/^(sk-|ghp_|github_pat_|xox[abp]-|AKIA|glpat-|ntn_|secret_)[A-Za-z0-9_-]{8,}/.test(s)) out.push(kp.join("."));
+    return s;
+  });
+  return out;
+}
+function expand(entry, env = process.env) {
+  const missing = /* @__PURE__ */ new Set();
+  const value = walk(
+    entry,
+    (s) => s.replace(PLACEHOLDER_RE, (whole, name, def) => {
+      if (env[name] !== void 0) return env[name];
+      if (def !== void 0) return def;
+      missing.add(name);
+      return whole;
+    })
+  );
+  return { value, missing: [...missing] };
+}
+function stringMatches(shed, local) {
+  if (shed === local) return true;
+  if (!PLACEHOLDER_RE.test(shed)) {
+    PLACEHOLDER_RE.lastIndex = 0;
+    return false;
+  }
+  PLACEHOLDER_RE.lastIndex = 0;
+  const re = "^" + shed.split(PLACEHOLDER_RE).map((part, i) => i % 3 === 0 ? part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : i % 3 === 1 ? ".+" : "").join("") + "$";
+  return new RegExp(re).test(local);
+}
+function matches2(shed, local) {
+  if (typeof shed === "string" && typeof local === "string") return stringMatches(shed, local);
+  if (Array.isArray(shed) && Array.isArray(local)) return shed.length === local.length && shed.every((x2, i) => matches2(x2, local[i]));
+  if (shed && local && typeof shed === "object" && typeof local === "object" && !Array.isArray(shed) && !Array.isArray(local)) {
+    const a = Object.keys(shed).sort(), b = Object.keys(local).sort();
+    return a.length === b.length && a.every((k, i) => k === b[i] && matches2(shed[k], local[k]));
+  }
+  return shed === local;
+}
+function remask(id, local, shed, cat) {
+  const keep = (l, s) => {
+    if (typeof l === "string" && typeof s === "string" && stringMatches(s, l)) return s;
+    if (Array.isArray(l) && Array.isArray(s)) return l.map((x2, i) => keep(x2, s[i]));
+    if (l && s && typeof l === "object" && typeof s === "object" && !Array.isArray(l) && !Array.isArray(s)) {
+      return Object.fromEntries(Object.entries(l).map(([k, x2]) => [k, keep(x2, s[k])]));
     }
-    if (!mine.length) continue;
-    m.components[cat.name] = [];
-    m.profiles[profileName][cat.name] = [];
-    for (const f of mine) {
-      const dst = path12.join(ctx.shed, cat.root, cat.kind === "dir" ? f.id : `${f.id}.md`);
+    return l;
+  };
+  return mask(id, shed === null ? local : keep(local, shed), cat);
+}
+function diffEntry(shed, local) {
+  const out = [];
+  const go = (s, l, kp) => {
+    if (s === void 0) {
+      out.push({ status: "A", file: kp || "(entry)" });
+      return;
+    }
+    if (l === void 0) {
+      out.push({ status: "D", file: kp || "(entry)" });
+      return;
+    }
+    const objs = s && l && typeof s === "object" && typeof l === "object" && !Array.isArray(s) && !Array.isArray(l);
+    if (objs) {
+      for (const k of (/* @__PURE__ */ new Set([...Object.keys(s), ...Object.keys(l)])).values()) go(s[k], l[k], kp ? `${kp}.${k}` : k);
+      return;
+    }
+    if (!matches2(s, l)) out.push({ status: "M", file: kp || "(entry)" });
+  };
+  go(shed, local, "");
+  return out.sort((a, b) => a.file.localeCompare(b.file));
+}
+async function readEntryFile(p) {
+  try {
+    return JSON.parse(await fs10.readFile(p, "utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error(`${p}: JSON \uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${e.message}`);
+  }
+}
+async function writeEntryFile(p, v) {
+  await fs10.mkdir(path14.dirname(p), { recursive: true });
+  await fs10.writeFile(p, JSON.stringify(v, null, 2) + "\n");
+}
+
+// src/core/ingest.ts
+function seqAt(doc, p) {
+  let node = doc.getIn(p);
+  if (!isSeq(node)) {
+    node = doc.createNode([]);
+    doc.setIn(p, node);
+  }
+  return node;
+}
+function pushUnique(seq, value) {
+  if (!seq.items.some((it) => (isMap(it) ? it.get("id") : String(it)) === value)) seq.add(value);
+}
+async function ingest(ctx, doc, profile, items, lock) {
+  const out = { managed: [], copied: 0, packages: [] };
+  for (const f of items) {
+    if (f.kind === "package") {
+      const p = f.pkg;
+      const node = doc.createNode(p.into ? { id: p.id, source: p.source, into: p.into } : { id: p.id, source: p.source });
+      if (p.into) node.comment = " install: ./setup    # \u2190 \uBCF5\uC6D0 \uD6C4 \uC2E4\uD589\uD560 \uBA85\uB839\uC774 \uC788\uC73C\uBA74 \uCC44\uC6B0\uC138\uC694 (--yes \uB85C \uC2E4\uD589)";
+      const seq = seqAt(doc, [PACKAGES]);
+      if (!seq.items.some((it) => isMap(it) && it.get("id") === p.id)) seq.add(node);
+      pushUnique(seqAt(doc, ["profiles", profile, PACKAGES]), p.id);
+      lock.packages[p.id] = { source: p.source, rev: p.rev };
+      out.packages.push(p.id);
+      ctx.log(`  \u2261 package ${p.id}  ${p.source} @${shortRev(p.rev)}  (\uCC38\uC870\uB9CC \uAE30\uB85D)`);
+      continue;
+    }
+    if (f.kind === "component") {
+      const dst = path15.join(ctx.shed, f.cat.root, f.cat.kind === "dir" ? f.id : `${f.id}.md`);
       await copyTree(f.path, dst, ignoreOf(ctx));
-      m.components[cat.name].push({ id: f.id });
-      m.profiles[profileName][cat.name].push(f.id);
-      managed.push(targetRel(cat, f.id));
-      copied++;
-      ctx.log(`  + ${cat.name}/${f.id}`);
+      ctx.log(`  + ${f.category}/${f.id}`);
+    } else {
+      const masked = mask(f.id, f.value, f.cat);
+      await writeEntryFile(path15.join(ctx.shed, f.category, `${f.id}.json`), masked);
+      const vars = placeholdersIn(masked);
+      ctx.log(`  + ${f.category}/${f.id}${vars.length ? `  (\uC2DC\uD06C\uB9BF \u2192 ${vars.map((v) => "${" + v + "}").join(", ")})` : ""}`);
+      for (const where of suspiciousStrings(masked)) ctx.log(`    ! ${where} \uAC00 \uC2DC\uD06C\uB9BF\uCC98\uB7FC \uBCF4\uC785\uB2C8\uB2E4. \uCC3D\uACE0\uC758 ${f.category}/${f.id}.json \uC5D0\uC11C \${VAR} \uB85C \uBC14\uAFB8\uC138\uC694`);
     }
+    const comps = seqAt(doc, ["components", f.category]);
+    if (!comps.items.some((it) => isMap(it) && it.get("id") === f.id)) comps.add(doc.createNode({ id: f.id }));
+    pushUnique(seqAt(doc, ["profiles", profile, f.category]), f.id);
+    out.managed.push(targetRel(f.cat, f.id));
+    out.copied++;
   }
+  return out;
+}
+function tidy(doc) {
+  const pk = doc.get(PACKAGES);
+  if (isSeq(pk) && !pk.items.length) doc.delete(PACKAGES);
+}
+
+// src/core/init.ts
+var MANIFEST_HEADER = "# lshed manifest \u2014 edit freely. Reference: https://github.com/LeeSongHeon-LSH/lshed\n";
+async function init(ctx, opts = {}) {
+  const profileName = opts.profile ?? "default";
+  if (await exists(manifestPath(ctx))) {
+    throw new Error(`\uC774\uBBF8 \uCD08\uAE30\uD654\uB41C \uCC3D\uACE0\uC785\uB2C8\uB2E4: ${manifestPath(ctx)}
+  \uC774 \uD658\uACBD\uC5D0 \uC0C8\uB85C \uC0DD\uAE34 \uAC83\uC744 \uAE30\uC874 \uCC3D\uACE0\uC5D0 \uB123\uC73C\uB824\uBA74 'lshed add' \uB97C, \uB2E4\uB978 \uD658\uACBD\uC758 \uC124\uC815\uC744 \uAC00\uC838\uC624\uB824\uBA74 'lshed restore' \uD6C4 'lshed save' \uB97C \uC4F0\uC138\uC694.`);
+  }
+  const d = await discover(ctx, opts.exclude);
+  for (const [key, by] of d.generated) ctx.log(`  \xB7 ${key}  (${by} \uAC00 \uC0DD\uC131\uD55C \uAC83 \u2192 \uAC74\uB108\uB700)`);
+  for (const key of d.excluded) ctx.log(`  - ${key}  (--exclude)`);
+  const exclude = opts.exclude?.length ? { exclude: [...opts.exclude] } : {};
+  const doc = new YAML4.Document({ version: 1, agent: ctx.adapter.name, ...exclude, components: {}, packages: [], profiles: { [profileName]: {} } });
+  const lock = { version: 1, packages: {} };
+  await fs11.mkdir(ctx.shed, { recursive: true });
+  const res = await ingest(ctx, doc, profileName, d.items, lock);
+  const managed = [...res.managed];
+  let copied = res.copied;
   const instr = instructionsFile(ctx);
   if (await exists(instr)) {
-    const text = await fs9.readFile(instr, "utf8");
+    const text = await fs11.readFile(instr, "utf8");
     if (!isGenerated(text)) {
-      const dst = path12.join(ctx.shed, INSTRUCTIONS, "main.md");
-      await fs9.mkdir(path12.dirname(dst), { recursive: true });
-      await fs9.writeFile(dst, text);
+      const dst = path16.join(ctx.shed, INSTRUCTIONS, "main.md");
+      await fs11.mkdir(path16.dirname(dst), { recursive: true });
+      await fs11.writeFile(dst, text);
       const fragRel = targetRel(INSTRUCTIONS, "main");
       await copyTree(dst, abs(ctx, fragRel), ignoreOf(ctx));
       managed.push(fragRel);
-      m.components[INSTRUCTIONS] = [{ id: "main" }];
-      m.profiles[profileName][INSTRUCTIONS] = ["main"];
+      doc.setIn(["components", INSTRUCTIONS], [{ id: "main" }]);
+      doc.setIn(["profiles", profileName, INSTRUCTIONS], ["main"]);
       copied++;
-      ctx.log(`  + ${INSTRUCTIONS}/main  (${path12.basename(instr)})`);
+      ctx.log(`  + ${INSTRUCTIONS}/main  (${path16.basename(instr)})`);
     }
   }
-  await fs9.mkdir(ctx.shed, { recursive: true });
-  let yamlText = stringifyManifest(m);
-  for (const p of pkgs) {
-    if (!p.into) continue;
-    yamlText = yamlText.replace(`    into: ${p.into}
-`, `    into: ${p.into}
-    # install: ./setup    # \u2190 \uBCF5\uC6D0 \uD6C4 \uC2E4\uD589\uD560 \uBA85\uB839\uC774 \uC788\uC73C\uBA74 \uCC44\uC6B0\uC138\uC694 (--yes \uB85C \uC2E4\uD589)
-`);
-  }
-  await fs9.writeFile(manifestPath(ctx), `# lshed manifest \u2014 edit freely. Reference: https://github.com/LeeSongHeon-LSH/lshed
-` + yamlText);
-  if (pkgs.length) {
-    await writeLock(ctx.shed, { version: 1, packages: Object.fromEntries(pkgs.map((p) => [p.id, { source: p.source, rev: p.rev }])) });
-  }
+  tidy(doc);
+  const yamlText = MANIFEST_HEADER + doc.toString({ lineWidth: 0 });
+  await fs11.writeFile(manifestPath(ctx), yamlText);
+  if (res.packages.length) await writeLock(ctx.shed, lock);
   await writeState(ctx.adapter, { profile: profileName, shed: ctx.shed, managed, appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
   const parts = [`\uBD80\uD488 ${copied}\uAC1C`];
-  if (pkgs.length) parts.push(`\uD328\uD0A4\uC9C0 ${pkgs.length}\uAC1C`);
-  if (generated.size) parts.push(`\uC0DD\uC131\uBB3C ${generated.size}\uAC1C \uAC74\uB108\uB700`);
-  if (skipped.length) parts.push(`\uC81C\uC678 ${skipped.length}\uAC1C`);
+  if (res.packages.length) parts.push(`\uD328\uD0A4\uC9C0 ${res.packages.length}\uAC1C`);
+  if (d.generated.size) parts.push(`\uC0DD\uC131\uBB3C ${d.generated.size}\uAC1C \uAC74\uB108\uB700`);
+  if (d.excluded.length) parts.push(`\uC81C\uC678 ${d.excluded.length}\uAC1C`);
   ctx.log(`
 ${MANIFEST_FILE} \uC0DD\uC131: ${manifestPath(ctx)}  (${parts.join(", ")}, \uD504\uB85C\uD544 "${profileName}")`);
-  if (pkgs.some((p) => p.into)) ctx.log(`git \uD328\uD0A4\uC9C0\uC758 \uC124\uCE58 \uBA85\uB839(install:)\uC740 lshed.yaml \uC5D0\uC11C \uC9C1\uC811 \uCC44\uC6B0\uC138\uC694.`);
-  return { manifest: m, copied, skipped, packages: pkgs.map((p) => p.id), generated: [...generated.keys()] };
+  if (d.items.some((f) => f.kind === "package" && f.pkg.into)) ctx.log(`git \uD328\uD0A4\uC9C0\uC758 \uC124\uCE58 \uBA85\uB839(install:)\uC740 lshed.yaml \uC5D0\uC11C \uC9C1\uC811 \uCC44\uC6B0\uC138\uC694.`);
+  const manifest = parseManifest(yamlText);
+  return { manifest, copied, skipped: d.excluded, packages: res.packages, generated: [...d.generated.keys()] };
 }
 
 // src/core/restore.ts
-import { promises as fs10 } from "fs";
-import path13 from "path";
+import { promises as fs12 } from "fs";
+import path17 from "path";
 async function restore(ctx, profileArg, opts = {}) {
   const backup = opts.backup ?? true;
   const state = await readState(ctx.adapter);
@@ -912,22 +1174,59 @@ async function restore(ctx, profileArg, opts = {}) {
   const oldManaged = new Set(state?.managed ?? []);
   const toRemove = [...oldManaged].filter((r) => !newManaged.has(r)).sort();
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path13.join(ctx.adapter.root, LSHED_DIR, "backups", stamp);
+  const backupDir = path17.join(ctx.adapter.root, LSHED_DIR, "backups", stamp);
   const backedUp = [];
   const placed = [];
+  const missingEnv = [];
+  const localEntries = /* @__PURE__ */ new Map();
+  const entriesOf = async (cat) => {
+    if (!localEntries.has(cat.name)) localEntries.set(cat.name, await cat.read());
+    return localEntries.get(cat.name);
+  };
   async function backUp(rel) {
+    const en = entryOf(ctx, rel);
+    if (en) {
+      const cur = (await entriesOf(en.cat))[en.id];
+      if (cur === void 0) return;
+      backedUp.push(rel);
+      if (opts.dryRun || !backup) return;
+      await writeEntryFile(path17.join(backupDir, en.cat.name, `${en.id}.json`), cur);
+      return;
+    }
     const from = abs(ctx, rel);
     if (!await exists(from)) return;
     backedUp.push(rel);
     if (opts.dryRun || !backup) return;
-    await copyTree(from, path13.join(backupDir, ...rel.split("/")), ignoreOf(ctx));
+    await copyTree(from, path17.join(backupDir, ...rel.split("/")), ignoreOf(ctx));
   }
   for (const rel of toRemove) {
     ctx.log(`  - ${rel}`);
     await backUp(rel);
-    if (!opts.dryRun) await removeTree(abs(ctx, rel));
+    if (opts.dryRun) continue;
+    const en = entryOf(ctx, rel);
+    if (en) await en.cat.write(en.id, null);
+    else await removeTree(abs(ctx, rel));
   }
   for (const it of plan) {
+    if (it.entry) {
+      const shed = await readEntryFile(it.src);
+      const local = (await entriesOf(it.entry))[it.id];
+      const vars = placeholdersIn(shed);
+      const ex = expand(shed);
+      if (ex.missing.length) missingEnv.push({ rel: it.rel, vars: ex.missing });
+      const value = it.entry.expandsEnv ? shed : ex.value;
+      const same2 = local !== void 0 && matches2(shed, local);
+      const mark2 = same2 ? "=" : local !== void 0 ? "~" : "+";
+      ctx.log(`  ${mark2} ${it.rel}${vars.length ? `  (${vars.map((v) => "${" + v + "}").join(", ")})` : ""}`);
+      if (same2) {
+        placed.push(it.rel);
+        continue;
+      }
+      if (local !== void 0) await backUp(it.rel);
+      if (!opts.dryRun) await it.entry.write(it.id, value);
+      placed.push(it.rel);
+      continue;
+    }
     const target = abs(ctx, it.rel);
     const same = await hashTree(target, ignoreOf(ctx)) === await hashTree(it.src, ignoreOf(ctx));
     const mark = same ? "=" : await exists(target) ? "~" : "+";
@@ -943,14 +1242,14 @@ async function restore(ctx, profileArg, opts = {}) {
   const instrPath = instructionsFile(ctx);
   if (fragments.length) {
     const contents = [];
-    for (const f of fragments) contents.push({ id: f.id, content: await fs10.readFile(f.src, "utf8") });
+    for (const f of fragments) contents.push({ id: f.id, content: await fs12.readFile(f.src, "utf8") });
     const rendered = renderInstructions(ctx, profile, contents);
-    const existing = await exists(instrPath) ? await fs10.readFile(instrPath, "utf8") : null;
+    const existing = await exists(instrPath) ? await fs12.readFile(instrPath, "utf8") : null;
     if (existing !== rendered) {
       const mark = existing === null ? "+" : "~";
       ctx.log(`  ${mark} ${instrRel}${existing !== null && !isGenerated(existing) ? "  (\uAE30\uC874 \uD30C\uC77C\uC740 lshed \uC0DD\uC131\uBB3C\uC774 \uC544\uB2D8 \u2192 \uBC31\uC5C5)" : ""}`);
       if (existing !== null) await backUp(instrRel);
-      if (!opts.dryRun) await fs10.writeFile(instrPath, rendered);
+      if (!opts.dryRun) await fs12.writeFile(instrPath, rendered);
     } else {
       ctx.log(`  = ${instrRel}`);
     }
@@ -960,14 +1259,22 @@ async function restore(ctx, profileArg, opts = {}) {
     ctx.log(`
 (dry-run) \uBCC0\uACBD \uC5C6\uC74C. \uBC30\uCE58 ${placed.length}, \uC81C\uAC70 ${toRemove.length}, \uBC31\uC5C5 \uC608\uC815 ${backedUp.length}`);
     reportPending(ctx, pkgRes);
-    return { profile, placed, removed: toRemove, backedUp, backupDir: null };
+    reportMissingEnv(ctx, missingEnv);
+    return { profile, placed, removed: toRemove, backedUp, backupDir: null, missingEnv };
   }
   await writeState(ctx.adapter, { profile, shed: ctx.shed, managed: [...newManaged].sort(), appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
   const bdir = backup && backedUp.length ? backupDir : null;
   ctx.log(`
 \uD504\uB85C\uD544 "${profile}" \uC801\uC6A9: \uBC30\uCE58 ${placed.length}, \uC81C\uAC70 ${toRemove.length}${pkgRes.installed.length ? `, \uD328\uD0A4\uC9C0 \uC124\uCE58 ${pkgRes.installed.length}` : ""}${bdir ? `, \uBC31\uC5C5 ${backedUp.length} \u2192 ${bdir}` : ""}`);
   reportPending(ctx, pkgRes);
-  return { profile, placed, removed: toRemove, backedUp, backupDir: bdir };
+  reportMissingEnv(ctx, missingEnv);
+  return { profile, placed, removed: toRemove, backedUp, backupDir: bdir, missingEnv };
+}
+function reportMissingEnv(ctx, missing) {
+  if (!missing.length) return;
+  ctx.log(`
+\uD658\uACBD\uBCC0\uC218\uAC00 \uC5C6\uB294 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4. \uC2DC\uD06C\uB9BF \uAC12\uC740 \uCC3D\uACE0\uC5D0 \uB2F4\uC9C0 \uC54A\uC73C\uBBC0\uB85C \uC774 \uAE30\uAE30\uC758 \uC178 \uD658\uACBD\uC5D0 \uB123\uC73C\uC138\uC694 (\uC608: ~/.zshrc \uC758 export):`);
+  for (const m of missing) ctx.log(`  ${m.rel}: ${m.vars.join(", ")}`);
 }
 
 // src/core/diff.ts
@@ -976,8 +1283,16 @@ async function diff(ctx) {
   if (!state) throw new Error("\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 'lshed restore <profile>' \uC744 \uC2E4\uD589\uD558\uC138\uC694.");
   const m = await loadManifest(ctx);
   const out = [];
+  const localEntries = /* @__PURE__ */ new Map();
   for (const item of planProfile(ctx, m, state.profile)) {
-    const changes = await diffTrees(abs(ctx, item.rel), item.src, ignoreOf(ctx));
+    let changes;
+    if (item.entry) {
+      if (!localEntries.has(item.category)) localEntries.set(item.category, await item.entry.read());
+      const shed = await readEntryFile(item.src);
+      changes = shed === null ? [{ status: "A", file: "(entry)" }] : diffEntry(shed, localEntries.get(item.category)[item.id]);
+    } else {
+      changes = await diffTrees(abs(ctx, item.rel), item.src, ignoreOf(ctx));
+    }
     if (changes.length) out.push({ item, changes });
   }
   return out;
@@ -993,15 +1308,83 @@ function formatDiff(diffs) {
   return lines.join("\n");
 }
 
+// src/core/add.ts
+import { promises as fs13 } from "fs";
+import YAML5 from "yaml";
+async function candidates(ctx, m, profile, d) {
+  d ??= await discover(ctx, m.exclude);
+  return { fresh: notInManifest(m, d), notInProfile: inManifestNotInProfile(m, profile, d), generated: d.generated };
+}
+async function add(ctx, keys = [], opts = {}) {
+  const state = await readState(ctx.adapter);
+  if (!state) throw new Error("\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 'lshed init' \uB610\uB294 'lshed restore <profile>' \uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+  const m = await loadManifest(ctx);
+  const c = await candidates(ctx, m, state.profile);
+  if (!keys.length && !opts.all) {
+    if (!c.fresh.length) ctx.log("\uCC3D\uACE0\uC5D0 \uC5C6\uB294 \uC0C8 \uD56D\uBAA9\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    else {
+      ctx.log(`\uCC3D\uACE0\uC5D0 \uC5C6\uB294 \uD56D\uBAA9 ${c.fresh.length}\uAC1C (\uB123\uC73C\uB824\uBA74 lshed add <key...> \uB610\uB294 --all):`);
+      for (const f of c.fresh) ctx.log(`  ${f.kind === "package" ? "\u2261" : " "} ${keyOf(f)}${f.kind === "package" ? `  ${f.pkg.source}` : ""}`);
+    }
+    hint(ctx, c, state.profile);
+    return [];
+  }
+  let chosen = c.fresh;
+  if (keys.length) {
+    chosen = keys.map((raw) => {
+      const [a, b] = raw.includes("/") ? raw.split("/", 2) : [void 0, raw];
+      const hits = c.fresh.filter((f) => f.id === b && (a === void 0 || f.category === a));
+      if (!hits.length) {
+        const known = (m.components[a ?? ""] ?? []).some((x2) => x2.id === b) || Object.values(m.components).some((cs) => cs.some((x2) => x2.id === b)) || m.packages.some((p) => p.id === b);
+        throw new Error(known ? `"${raw}" \uB294 \uC774\uBBF8 \uCC3D\uACE0\uC5D0 \uC788\uC2B5\uB2C8\uB2E4. \uD504\uB85C\uD544\uC5D0 \uB123\uC73C\uB824\uBA74 lshed.yaml \uC758 profiles \uB97C \uACE0\uCE58\uC138\uC694.` : `"${raw}" \uB294 \uB85C\uCEEC\uC5D0\uC11C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. 'lshed add' \uB85C \uD6C4\uBCF4\uB97C \uBCF4\uC138\uC694.`);
+      }
+      if (hits.length > 1) throw new Error(`"${raw}" \uAC00 \uBAA8\uD638\uD569\uB2C8\uB2E4: ${hits.map(keyOf).join(", ")}`);
+      return hits[0];
+    });
+  }
+  if (!chosen.length) {
+    ctx.log("\uCC3D\uACE0\uC5D0 \uC5C6\uB294 \uC0C8 \uD56D\uBAA9\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    hint(ctx, c, state.profile);
+    return [];
+  }
+  const doc = YAML5.parseDocument(await fs13.readFile(manifestPath(ctx), "utf8"));
+  const lock = await readLock(ctx.shed);
+  const res = await ingest(ctx, doc, state.profile, chosen, lock);
+  tidy(doc);
+  await fs13.writeFile(manifestPath(ctx), doc.toString({ lineWidth: 0 }));
+  if (res.packages.length) await writeLock(ctx.shed, lock);
+  const managed = [.../* @__PURE__ */ new Set([...state.managed, ...res.managed])].sort();
+  await writeState(ctx.adapter, { ...state, managed, appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  const added = chosen.map(keyOf);
+  ctx.log(`
+${added.length}\uAC1C\uB97C \uCC3D\uACE0\uC5D0 \uB123\uACE0 \uD504\uB85C\uD544 "${state.profile}" \uC5D0 \uCD94\uAC00\uD588\uC2B5\uB2C8\uB2E4. \uCC3D\uACE0\uB97C \uCEE4\uBC0B\uD558\uC138\uC694: ${ctx.shed}`);
+  if (res.packages.some((id) => chosen.find((f) => f.id === id && f.kind === "package" && f.pkg.into))) ctx.log(`git \uD328\uD0A4\uC9C0\uC758 \uC124\uCE58 \uBA85\uB839(install:)\uC740 lshed.yaml \uC5D0\uC11C \uC9C1\uC811 \uCC44\uC6B0\uC138\uC694.`);
+  hint(ctx, { ...c, fresh: c.fresh.filter((f) => !chosen.includes(f)) }, state.profile);
+  return added;
+}
+function hint(ctx, c, profile) {
+  const byPkg = /* @__PURE__ */ new Map();
+  for (const by of c.generated.values()) byPkg.set(by, (byPkg.get(by) ?? 0) + 1);
+  for (const [by, n] of byPkg) ctx.log(`  \xB7 \uD328\uD0A4\uC9C0 ${by} \uAC00 \uC0DD\uC131\uD55C \uAC83 ${n}\uAC1C\uB294 \uB2F4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`);
+  if (c.notInProfile.length) ctx.log(`\uCC3D\uACE0\uC5D0\uB294 \uC788\uC9C0\uB9CC \uD504\uB85C\uD544 "${profile}" \uC774 \uC548 \uC4F0\uB294 \uAC83 ${c.notInProfile.length}\uAC1C: ${c.notInProfile.join(", ")}  \u2192 lshed.yaml \uC758 profiles \uC5D0 \uCD94\uAC00`);
+}
+
 // src/core/status.ts
 async function status(ctx) {
   const state = await readState(ctx.adapter);
-  if (!state) return { state: null, drifted: [], packages: [] };
+  if (!state) return { state: null, drifted: [], packages: [], missingEnv: [], fresh: [] };
   const d = await diff(ctx);
   const m = await loadManifest(ctx);
   const lock = await readLock(ctx.shed);
   const packages = await Promise.all(packagesOf(m, state.profile).map((p) => packageStatus(ctx, p, lock)));
-  return { state, drifted: d.map((x2) => `${x2.item.category}/${x2.item.id}`), packages };
+  const missingEnv = [];
+  for (const it of planProfile(ctx, m, state.profile).filter((p) => p.entry)) {
+    const shed = await readEntryFile(it.src);
+    const missing = shed === null ? [] : expand(shed).missing;
+    if (missing.length) missingEnv.push({ rel: it.rel, vars: missing });
+  }
+  const fresh = (await candidates(ctx, m, state.profile)).fresh.map(keyOf);
+  return { state, drifted: d.map((x2) => `${x2.item.category}/${x2.item.id}`), packages, missingEnv, fresh };
 }
 function formatStatus(s, adapterRoot) {
   if (!s.state) return `\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 (${adapterRoot}).
@@ -1018,6 +1401,8 @@ function formatStatus(s, adapterRoot) {
     const where = !p.present ? "\uC124\uCE58 \uC548 \uB428 \u2192 lshed restore" : !p.locked ? `${short2(p.rev)} (\uB77D \uC5C6\uC74C)` : p.rev === p.locked ? `${short2(p.rev)} = lock` : `${short2(p.rev)} \u2260 lock ${short2(p.locked)} \u2192 lshed update`;
     lines.push(`\uD328\uD0A4\uC9C0   ${p.pkg.id}  ${where}`);
   }
+  for (const m of s.missingEnv) lines.push(`\uD658\uACBD\uBCC0\uC218 ${m.rel}: ${m.vars.join(", ")} \uC5C6\uC74C  \u2192 \uC178\uC5D0\uC11C export \uD558\uC138\uC694`);
+  if (s.fresh.length) lines.push(`\uCC3D\uACE0 \uBC16  ${s.fresh.length}\uAC1C: ${s.fresh.join(", ")}  \u2192 lshed add`);
   return lines.join("\n");
 }
 
@@ -1037,13 +1422,27 @@ async function save(ctx, ids = []) {
     });
   }
   const saved = [];
+  const localEntries = /* @__PURE__ */ new Map();
   for (const it of plan) {
-    const kind = it.category === INSTRUCTIONS ? "file" : ctx.adapter.categories().find((c) => c.name === it.category).kind;
-    const src = effectiveSource(it.category, it.component, kind);
+    const src = effectiveSource(it.category, it.component, kindOf(ctx, it.category));
     if (!isSaveable(src)) {
       ctx.log(`  ! ${it.category}/${it.id}: \uC6D0\uACA9 \uCD9C\uCC98(${src})\uB294 save \uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
       continue;
     }
+    if (it.entry) {
+      if (!localEntries.has(it.category)) localEntries.set(it.category, await it.entry.read());
+      const local2 = localEntries.get(it.category)[it.id];
+      if (local2 === void 0) {
+        ctx.log(`  ! ${it.category}/${it.id}: \uB85C\uCEEC\uC5D0 \uC5C6\uC74C (\uAC74\uB108\uB700)`);
+        continue;
+      }
+      const shed = await readEntryFile(it.src);
+      if (shed !== null && matches2(shed, local2)) continue;
+      await writeEntryFile(it.src, remask(it.id, local2, shed, it.entry));
+      saved.push(`${it.category}/${it.id}`);
+      ctx.log(`  \u2713 ${it.category}/${it.id} \u2192 \uCC3D\uACE0  (\uC2DC\uD06C\uB9BF\uC740 \uC790\uB9AC\uD45C\uC2DC\uC790\uB85C)`);
+      continue;
+    }
     const local = abs(ctx, it.rel);
     if (!await exists(local)) {
       ctx.log(`  ! ${it.category}/${it.id}: \uB85C\uCEEC\uC5D0 \uC5C6\uC74C (\uAC74\uB108\uB700)`);
@@ -1083,9 +1482,9 @@ function formatRows(rows, m) {
 }
 
 // src/core/remove.ts
-import { promises as fs11 } from "fs";
-import path14 from "path";
-import YAML3, { isSeq, isMap } from "yaml";
+import { promises as fs14 } from "fs";
+import path18 from "path";
+import YAML6, { isSeq as isSeq2, isMap as isMap2 } from "yaml";
 function resolveKey(m, raw) {
   const rows = listRows(m);
   const [a, b] = raw.includes("/") ? raw.split("/", 2) : [void 0, raw];
@@ -1099,13 +1498,13 @@ async function remove(ctx, raw) {
   const { category, id } = resolveKey(m, raw);
   const users = listRows(m).find((r) => r.category === category && r.id === id).usedBy;
   if (users.length) throw new Error(`${category}/${id} \uB294 \uD504\uB85C\uD544 ${users.join(", ")} \uC774 \uC4F0\uACE0 \uC788\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 \uD504\uB85C\uD544\uC5D0\uC11C \uBE7C\uC138\uC694.`);
-  const text = await fs11.readFile(manifestPath(ctx), "utf8");
-  const doc = YAML3.parseDocument(text);
+  const text = await fs14.readFile(manifestPath(ctx), "utf8");
+  const doc = YAML6.parseDocument(text);
   let deleted;
   if (category === PACKAGES) {
     const seq = doc.get(PACKAGES);
-    if (!isSeq(seq)) throw new Error("packages \uAC00 \uBAA9\uB85D\uC774 \uC544\uB2D9\uB2C8\uB2E4");
-    const idx = seq.items.findIndex((it) => isMap(it) && it.get("id") === id);
+    if (!isSeq2(seq)) throw new Error("packages \uAC00 \uBAA9\uB85D\uC774 \uC544\uB2D9\uB2C8\uB2E4");
+    const idx = seq.items.findIndex((it) => isMap2(it) && it.get("id") === id);
     seq.delete(idx);
     if (!seq.items.length) doc.delete(PACKAGES);
     const lock = await readLock(ctx.shed);
@@ -1116,19 +1515,19 @@ async function remove(ctx, raw) {
     ctx.log(`  - package ${id}  (\uB9E4\uB2C8\uD398\uC2A4\uD2B8\xB7\uB77D\uC5D0\uC11C \uC81C\uAC70. \uB85C\uCEEC clone \uC740 \uADF8\uB300\uB85C)`);
   } else {
     const seq = doc.getIn(["components", category]);
-    if (!isSeq(seq)) throw new Error(`components.${category} \uAC00 \uBAA9\uB85D\uC774 \uC544\uB2D9\uB2C8\uB2E4`);
-    const idx = seq.items.findIndex((it) => isMap(it) && it.get("id") === id);
+    if (!isSeq2(seq)) throw new Error(`components.${category} \uAC00 \uBAA9\uB85D\uC774 \uC544\uB2D9\uB2C8\uB2E4`);
+    const idx = seq.items.findIndex((it) => isMap2(it) && it.get("id") === id);
     seq.delete(idx);
     if (!seq.items.length) doc.deleteIn(["components", category]);
     const src = sourcePath(ctx, category, findComponent(m, category, id));
-    const inside = !path14.relative(ctx.shed, src).startsWith("..");
+    const inside = !path18.relative(ctx.shed, src).startsWith("..");
     if (inside && await exists(src)) {
       await removeTree(src);
       deleted = src;
     }
     ctx.log(`  - ${category}/${id}${deleted ? "" : "  (\uCC3D\uACE0 \uBC16 \uACBD\uB85C\uB77C \uD30C\uC77C\uC740 \uB450\uC5C8\uC74C)"}`);
   }
-  await fs11.writeFile(manifestPath(ctx), doc.toString());
+  await fs14.writeFile(manifestPath(ctx), doc.toString());
   return { category, id, deleted };
 }
 async function prune(ctx, opts = {}) {
@@ -1153,21 +1552,105 @@ ${removed.length}\uAC1C \uC81C\uAC70. \uCC3D\uACE0\uB97C \uCEE4\uBC0B\uD558\uC13
   return removed;
 }
 
+// src/core/sync.ts
+import os2 from "os";
+async function sync(ctx, opts = {}) {
+  const shed = ctx.shed;
+  const push = opts.push ?? true;
+  if (!await isRepo(shed)) {
+    throw new Error(`\uCC3D\uACE0\uAC00 git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${shed}
+  cd ${shed} && git init && git add -A && git commit -m "my harness"
+  \uC6D0\uACA9\uC5D0 \uB450\uB824\uBA74: git remote add origin <url> && git push -u origin HEAD`);
+  }
+  const res = { committed: [], pulled: 0, pushed: false, unsaved: [] };
+  if (await readState(ctx.adapter)) {
+    try {
+      res.unsaved = (await diff(ctx)).map((d) => `${d.item.category}/${d.item.id}`);
+    } catch {
+    }
+    if (res.unsaved.length) ctx.log(`  ! \uB85C\uCEEC \uD3B8\uC9D1 ${res.unsaved.length}\uAC1C\uAC00 \uCC3D\uACE0\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4: ${res.unsaved.join(", ")}  \u2192 lshed save \uD6C4 \uB2E4\uC2DC sync`);
+  }
+  const dirty = (await git(["status", "--porcelain", "--untracked-files=all"], shed)).split("\n").filter(Boolean).map((l) => l.slice(3).trim());
+  if (dirty.length) {
+    const msg = opts.message ?? defaultMessage(dirty, (await readState(ctx.adapter))?.profile);
+    ctx.log(`  ${opts.dryRun ? "(dry-run) " : ""}commit ${dirty.length}\uAC1C: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ` \uC678 ${dirty.length - 5}` : ""}`);
+    if (!opts.dryRun) {
+      await git(["add", "-A"], shed);
+      await git(["commit", "--quiet", "-m", msg], shed);
+    }
+    res.committed = dirty;
+  } else {
+    ctx.log("  = \uCC3D\uACE0\uC5D0 \uCEE4\uBC0B\uD560 \uBCC0\uACBD \uC5C6\uC74C");
+  }
+  const remote = await git(["remote", "get-url", "origin"], shed).catch(() => null);
+  if (!remote) {
+    ctx.log("  \xB7 origin \uC774 \uC5C6\uC5B4 pull/push \uB294 \uAC74\uB108\uB700 (git remote add origin <url>)");
+    return res;
+  }
+  if (opts.dryRun) {
+    ctx.log(`  (dry-run) pull --rebase, push \u2192 ${remote}`);
+    return res;
+  }
+  const before = await git(["rev-parse", "HEAD"], shed);
+  const branch2 = await git(["rev-parse", "--abbrev-ref", "HEAD"], shed);
+  const hasUpstream = await git(["rev-parse", "--abbrev-ref", "@{upstream}"], shed).then(() => true, () => false);
+  if (hasUpstream) {
+    try {
+      await git(["pull", "--rebase", "--quiet"], shed);
+    } catch (e) {
+      await git(["rebase", "--abort"], shed).catch(() => {
+      });
+      throw new Error(`pull \uC911 \uCDA9\uB3CC\uC774 \uB098\uC11C \uB418\uB3CC\uB838\uC2B5\uB2C8\uB2E4. \uCC3D\uACE0\uC5D0\uC11C \uC9C1\uC811 \uD574\uACB0\uD558\uC138\uC694:
+  cd ${shed} && git pull --rebase
+  (${firstLine(e.message)})`);
+    }
+    const after = await git(["rev-parse", "HEAD"], shed);
+    if (after !== before) {
+      const n = Number(await git(["rev-list", "--count", `${before}..${after}`], shed).catch(() => "0"));
+      res.pulled = Math.max(0, n - (res.committed.length ? 1 : 0));
+      if (res.pulled) ctx.log(`  \u2193 \uC6D0\uACA9 \uCEE4\uBC0B ${res.pulled}\uAC1C \uBC1B\uC74C`);
+    }
+  } else {
+    ctx.log(`  \xB7 \uBE0C\uB79C\uCE58 ${branch2} \uC5D0 upstream \uC774 \uC5C6\uC5B4 pull \uC740 \uAC74\uB108\uB700`);
+  }
+  if (push) {
+    const ahead = hasUpstream ? Number(await git(["rev-list", "--count", "@{upstream}..HEAD"], shed)) : 1;
+    if (ahead > 0) {
+      await git(hasUpstream ? ["push", "--quiet"] : ["push", "--quiet", "-u", "origin", branch2], shed);
+      res.pushed = true;
+      ctx.log(`  \u2191 push ${hasUpstream ? `${ahead}\uAC1C \uCEE4\uBC0B` : `(upstream \uC124\uC815: origin/${branch2})`}`);
+    } else {
+      ctx.log("  = \uC6D0\uACA9\uACFC \uAC19\uC74C");
+    }
+  }
+  if (res.pulled) ctx.log(`
+\uCC3D\uACE0\uAC00 \uBC14\uB00C\uC5C8\uC2B5\uB2C8\uB2E4. \uC774 \uAE30\uAE30\uC5D0 \uC801\uC6A9\uD558\uB824\uBA74: lshed restore`);
+  return res;
+}
+function defaultMessage(paths, profile) {
+  const parts = [...new Set(paths.map((p) => p.split("/").slice(0, 2).join("/")))];
+  const head2 = parts.slice(0, 3).join(", ") + (parts.length > 3 ? ` +${parts.length - 3}` : "");
+  return `lshed sync: ${head2}
+
+${os2.hostname()}${profile ? ` \xB7 profile ${profile}` : ""}`;
+}
+var firstLine = (s) => s.split("\n").find((l) => l.trim() && !l.startsWith("Command failed")) ?? s;
+
 // src/cli.ts
 var { version } = createRequire(import.meta.url)("../package.json");
 var program = new Command().name("lshed").description("Keep your coding-agent harness (skills, agents, commands, instructions) in a shed and restore it anywhere by profile.").version(version).option("--shed <dir>", "shed directory (default: $LSHED_HOME, then the shed recorded by the last restore)").option("--root <dir>", "agent config root (default: ~/.claude)");
 function adapterFromOpts() {
   const { root } = program.opts();
-  return new ClaudeCodeAdapter(root ? path15.resolve(root) : void 0);
+  return new ClaudeCodeAdapter(root ? path19.resolve(root) : void 0);
 }
 async function ctxFor(cmd) {
   const adapter = adapterFromOpts();
   const { shed: flag } = program.opts();
   let shed = flag ?? process.env.LSHED_HOME;
   if (!shed && cmd === "other") shed = (await readState(adapter))?.shed;
-  if (!shed && cmd === "init") shed = path15.join(os2.homedir(), "lshed");
+  if (!shed && cmd === "init") shed = path19.join(os3.homedir(), "lshed");
   if (!shed) throw new Error("\uCC3D\uACE0 \uC704\uCE58\uB97C \uBAA8\uB985\uB2C8\uB2E4. --shed <dir> \uB610\uB294 LSHED_HOME \uC744 \uC9C0\uC815\uD558\uC138\uC694.");
-  return { adapter, shed: path15.resolve(shed), log: (l) => console.log(l), exec: spawnExec };
+  return { adapter, shed: path19.resolve(shed), log: (l) => console.log(l), exec: spawnExec };
 }
 async function run(fn) {
   try {
@@ -1212,7 +1695,7 @@ program.command("status").description("show the applied profile, managed paths a
   const adapter = adapterFromOpts();
   const state = await readState(adapter);
   if (!state) {
-    console.log(formatStatus({ state: null, drifted: [], packages: [] }, adapter.root));
+    console.log(formatStatus({ state: null, drifted: [], packages: [], missingEnv: [], fresh: [] }, adapter.root));
     return;
   }
   const ctx = await ctxFor("other");
@@ -1226,6 +1709,14 @@ program.command("save [ids...]").description("copy local edits back into the she
   const ctx = await ctxFor("other");
   await save(ctx, ids);
 }));
+program.command("add [keys...]").description("put things that appeared locally since init into the shed and the current profile (lists candidates without keys)").option("--all", "add every candidate").action((keys, o) => run(async () => {
+  const ctx = await ctxFor("other");
+  await add(ctx, keys, { all: o.all });
+}));
+program.command("sync").description("commit the shed, pull --rebase and push (the shed must be a git repo with origin)").option("-m, --message <msg>", "commit message (default: names the changed parts)").option("--no-push", "commit and pull only").option("--dry-run", "show what would be committed and pushed").action((o) => run(async () => {
+  const ctx = await ctxFor("other");
+  await sync(ctx, { message: o.message, push: o.push, dryRun: o.dryRun });
+}));
 program.command("list").description("everything in the shed and which profiles use it").option("--unused", "only things no profile uses").action((o) => run(async () => {
   const ctx = await ctxFor("other");
   const m = await loadManifest(ctx);
@@ -1244,6 +1735,11 @@ program.command("scan").description("(debug) list components found in the agent
   const adapter = adapterFromOpts();
   const found = await adapter.scan();
   for (const c of found) console.log(`${c.category}/${c.id}	${c.path}`);
-  console.error(`${found.length}\uAC1C \uBC1C\uACAC (root: ${adapter.root})`);
+  let n = found.length;
+  for (const e of adapter.entries()) for (const id of Object.keys(await e.read())) {
+    console.log(`${e.name}/${id}	(entry)`);
+    n++;
+  }
+  console.error(`${n}\uAC1C \uBC1C\uACAC (root: ${adapter.root})`);
 }));
 program.parseAsync();