lshed 0.6.0 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.7.2 — 2026-09-03
+
+Joining a machine that already has a harness, found while preparing the Windows check.
+
+- `restore` warns before removing parts that a **different** shed had claimed. Running `init` against a scratch shed to look around marks that machine's own parts as managed, so a later restore from the real shed would remove them. They were always backed up, but nothing said why. `lshed scan` is the read-only way to look.
+- No longer crashes with an `EPIPE` stack trace when output is piped into something that exits early (`lshed status | head`).
+- The smoke script now models a machine that already runs the agent: a skill whose name collides with the shed, a skill only that machine has, and its own MCP and settings. It checks that a collision is backed up and replaced, that machine-only parts survive, that nothing is removed, and that `add` pushes them into the shed.
+- README: how to join a machine that already has a setup, and why not to `init` there.
+
+## 0.7.1 — 2026-09-03
+
+Groundwork for running on Windows and macOS. Not yet verified on a real machine.
+
+- Package `install:` commands run through the platform shell (`sh` or `cmd.exe`) instead of a hard-coded `sh -c`.
+- On Windows, `claude` and other wrappers installed as `.cmd` are found by spawning through the shell.
+- Home-directory paths with backslashes are also rewritten to `${HOME}`.
+- `sync` explains what to do when git has no user identity.
+- `npm run smoke` drives the built CLI through init, restore, add, diff, save, profile switch, list and sync in a temporary directory without touching the real `~/.claude`. Use it on a new OS before trusting a real restore.
+- GitHub Actions matrix: ubuntu, macOS, Windows × Node 20, 22. Tests use directory junctions on Windows so no elevated privileges are needed.
+
+## 0.7.0 — 2026-09-03
+
+`settings.json` travels, without merging.
+
+- New category `settings` for Claude Code: each top-level key of `~/.claude/settings.json` (`hooks`, `permissions`, `env`, `model`, `theme`, …) is one component, stored as `settings/<key>.json`. `restore` writes only the keys the profile lists; a profile can carry `permissions` and leave `model` to each machine. `enabledPlugins` is skipped because the plugin packages own it.
+- Absolute paths under the home directory are stored as `${HOME}/…` (MCP entries too), so hook commands survive a different home. Claude Code does not expand variables in `settings.json`, so `restore` expands `${HOME}` and other `${VAR}` there from the shell; MCP placeholders are still left for Claude Code.
+- `env` in settings is a secret map: secret-looking keys are masked.
+- The secret heuristic now matches whole words. `CLAUDE_CODE_MAX_OUTPUT_TOKENS` is not a token; `BYPASS_PERMISSIONS` is not a password.
+- `init` and `add` flag an entry whose value points inside a package (a hook a toolkit's installer wrote) and suggest `exclude:`.
+- The MCP adapter became a generic "one JSON key = one entry" store used by both categories.
+
 ## 0.6.0 — 2026-09-03
 
 - `lshed sync [-m <msg>] [--no-push] [--dry-run]`: commits everything in the shed, `git pull --rebase`, `git push` (setting the upstream the first time). Without `origin` it only commits. When commits come in it says to run `lshed restore`. On a conflict it aborts the rebase, leaves your commit in place and hands you the git command. It warns first if `diff` shows edits you have not saved, and never runs `save` for you.

package/README.md

@@ -1,6 +1,6 @@
 # lshed
 
-Keep your coding-agent harness — skills, subagents, commands, instructions, MCP servers — in a **shed**, and restore it on any machine with one command.
+Keep your coding-agent harness — skills, subagents, commands, instructions, MCP servers, settings — in a **shed**, and restore it on any machine with one command.
 
 ```
 lshed init --shed ~/lshed          # scan ~/.claude into a shed + write lshed.yaml
@@ -17,7 +17,7 @@ lshed adds three first-class ideas on top of "a directory in git":
 
 | Idea | What it gives you |
 |---|---|
-| **Components** | every skill / agent / command / instruction fragment / MCP server is one named part in the shed |
+| **Components** | every skill / agent / command / instruction fragment / MCP server / settings key is one named part in the shed |
 | **Profiles** | named recipes — `research`, `work`, `minimal` — that pick a subset of parts |
 | **Managed set** | lshed remembers what it placed, so switching profiles removes only its own files and never touches yours |
 
@@ -89,6 +89,31 @@ lshed sync            # commit the shed, pull, push
 
 `save` is the only path from `~/.claude` to the shed, and it only works for parts the shed owns (`file:` sources). `sync` warns if you have unsaved edits so you do not push a shed that is behind your machine.
 
+### A machine that already has a setup
+
+The common case is not an empty machine: it already runs the agent and has skills, settings and MCP servers of its own. `restore` is built for that. With no prior lshed state it **removes nothing** — it places what the profile lists, and anything it overwrites goes to `~/.claude/lshed/backups/<timestamp>/` first. Parts that exist only on that machine are untouched.
+
+```
+$ lshed restore default --shed ~/lshed --dry-run
+  + skills/mine
+  ~ skills/shared            # same name, different content → backed up, then replaced
+  + mcp:exa  (${EXA_API_KEY})
+  ~ settings:model
+(dry-run) 변경 없음. 배치 5, 제거 0, 백업 예정 3
+```
+
+Always run `--dry-run` first. `+` is new, `~` replaces with a backup, `-` removes with a backup. If the plan looks right, drop the flag.
+
+Then push that machine's own parts up into the shed and both machines have everything:
+
+```
+lshed add                    # lists what this machine has that the shed does not
+lshed add windows-only mcp/my-local-server
+lshed sync
+```
+
+Do not run `init` on such a machine just to look around. `init` claims what it finds as lshed-managed, so a later `restore` from your real shed would treat those parts as removable (backed up, but removed). Use `lshed scan`, which only prints. If you do it anyway, `restore` warns you before removing anything and `lshed add` is the way out.
+
 ### A new machine
 
 ```
@@ -227,6 +252,9 @@ components:
     - id: research-style
   mcp:
     - id: exa                     # file:./mcp/exa.json — secrets replaced by ${VAR}
+  settings:
+    - id: permissions             # file:./settings/permissions.json — one top-level key of settings.json
+    - id: hooks
 
 packages:
   - id: gstack
@@ -241,6 +269,7 @@ profiles:
     agents: [reviewer]
     instructions: [base, research-style]    # order matters
     mcp: [exa]
+    settings: [permissions, hooks]
   teaching:
     skills: [grading-helper]
     commands: [summarize]
@@ -248,7 +277,7 @@ profiles:
 ```
 
 - Component `source` accepts `file:<path relative to the shed>`. Package `source` accepts `github:owner/repo@ref`, `git:<url>#ref`, `claude-marketplace:<owner/repo>`, `claude-plugin:<name>@<marketplace>`.
-- Category names come from the adapter. For Claude Code: `skills`, `agents`, `commands`, `instructions`, `mcp`.
+- Category names come from the adapter. For Claude Code: `skills`, `agents`, `commands`, `instructions`, `mcp`, `settings`.
 - `ignore:` adds to the built-in list of things never copied: `node_modules`, `.git`, `__pycache__`, `.venv`, cache directories, `*.log`. Build output like `dist/` is not ignored by default, since some skills ship it.
 - `exclude:` lists parts that exist locally but must not enter the shed. `init --exclude` writes it.
 
@@ -274,7 +303,7 @@ Claude Code plugins are packages with their own scheme. `init` finds user-scope
 
 User-scope MCP servers live in `~/.claude.json`, next to machine IDs and session state. lshed treats each server as a component of category `mcp`: the shed holds `mcp/<name>.json`, and `restore` edits only the `mcpServers.<name>` key of `~/.claude.json`, leaving everything else in that file alone.
 
-**No secret value enters the shed.** `init` and `add` replace values under `env` and `headers` whose key looks like a secret (`key`, `token`, `secret`, `pass`, `auth`, `credential`, `cookie`, `session`) with a `${VAR}` placeholder:
+**No secret value enters the shed.** `init` and `add` replace values under `env` and `headers` whose key contains a secret-looking word (`key`, `token`, `secret`, `password`, `auth`, `authorization`, `credential`, `cookie`, `session` — whole words, so `MAX_OUTPUT_TOKENS` is left alone) with a `${VAR}` placeholder:
 
 ```json
 { "type": "stdio", "command": "npx", "args": ["-y", "exa-mcp-server"],
@@ -285,6 +314,24 @@ User-scope MCP servers live in `~/.claude.json`, next to machine IDs and session
 
 `restore` writes the placeholder as is. Claude Code expands `${VAR}` from the environment when it starts the server, so the value only ever lives in your shell (`export EXA_API_KEY=...` in `~/.zshrc`, or however you manage secrets). `restore` and `status` list the variables the profile needs that are not set. The heuristic is a suggestion: edit the JSON in the shed to add or remove placeholders, and `init` warns when something in `args` or `url` looks like a token. `save` keeps existing placeholders and masks new secret-looking keys, so a rotated key never leaks into the shed by accident. `diff` compares with placeholders as wildcards, so a machine holding real values is not drift.
 
+## Settings
+
+`~/.claude/settings.json` holds hooks, permissions, `env`, the model, the theme, and some state Claude Code writes for itself. lshed does not merge it. Each **top-level key is one component** of category `settings`: the shed holds `settings/permissions.json`, `settings/hooks.json`, and so on, and `restore` writes exactly those keys, leaving the rest of the file alone. A profile can carry `permissions` and `hooks` and leave `model` to each machine.
+
+```
+$ lshed add
+창고에 없는 항목 3개:
+    settings/hooks  ! 패키지 gstack 안을 가리킵니다. 그 설치가 만든 것이면 exclude 하세요: settings/hooks
+    settings/model
+    settings/theme
+```
+
+- `enabledPlugins` is never taken: the plugin packages own it, and `restore` rebuilds it by installing them.
+- Absolute paths under your home directory become `${HOME}/…` in the shed, so a hook command written on one machine works on another. Claude Code does not expand variables in `settings.json`, so `restore` fills `${HOME}` and any `${VAR}` itself from your shell; unset variables are reported and left as placeholders.
+- `env` is treated as a secret map: keys that look secret are masked, the rest (`CLAUDE_CODE_MAX_OUTPUT_TOKENS`, …) travel as they are.
+- A value pointing inside a package (a hook a toolkit's installer wrote) is flagged. If the installer recreates it, put it in `exclude:` and let `restore --yes` bring it back.
+- Since the shed owns the whole key, extra permissions you grant locally show up in `diff` and go into the shed with `save`, like any other edit.
+
 ## Commands
 
 ```
@@ -309,7 +356,7 @@ Global options: `--shed <dir>` (or `LSHED_HOME`; after the first restore lshed r
 
 0. Installs any package in the profile that is missing, at the version in `lshed.lock`.
 1. Removes paths that the **previous** profile placed and the new one doesn't need.
-2. Copies every part of the new profile into place; writes every MCP entry into `~/.claude.json`.
+2. Copies every part of the new profile into place; writes MCP entries into `~/.claude.json` and settings keys into `settings.json`.
 3. Regenerates the instructions file.
 
 Anything it overwrites or removes is backed up first under `~/.claude/lshed/backups/<timestamp>/`, unless you pass `--no-backup`. Files lshed never placed are left alone. `--dry-run` prints the plan and writes nothing.
@@ -335,9 +382,11 @@ The shed is the source of truth for authored parts: `save` copies local edits ba
   lshed.lock                                    package versions (generated)
   skills/<id>/    agents/<id>.md    commands/<id>.md    instructions/<id>.md
   mcp/<id>.json                                 secrets as ${VAR}
+  settings/<id>.json                            one top-level key each; home paths as ${HOME}
 
 ~/.claude/
   skills/ agents/ commands/ CLAUDE.md           ← placed by restore
+  settings.json  <id>                           ← one key per settings component; the rest is untouched
   lshed/state.json                              ← which profile, which paths are managed
   lshed/instructions/<id>.md                    ← fragments imported by CLAUDE.md
   lshed/backups/<timestamp>/                    ← whatever restore replaced
@@ -350,7 +399,6 @@ The shed is the source of truth for authored parts: `save` copies local edits ba
 
 - Secrets beyond "name the variable". Encrypted values, `op://` references and OS keychains are possible later; today lshed is deliberately no better than dotfiles here.
 - Project-scope MCP servers (`.mcp.json`, `~/.claude.json` `projects.*`) and project-scope plugins. They belong to the project.
-- `settings.json` merging (hooks, permissions).
 - Windows and macOS have not been tested. The code avoids platform-specific paths, but treat this as Linux/WSL for now.
 
 ## Troubleshooting
@@ -361,6 +409,7 @@ The shed is the source of truth for authored parts: `save` copies local edits ba
 - **`status` says a package differs from the lock** — something updated the clone or plugin behind lshed's back (Claude Code auto-updates plugins). `lshed update` records the new version.
 - **`status` keeps listing the same new things** — they are installer aliases or scratch. Add them to `exclude:` in `lshed.yaml`.
 - **restore says an MCP variable is missing** — export it in your shell profile and restart Claude Code. The placeholder in `~/.claude.json` is correct; Claude Code fills it at startup.
+- **restore wrote a hook with the wrong path** — the shed stores home paths as `${HOME}/…`. If a command points elsewhere on this machine, edit the JSON in the shed to use `${HOME}` or another variable and `restore` again.
 - **sync stopped on a conflict** — `cd <shed> && git pull --rebase`, resolve, `git rebase --continue`, then `lshed sync` again.
 
 ## License

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { Command } from "commander";
 import { createRequire } from "module";
-import os3 from "os";
+import os4 from "os";
 import path19 from "path";
 
 // src/adapters/claude-code.ts
@@ -166,14 +166,62 @@ var pluginInstaller = {
   }
 };
 
-// src/adapters/claude-mcp.ts
-import { promises as fs3 } from "fs";
-import path3 from "path";
+// src/adapters/json-entries.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var JsonEntries = class {
+  constructor(spec) {
+    this.spec = spec;
+    this.name = spec.name;
+    this.secretKeys = spec.secretKeys;
+    this.secretRootIds = spec.secretRootIds;
+    this.expandsEnv = spec.expandsEnv;
+  }
+  spec;
+  kind = "entry";
+  name;
+  secretKeys;
+  secretRootIds;
+  expandsEnv;
+  file() {
+    return this.spec.file();
+  }
+  async load() {
+    const p = await this.file();
+    try {
+      return JSON.parse(await fs2.readFile(p, "utf8"));
+    } catch (e) {
+      if (e.code === "ENOENT") return {};
+      throw new Error(`${p} \uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${e.message}`);
+    }
+  }
+  section(all) {
+    const s = this.spec.under ? all[this.spec.under] : all;
+    return s && typeof s === "object" && !Array.isArray(s) ? s : {};
+  }
+  async read() {
+    const out = { ...this.section(await this.load()) };
+    for (const k of this.spec.skip ?? []) delete out[k];
+    return out;
+  }
+  async write(id, value) {
+    const p = await this.file();
+    const all = await this.load();
+    const sect = { ...this.section(all) };
+    if (value === null) delete sect[id];
+    else sect[id] = value;
+    const next = this.spec.under ? { ...all, [this.spec.under]: sect } : sect;
+    await fs2.mkdir(path2.dirname(p), { recursive: true });
+    const tmp = `${p}.lshed-${process.pid}.tmp`;
+    await fs2.writeFile(tmp, JSON.stringify(next, null, 2) + "\n");
+    await fs2.rename(tmp, p);
+  }
+};
 
 // src/fsutil.ts
-import { promises as fs2 } from "fs";
+import { promises as fs3 } from "fs";
 import { createHash } from "crypto";
-import path2 from "path";
+import path3 from "path";
 
 // src/ignore.ts
 var DEFAULT_IGNORE = [
@@ -198,7 +246,7 @@ function isIgnored(rel, patterns) {
 // src/fsutil.ts
 async function exists(p) {
   try {
-    await fs2.access(p);
+    await fs3.access(p);
     return true;
   } catch {
     return false;
@@ -206,7 +254,7 @@ async function exists(p) {
 }
 async function isDir(p) {
   try {
-    return (await fs2.stat(p)).isDirectory();
+    return (await fs3.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -216,14 +264,14 @@ async function listFiles(root, ignore = DEFAULT_IGNORE) {
   if (!await isDir(root)) return [""];
   const out = [];
   async function walk2(dir, rel) {
-    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
       const r = rel ? `${rel}/${e.name}` : e.name;
       if (isIgnored(r, ignore)) continue;
-      const full = path2.join(dir, e.name);
+      const full = path3.join(dir, e.name);
       let st;
       try {
-        st = await fs2.stat(full);
+        st = await fs3.stat(full);
       } catch {
         continue;
       }
@@ -235,28 +283,28 @@ async function listFiles(root, ignore = DEFAULT_IGNORE) {
   return out.sort();
 }
 async function hashFile(p) {
-  return createHash("sha256").update(await fs2.readFile(p)).digest("hex");
+  return createHash("sha256").update(await fs3.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 fs2.readFile(rel ? path2.join(root, rel) : root)).update("\0");
+    h.update(rel).update("\0").update(await fs3.readFile(rel ? path3.join(root, rel) : root)).update("\0");
   }
   return h.digest("hex");
 }
 async function copyTree(src, dst, ignore = DEFAULT_IGNORE) {
-  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, {
+  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, {
     recursive: true,
     dereference: true,
     filter: async (from) => {
-      const rel = path2.relative(srcRoot, path2.resolve(from)).split(path2.sep).join("/");
+      const rel = path3.relative(srcRoot, path3.resolve(from)).split(path3.sep).join("/");
       if (isIgnored(rel, ignore)) return false;
       try {
-        if ((await fs2.lstat(from)).isSymbolicLink()) await fs2.stat(from);
+        if ((await fs3.lstat(from)).isSymbolicLink()) await fs3.stat(from);
       } catch {
         return false;
       }
@@ -265,15 +313,15 @@ async function copyTree(src, dst, ignore = DEFAULT_IGNORE) {
   });
 }
 async function removeTree(p) {
-  await fs2.rm(p, { recursive: true, force: true });
+  await fs3.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 ? path2.join(local, f) : local;
-    const sp = f ? path2.join(shed, f) : shed;
+    const lp = f ? path3.join(local, f) : local;
+    const sp = f ? path3.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 });
@@ -281,48 +329,6 @@ 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" },
@@ -333,13 +339,42 @@ var CATEGORIES = [
 var ClaudeCodeAdapter = class {
   name = "claude-code";
   root;
-  mcp;
+  entryCats;
   constructor(root) {
     this.root = root ?? process.env.CLAUDE_CONFIG_DIR ?? path4.join(os.homedir(), ".claude");
-    this.mcp = new ClaudeMcpEntries(this.root);
+    const root_ = this.root;
+    this.entryCats = [
+      /**
+       * 사용자 범위 MCP (§7.4): ~/.claude 의 형제 ~/.claude.json 의 mcpServers. CLAUDE_CONFIG_DIR 처럼 루트 안에 있으면 그것.
+       * Claude Code 가 ${VAR} 를 모든 범위에서 스스로 확장하므로 자리표시자를 그대로 둔다.
+       */
+      new JsonEntries({
+        name: "mcp",
+        file: async () => {
+          const inside = path4.join(root_, ".claude.json");
+          return await exists(inside) ? inside : `${root_}.json`;
+        },
+        under: "mcpServers",
+        secretKeys: ["env", "headers"],
+        expandsEnv: true
+      }),
+      /**
+       * settings.json (§7.6): 최상위 키 하나 = 항목 하나 (hooks, permissions, env, model, ...).
+       * 병합하지 않는다. 키를 통째로 소유하고, 로컬 편집은 diff/save 로 되가져온다.
+       * enabledPlugins 는 플러그인 설치기가 만드는 상태라 담지 않는다. ${VAR} 는 Claude Code 가 안 채우므로 restore 가 채운다.
+       */
+      new JsonEntries({
+        name: "settings",
+        file: async () => path4.join(root_, "settings.json"),
+        secretKeys: [],
+        secretRootIds: ["env"],
+        expandsEnv: false,
+        skip: ["enabledPlugins"]
+      })
+    ];
   }
   entries() {
-    return [this.mcp];
+    return this.entryCats;
   }
   categories() {
     return CATEGORIES;
@@ -413,7 +448,7 @@ var resetHard = (dir, sha) => git(["reset", "--hard", "--quiet", sha], dir);
 var pullFf = (dir) => git(["pull", "--ff-only", "--quiet"], dir);
 function runShell(cmd, cwd) {
   return new Promise((resolve, reject) => {
-    const p = spawn("sh", ["-c", cmd], { cwd, stdio: "inherit" });
+    const p = spawn(cmd, { cwd, stdio: "inherit", shell: true });
     p.on("error", reject);
     p.on("close", (code) => code === 0 ? resolve() : reject(new Error(`\uBA85\uB839\uC774 ${code} \uB85C \uB05D\uB0AC\uC2B5\uB2C8\uB2E4: ${cmd}`)));
   });
@@ -609,7 +644,7 @@ async function writeState(adapter, state) {
 // src/core/context.ts
 function spawnExec(cmd, args, cwd) {
   return new Promise((resolve, reject) => {
-    const p = spawn2(cmd, args, { cwd, stdio: "inherit" });
+    const p = spawn2(cmd, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
     p.on("error", reject);
     p.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} ${args.join(" ")} \uAC00 ${code} \uB85C \uB05D\uB0AC\uC2B5\uB2C8\uB2E4`)));
   });
@@ -904,7 +939,9 @@ async function discover(ctx, exclude = []) {
         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 });
+      const owner = kept.find((p) => p.path && JSON.stringify(all2[id]).includes(p.path));
+      const warn = owner ? `\uD328\uD0A4\uC9C0 ${owner.id} \uC548\uC744 \uAC00\uB9AC\uD0B5\uB2C8\uB2E4. \uADF8 \uC124\uCE58\uAC00 \uB9CC\uB4E0 \uAC83\uC774\uBA74 exclude \uD558\uC138\uC694: ${cat.name}/${id}` : void 0;
+      items.push({ kind: "entry", category: cat.name, id, value: all2[id], cat, warn });
     }
   }
   return { items, generated, excluded };
@@ -928,8 +965,12 @@ import { isSeq, isMap } from "yaml";
 
 // src/core/entries.ts
 import { promises as fs10 } from "fs";
+import os2 from "os";
 import path14 from "path";
-var SECRET_KEY_RE = /key|token|secret|pass|auth|credential|cookie|session/i;
+var SECRET_WORDS = /* @__PURE__ */ new Set(["key", "apikey", "token", "secret", "password", "passwd", "auth", "authorization", "credential", "credentials", "cookie", "session"]);
+function isSecretKey(k) {
+  return k.split(/[^A-Za-z0-9]+|(?<=[a-z0-9])(?=[A-Z])/).some((w) => SECRET_WORDS.has(w.toLowerCase()));
+}
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
 function placeholdersIn(v) {
   const out = /* @__PURE__ */ new Set();
@@ -946,27 +987,39 @@ function walk(v, onString, keyPath = []) {
   return v;
 }
 var envName = (...parts) => parts.join("_").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
-function mask(id, entry, cat) {
+function mask(id, entry, cat, home = os2.homedir()) {
+  entry = portable(entry, home);
   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 maskSection = (sect, envLike) => {
     const masked = {};
     for (const [k, v] of Object.entries(sect)) {
-      if (typeof v !== "string" || !SECRET_KEY_RE.test(k) || PLACEHOLDER_RE.test(v)) {
+      if (typeof v !== "string" || !isSecretKey(k) || PLACEHOLDER_RE.test(v)) {
         masked[k] = v;
         PLACEHOLDER_RE.lastIndex = 0;
         continue;
       }
-      const name = sk === "env" ? envName(k) : envName(id, k);
+      const name = envLike ? envName(k) : envName(id, k);
       const scheme = /^(\w+) \S+$/.exec(v);
       masked[k] = scheme ? `${scheme[1]} \${${name}}` : `\${${name}}`;
     }
-    out[sk] = masked;
+    return masked;
+  };
+  if (cat.secretRootIds?.includes(id)) return maskSection(entry, true);
+  const out = { ...entry };
+  for (const sk of cat.secretKeys) {
+    const sect = out[sk];
+    if (!sect || typeof sect !== "object" || Array.isArray(sect)) continue;
+    out[sk] = maskSection(sect, sk === "env");
   }
   return out;
 }
+function portable(entry, home = os2.homedir()) {
+  if (!home || home === "/") return entry;
+  return walk(entry, (s) => s === home || s.startsWith(home + "/") || s.startsWith(home + "\\") ? "${HOME}" + s.slice(home.length) : s);
+}
+function envWithHome(env = process.env) {
+  return { HOME: os2.homedir(), ...env };
+}
 function suspiciousStrings(entry) {
   const out = [];
   walk(entry, (s, kp) => {
@@ -1007,7 +1060,7 @@ function matches2(shed, local) {
   }
   return shed === local;
 }
-function remask(id, local, shed, cat) {
+function remask(id, local, shed, cat, home = os2.homedir()) {
   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]));
@@ -1016,7 +1069,7 @@ function remask(id, local, shed, cat) {
     }
     return l;
   };
-  return mask(id, shed === null ? local : keep(local, shed), cat);
+  return mask(id, shed === null ? local : keep(local, portable(shed, home)), cat, home);
 }
 function diffEntry(shed, local) {
   const out = [];
@@ -1086,9 +1139,10 @@ async function ingest(ctx, doc, profile, items, lock) {
     } 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);
+      const vars = placeholdersIn(masked).filter((v) => v !== "HOME");
       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`);
+      if (f.warn) ctx.log(`    ! ${f.warn}`);
     }
     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 }));
@@ -1173,6 +1227,10 @@ async function restore(ctx, profileArg, opts = {}) {
   if (fragments.length) newManaged.add(instrRel);
   const oldManaged = new Set(state?.managed ?? []);
   const toRemove = [...oldManaged].filter((r) => !newManaged.has(r)).sort();
+  if (state && state.shed !== ctx.shed && toRemove.length) {
+    ctx.log(`! \uB9C8\uC9C0\uB9C9\uC73C\uB85C \uC801\uC6A9\uD55C \uCC3D\uACE0\uAC00 \uB2E4\uB985\uB2C8\uB2E4: ${state.shed}`);
+    ctx.log(`  \uC544\uB798 ${toRemove.length}\uAC1C\uB294 \uADF8 \uCC3D\uACE0\uC758 \uAD00\uB9AC \uBAA9\uB85D\uC5D0 \uC788\uC5B4 \uC81C\uAC70 \uB300\uC0C1\uC785\uB2C8\uB2E4 (\uBC31\uC5C5\uB428). \uC774 \uAE30\uAE30\uC758 \uAC83\uC744 \uC9C0\uD0A4\uB824\uBA74 \uBA3C\uC800 'lshed add' \uB85C \uCC3D\uACE0\uC5D0 \uB123\uC73C\uC138\uC694.`);
+  }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupDir = path17.join(ctx.adapter.root, LSHED_DIR, "backups", stamp);
   const backedUp = [];
@@ -1211,8 +1269,8 @@ async function restore(ctx, profileArg, opts = {}) {
     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);
+      const vars = placeholdersIn(shed).filter((v) => v !== "HOME");
+      const ex = expand(shed, envWithHome());
       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);
@@ -1324,7 +1382,7 @@ async function add(ctx, keys = [], opts = {}) {
     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}` : ""}`);
+      for (const f of c.fresh) ctx.log(`  ${f.kind === "package" ? "\u2261" : " "} ${keyOf(f)}${f.kind === "package" ? `  ${f.pkg.source}` : f.kind === "entry" && f.warn ? `  ! ${f.warn}` : ""}`);
     }
     hint(ctx, c, state.profile);
     return [];
@@ -1380,7 +1438,7 @@ async function status(ctx) {
   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;
+    const missing = shed === null ? [] : expand(shed, envWithHome()).missing;
     if (missing.length) missingEnv.push({ rel: it.rel, vars: missing });
   }
   const fresh = (await candidates(ctx, m, state.profile)).fresh.map(keyOf);
@@ -1553,7 +1611,7 @@ ${removed.length}\uAC1C \uC81C\uAC70. \uCC3D\uACE0\uB97C \uCEE4\uBC0B\uD558\uC13
 }
 
 // src/core/sync.ts
-import os2 from "os";
+import os3 from "os";
 async function sync(ctx, opts = {}) {
   const shed = ctx.shed;
   const push = opts.push ?? true;
@@ -1576,7 +1634,16 @@ async function sync(ctx, opts = {}) {
     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);
+      try {
+        await git(["commit", "--quiet", "-m", msg], shed);
+      } catch (e) {
+        if (/Author identity unknown|Please tell me who you are/.test(e.message)) {
+          throw new Error(`git \uC0AC\uC6A9\uC790 \uC815\uBCF4\uAC00 \uC5C6\uC5B4 \uCEE4\uBC0B\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uD55C \uBC88\uB9CC \uC124\uC815\uD558\uC138\uC694:
+  git config --global user.name "\uC774\uB984"
+  git config --global user.email "\uBA54\uC77C"`);
+        }
+        throw e;
+      }
     }
     res.committed = dirty;
   } else {
@@ -1632,12 +1699,17 @@ function defaultMessage(paths, profile) {
   const head2 = parts.slice(0, 3).join(", ") + (parts.length > 3 ? ` +${parts.length - 3}` : "");
   return `lshed sync: ${head2}
 
-${os2.hostname()}${profile ? ` \xB7 profile ${profile}` : ""}`;
+${os3.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");
+for (const s of [process.stdout, process.stderr]) {
+  s.on("error", (e) => {
+    if (e.code === "EPIPE") process.exit(0);
+  });
+}
 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();
@@ -1648,7 +1720,7 @@ async function ctxFor(cmd) {
   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 = path19.join(os3.homedir(), "lshed");
+  if (!shed && cmd === "init") shed = path19.join(os4.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: path19.resolve(shed), log: (l) => console.log(l), exec: spawnExec };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lshed",
-  "version": "0.6.0",
+  "version": "0.7.2",
   "description": "Portable harness environment manager for coding agents",
   "license": "MIT",
   "author": "leesongheon <leesongheon1209@gmail.com>",
@@ -22,6 +22,7 @@
     "dev": "tsx src/cli.ts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
+    "smoke": "node scripts/smoke.mjs",
     "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
   "keywords": [