@uzysjung/agent-harness 26.153.0 → 26.154.0

package/dist/index.js

@@ -6,7 +6,6 @@ import {
   CLI_BASES,
   CONTINUOUS_SKILLS,
   DEFAULT_OPTIONS,
-  DEV_METHOD_SKILL_IDS,
   EXTERNAL_ASSETS,
   HARNESS_ANCHOR_FILE,
   HARNESS_IMPORT_LINE,
@@ -19,6 +18,7 @@ import {
   RETIRED_SKILL_IDS,
   TRACKS,
   TRACK_AGENTS,
+  UPDATE_GROUPS,
   __commonJS,
   __toESM,
   anyTrack,
@@ -39,6 +39,7 @@ import {
   ensureDir,
   ensureProjectSkeleton,
   experimentalOptInCandidates,
+  extractFrontmatter,
   filterApplicableAssets,
   formatResidentCostLine,
   hasUiTrack,
@@ -51,12 +52,14 @@ import {
   isHarnessOwned,
   isInstallScope,
   isTrack,
+  landsOnDisk,
   legacyInstallLogPath,
   listFilesRecursive,
   mergeExternalFiles,
   readInstallLog,
   renderFillScaffold,
   residentCost,
+  resolveBundleRoot,
   resolveRules,
   resolveScope,
   stripHarnessImport,
@@ -64,7 +67,7 @@ import {
   upsertHarnessImport,
   withContinuousSkillsNote,
   writeInstallLog
-} from "./chunk-OYNSK6QF.js";
+} from "./chunk-242TVGMZ.js";
 
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
@@ -749,7 +752,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "@uzysjung/agent-harness",
-  version: "26.153.0",
+  version: "26.154.0",
   description: "Curate vetted AI-coding skills & plugins by your tech stack \u2014 install only what you need, across Claude Code, Codex, OpenCode & Antigravity",
   type: "module",
   publishConfig: {
@@ -814,6 +817,8 @@ import { fileURLToPath } from "url";
 
 // src/baseline-targets.ts
 init_esm_shims();
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 var BASELINE_KINDS = ["rules", "agents", "hooks", "skills"];
 var BASELINE_PREFIX = "baseline:";
 var PREFIX_BY_KIND = [
@@ -851,6 +856,42 @@ function isBaselineExcluded(target, excluded) {
   const t = classifyBaselineTarget(target);
   return t !== null && excluded.has(t.id);
 }
+var HINT_MAX = 96;
+function clip(text) {
+  const t = text.replace(/\s+/g, " ").trim();
+  return t.length > HINT_MAX ? `${t.slice(0, HINT_MAX - 1)}\u2026` : t;
+}
+function describeBaselineTarget(t, templatesDir = join(resolveBundleRoot(), "templates")) {
+  const file = t.kind === "skills" ? join(templatesDir, "skills", t.name, "SKILL.md") : join(templatesDir, t.kind, `${t.name}.${t.kind === "hooks" ? "sh" : "md"}`);
+  if (!existsSync(file)) return void 0;
+  const content = readFileSync(file, "utf8");
+  if (t.kind === "agents" || t.kind === "skills") {
+    const fm = extractFrontmatter(content) ?? "";
+    const m = /^description:\s*(.+)$/m.exec(fm);
+    const raw = m?.[1]?.trim().replace(/^["']|["']$/g, "");
+    return raw ? clip(raw) : void 0;
+  }
+  if (t.kind === "hooks") {
+    const lines = content.split("\n").slice(1);
+    const comment = [];
+    for (const l of lines) {
+      if (!l.startsWith("#")) break;
+      comment.push(l.replace(/^#\s?/, ""));
+    }
+    return comment.length > 0 ? clip(comment.join(" \xB7 ")) : void 0;
+  }
+  const body = content.split("\n");
+  const heading = body.find((l) => l.startsWith("# "))?.slice(2).trim();
+  const first = body.slice(body.findIndex((l) => l.startsWith("# ")) + 1).find((l) => l.trim() !== "")?.replace(/^[-*]\s+/, "").replace(/\*\*/g, "");
+  if (!heading) return void 0;
+  return clip(first ? `${heading} \xB7 ${first}` : heading);
+}
+function withBaselineHints(targets, templatesDir) {
+  return targets.map((t) => {
+    const hint = describeBaselineTarget(t, templatesDir);
+    return hint ? { ...t, hint } : t;
+  });
+}
 
 // src/cli-targets.ts
 init_esm_shims();
@@ -988,18 +1029,18 @@ function padDisplay(s, width) {
 init_esm_shims();
 import {
   chmodSync as chmodSync3,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename5, dirname as dirname4, join as join12, resolve } from "path";
+import { basename as basename5, dirname as dirname4, join as join13, resolve } from "path";
 
 // src/ci-scaffold.ts
 init_esm_shims();
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 var PYTHON_TRACKS = "data|csr-fastapi|full";
 var VARIANTS = [
   {
@@ -1023,12 +1064,12 @@ function installCiScaffold(ctx) {
   for (const v2 of VARIANTS) {
     if (!v2.applies(ctx.tracks)) continue;
     const relTarget = `.github/workflows/${v2.target}`;
-    const target = join(ctx.projectDir, relTarget);
-    if (existsSync(target)) {
+    const target = join2(ctx.projectDir, relTarget);
+    if (existsSync2(target)) {
       report.skippedExisting.push(relTarget);
       continue;
     }
-    copyFile(join(ctx.harnessRoot, "templates/github-workflows", v2.source), target);
+    copyFile(join2(ctx.harnessRoot, "templates/github-workflows", v2.source), target);
     report.written.push(relTarget);
   }
   return report;
@@ -1039,8 +1080,8 @@ init_esm_shims();
 
 // src/antigravity/transform.ts
 init_esm_shims();
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { basename, join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { basename, join as join6 } from "path";
 
 // src/codex/agents-md.ts
 init_esm_shims();
@@ -1055,8 +1096,8 @@ function renderAgentsMd(params) {
 
 // src/codex/skills.ts
 init_esm_shims();
-import { chmodSync, existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { chmodSync, existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
 function renderBundledSkill(source) {
   const trimmed = source.trimEnd();
   const lines = trimmed.split(/\r?\n/);
@@ -1088,14 +1129,14 @@ function writeBundledSkillDirs(params) {
   const { harnessRoot, projectDir, skillIds, writer } = params;
   const written = [];
   for (const id of skillIds) {
-    const srcDir = join2(harnessRoot, "templates/skills", id);
-    const srcSkill = join2(srcDir, "SKILL.md");
-    if (!existsSync2(srcSkill)) {
+    const srcDir = join3(harnessRoot, "templates/skills", id);
+    const srcSkill = join3(srcDir, "SKILL.md");
+    if (!existsSync3(srcSkill)) {
       continue;
     }
-    const targetDir = join2(projectDir, ".agents", "skills", id);
-    const targetSkill = join2(targetDir, "SKILL.md");
-    if (!writer.write(targetSkill, renderBundledSkill(readFileSync(srcSkill, "utf8")))) {
+    const targetDir = join3(projectDir, ".agents", "skills", id);
+    const targetSkill = join3(targetDir, "SKILL.md");
+    if (!writer.write(targetSkill, renderBundledSkill(readFileSync2(srcSkill, "utf8")))) {
       continue;
     }
     written.push(targetSkill);
@@ -1103,10 +1144,10 @@ function writeBundledSkillDirs(params) {
       if (rel === "SKILL.md") continue;
       if (rel.split("/").some((segment) => segment.startsWith("."))) continue;
       const segments = rel.split("/");
-      const raw = readFileSync(join2(srcDir, ...segments), "utf8");
+      const raw = readFileSync2(join3(srcDir, ...segments), "utf8");
       const ported = rel.endsWith(".md") || rel.endsWith(".sh") ? `${portBody(raw)}
 ` : raw;
-      const target = join2(targetDir, ...segments);
+      const target = join3(targetDir, ...segments);
       if (!writer.write(target, ported, { createInRefresh: true })) continue;
       if (rel.endsWith(".sh")) chmodSync(target, 493);
       written.push(target);
@@ -1117,13 +1158,13 @@ function writeBundledSkillDirs(params) {
 
 // src/owned-write.ts
 init_esm_shims();
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { dirname, relative, sep } from "path";
 
 // src/foreign-slot.ts
 init_esm_shims();
 import { lstatSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var SKILL_SLOT = /^((?:\.claude|\.agents)\/skills\/[^/]+)(?:\/|$)/;
 function occupiedByNonDirectory(path) {
   const stat = lstatSync(path, { throwIfNoEntry: false });
@@ -1132,15 +1173,15 @@ function occupiedByNonDirectory(path) {
 function foreignOwnedTarget(projectDir, rel) {
   const slot = SKILL_SLOT.exec(rel)?.[1];
   if (slot === void 0) return null;
-  if (occupiedByNonDirectory(join3(projectDir, slot))) return slot;
+  if (occupiedByNonDirectory(join4(projectDir, slot))) return slot;
   if (rel !== slot) {
     const parts = rel.slice(slot.length + 1).split("/");
     let cursor = slot;
     for (const part of parts.slice(0, -1)) {
       cursor = `${cursor}/${part}`;
-      if (occupiedByNonDirectory(join3(projectDir, cursor))) return cursor;
+      if (occupiedByNonDirectory(join4(projectDir, cursor))) return cursor;
     }
-    const leaf = lstatSync(join3(projectDir, rel), { throwIfNoEntry: false });
+    const leaf = lstatSync(join4(projectDir, rel), { throwIfNoEntry: false });
     if (leaf !== void 0 && !leaf.isFile()) return rel;
   }
   return null;
@@ -1163,13 +1204,13 @@ function createOwnedWriter(projectDir, baseline, options = {}) {
         return false;
       }
       const digest = hashContent(content);
-      if (!existsSync3(absPath)) {
+      if (!existsSync4(absPath)) {
         if (refreshOnly && !opts?.createInRefresh) return false;
         mkdirSync(dirname(absPath), { recursive: true });
         writeFileSync(absPath, content);
         updated++;
       } else {
-        const current = readFileSync2(absPath, "utf8");
+        const current = readFileSync3(absPath, "utf8");
         if (current !== content) {
           if (!isHarnessOwned(baseline, rel, current)) {
             backupPaths.push(backupFile(absPath, now));
@@ -1196,8 +1237,8 @@ function createOwnedWriter(projectDir, baseline, options = {}) {
 
 // src/rules-port.ts
 init_esm_shims();
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
 function stripClaudeFrontmatter(source) {
   if (!source.startsWith("---\n")) return source.trim();
   const end = source.indexOf("\n---", 4);
@@ -1207,9 +1248,9 @@ function stripClaudeFrontmatter(source) {
 function portRules(harnessRoot, ruleNames) {
   const ported = [];
   for (const name of ruleNames) {
-    const src = join4(harnessRoot, "templates/rules", `${name}.md`);
-    if (!existsSync4(src)) continue;
-    ported.push({ name, body: stripClaudeFrontmatter(readFileSync3(src, "utf8")) });
+    const src = join5(harnessRoot, "templates/rules", `${name}.md`);
+    if (!existsSync5(src)) continue;
+    ported.push({ name, body: stripClaudeFrontmatter(readFileSync4(src, "utf8")) });
   }
   return ported;
 }
@@ -1233,7 +1274,7 @@ function runAntigravityTransform(params) {
   const antigravityInstalled = rulesFile !== null;
   const harnessRuleFiles = [];
   for (const rule of portRules(harnessRoot, rules)) {
-    const target = join5(projectDir, ".agents", "rules", `${rule.name}.md`);
+    const target = join6(projectDir, ".agents", "rules", `${rule.name}.md`);
     if (!writer.write(target, `${rule.body}
 `, { createInRefresh: antigravityInstalled })) {
       continue;
@@ -1254,14 +1295,14 @@ function runAntigravityTransform(params) {
   };
 }
 function writeRules(harnessRoot, projectDir, writer, selectedInternalSkills) {
-  const claudeMdPath = join5(harnessRoot, "templates/CLAUDE.md");
-  const templatePath = join5(harnessRoot, "templates/antigravity/AGENTS.md.template");
-  if (!existsSync5(claudeMdPath) || !existsSync5(templatePath)) {
+  const claudeMdPath = join6(harnessRoot, "templates/CLAUDE.md");
+  const templatePath = join6(harnessRoot, "templates/antigravity/AGENTS.md.template");
+  if (!existsSync6(claudeMdPath) || !existsSync6(templatePath)) {
     return null;
   }
-  const claudeMd = readFileSync4(claudeMdPath, "utf8");
-  const template = readFileSync4(templatePath, "utf8");
-  const target = join5(projectDir, ".agents", "rules", "uzys-harness.md");
+  const claudeMd = readFileSync5(claudeMdPath, "utf8");
+  const template = readFileSync5(templatePath, "utf8");
+  const target = join6(projectDir, ".agents", "rules", "uzys-harness.md");
   const rulesOut = renderAgentsMd({
     template,
     claudeMd,
@@ -1278,18 +1319,18 @@ function writeRules(harnessRoot, projectDir, writer, selectedInternalSkills) {
 // src/codex/opt-in.ts
 init_esm_shims();
 import { homedir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/codex/trust-entry.ts
 init_esm_shims();
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 var TRUST_BLOCK_REGEX = /\[projects\."([^"]+)"\]/g;
 function registerTrustEntry(opts) {
   const { configPath, projectDir } = opts;
   try {
     mkdirSync2(dirname2(configPath), { recursive: true });
-    const existing = existsSync6(configPath) ? readFileSync5(configPath, "utf8") : "";
+    const existing = existsSync7(configPath) ? readFileSync6(configPath, "utf8") : "";
     if (hasTrustEntry(existing, projectDir)) {
       return { status: "already-present" };
     }
@@ -1313,8 +1354,8 @@ function hasTrustEntry(configContent, projectDir) {
 
 // src/codex/opt-in.ts
 function runCodexOptIn(ctx) {
-  const codexHome = ctx.codexHome ?? join6(homedir(), ".codex");
-  const configPath = join6(codexHome, "config.toml");
+  const codexHome = ctx.codexHome ?? join7(homedir(), ".codex");
+  const configPath = join7(codexHome, "config.toml");
   const result = registerTrustEntry({ configPath, projectDir: ctx.projectDir });
   return {
     trustEntry: {
@@ -1327,8 +1368,8 @@ function runCodexOptIn(ctx) {
 
 // src/codex/transform.ts
 init_esm_shims();
-import { chmodSync as chmodSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { basename as basename2, join as join7 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { basename as basename2, join as join8 } from "path";
 
 // src/codex/config-toml.ts
 init_esm_shims();
@@ -1405,12 +1446,12 @@ function runCodexTransform(params) {
     refreshOnly
   } = params;
   const writer = createOwnedWriter(projectDir, baseline, { refreshOnly: refreshOnly ?? false });
-  const claudeMd = readRequired(join7(harnessRoot, "templates/CLAUDE.md"));
-  const agentsTemplate = readRequired(join7(harnessRoot, "templates/codex/AGENTS.md.template"));
-  const configTemplate = readRequired(join7(harnessRoot, "templates/codex/config.toml.template"));
+  const claudeMd = readRequired(join8(harnessRoot, "templates/CLAUDE.md"));
+  const agentsTemplate = readRequired(join8(harnessRoot, "templates/codex/AGENTS.md.template"));
+  const configTemplate = readRequired(join8(harnessRoot, "templates/codex/config.toml.template"));
   const projectName = basename2(projectDir);
-  const mcp = readOptionalJson(join7(harnessRoot, ".mcp.json"));
-  const agentsMdPath = join7(projectDir, "AGENTS.md");
+  const mcp = readOptionalJson(join8(harnessRoot, ".mcp.json"));
+  const agentsMdPath = join8(projectDir, "AGENTS.md");
   ensureDir(projectDir);
   const agentsMdOut = renderAgentsMd({
     template: agentsTemplate,
@@ -1425,7 +1466,7 @@ function runCodexTransform(params) {
     harnessRules: renderRulesBlock(portRules(harnessRoot, rules))
   });
   writer.write(agentsMdPath, agentsMdOut);
-  const configTomlPath = join7(projectDir, ".codex/config.toml");
+  const configTomlPath = join8(projectDir, ".codex/config.toml");
   writer.write(
     configTomlPath,
     renderConfigToml({
@@ -1435,15 +1476,15 @@ function runCodexTransform(params) {
       mcp
     })
   );
-  const hookDir = join7(projectDir, ".codex/hooks");
+  const hookDir = join8(projectDir, ".codex/hooks");
   const hookFiles = [];
   for (const hook of HOOK_NAMES) {
-    const src = join7(harnessRoot, "templates/hooks", `${hook}.sh`);
-    if (!existsSync7(src)) {
+    const src = join8(harnessRoot, "templates/hooks", `${hook}.sh`);
+    if (!existsSync8(src)) {
       continue;
     }
-    const ported = readFileSync6(src, "utf8").replace(ENV_VAR_RENAME, "CODEX_PROJECT_DIR");
-    const target = join7(hookDir, `${hook}.sh`);
+    const ported = readFileSync7(src, "utf8").replace(ENV_VAR_RENAME, "CODEX_PROJECT_DIR");
+    const target = join8(hookDir, `${hook}.sh`);
     if (!writer.write(target, ported)) continue;
     chmodSync2(target, 493);
     hookFiles.push(target);
@@ -1463,17 +1504,17 @@ function runCodexTransform(params) {
   };
 }
 function readRequired(path) {
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     throw new Error(`Codex transform: required source missing: ${path}`);
   }
-  return readFileSync6(path, "utf8");
+  return readFileSync7(path, "utf8");
 }
 function readOptionalJson(path) {
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
@@ -1481,8 +1522,8 @@ function readOptionalJson(path) {
 
 // src/opencode/transform.ts
 init_esm_shims();
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync7, unlinkSync } from "fs";
-import { basename as basename3, join as join8 } from "path";
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync8, unlinkSync } from "fs";
+import { basename as basename3, join as join9 } from "path";
 
 // src/opencode/agents-md.ts
 init_esm_shims();
@@ -1525,15 +1566,15 @@ function runOpencodeTransform(params) {
     refreshOnly
   } = params;
   const writer = createOwnedWriter(projectDir, baseline, { refreshOnly: refreshOnly ?? false });
-  const claudeMd = readRequired2(join8(harnessRoot, "templates/CLAUDE.md"));
-  const agentsTemplate = readRequired2(join8(harnessRoot, "templates/opencode/AGENTS.md.template"));
+  const claudeMd = readRequired2(join9(harnessRoot, "templates/CLAUDE.md"));
+  const agentsTemplate = readRequired2(join9(harnessRoot, "templates/opencode/AGENTS.md.template"));
   const opencodeTemplate = readRequired2(
-    join8(harnessRoot, "templates/opencode/opencode.json.template")
+    join9(harnessRoot, "templates/opencode/opencode.json.template")
   );
   const projectName = basename3(projectDir);
-  const mcp = readOptionalJson2(join8(harnessRoot, ".mcp.json"));
+  const mcp = readOptionalJson2(join9(harnessRoot, ".mcp.json"));
   ensureDir(projectDir);
-  const agentsMdPath = join8(projectDir, "AGENTS.md");
+  const agentsMdPath = join9(projectDir, "AGENTS.md");
   const agentsMdOut = renderAgentsMd2({
     template: agentsTemplate,
     claudeMd,
@@ -1549,7 +1590,7 @@ function runOpencodeTransform(params) {
     harnessRules: renderRulesBlock(portRules(harnessRoot, rules))
   });
   writer.write(agentsMdPath, agentsMdOut);
-  const opencodeJsonPath = join8(projectDir, "opencode.json");
+  const opencodeJsonPath = join9(projectDir, "opencode.json");
   writer.write(opencodeJsonPath, renderOpencodeJson({ template: opencodeTemplate, mcp }));
   const skillFiles = writeBundledSkillDirs({
     harnessRoot,
@@ -1558,13 +1599,13 @@ function runOpencodeTransform(params) {
     writer
   });
   const retiredCommands = [];
-  const cmdDir = join8(projectDir, ".opencode/commands");
-  if (existsSync8(cmdDir)) {
+  const cmdDir = join9(projectDir, ".opencode/commands");
+  if (existsSync9(cmdDir)) {
     for (const entry of readdirSync(cmdDir)) {
       if (!entry.endsWith(".md")) continue;
       const id = entry.slice(0, -3);
-      if (!existsSync8(join8(harnessRoot, "templates/skills", id, "SKILL.md"))) continue;
-      const victim = join8(cmdDir, entry);
+      if (!existsSync9(join9(harnessRoot, "templates/skills", id, "SKILL.md"))) continue;
+      const victim = join9(cmdDir, entry);
       try {
         backupFile(victim);
         unlinkSync(victim);
@@ -1582,17 +1623,17 @@ function runOpencodeTransform(params) {
   };
 }
 function readRequired2(path) {
-  if (!existsSync8(path)) {
+  if (!existsSync9(path)) {
     throw new Error(`OpenCode transform: required source missing: ${path}`);
   }
-  return readFileSync7(path, "utf8");
+  return readFileSync8(path, "utf8");
 }
 function readOptionalJson2(path) {
-  if (!existsSync8(path)) {
+  if (!existsSync9(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -1684,8 +1725,8 @@ function runCliTransforms(params) {
 
 // src/env-files.ts
 init_esm_shims();
-import { appendFileSync, existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9 } from "path";
+import { appendFileSync, existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
 var ENV_EXAMPLE_BODY = `# .env.example \u2014 csr-supabase Track
 # Copy to .env (gitignored) and fill in values: cp .env.example .env
 
@@ -1722,19 +1763,19 @@ function writeEnvExample(projectDir, tracks) {
   if (!tracks.some((t) => ENV_EXAMPLE_TRACKS.includes(t))) {
     return false;
   }
-  const path = join9(projectDir, ".env.example");
-  if (existsSync9(path)) {
+  const path = join10(projectDir, ".env.example");
+  if (existsSync10(path)) {
     return false;
   }
   writeFileSync3(path, ENV_EXAMPLE_BODY);
   return true;
 }
 function addGitignoreEnv(projectDir) {
-  const path = join9(projectDir, ".gitignore");
-  if (!existsSync9(path)) {
+  const path = join10(projectDir, ".gitignore");
+  if (!existsSync10(path)) {
     return false;
   }
-  const content = readFileSync8(path, "utf8");
+  const content = readFileSync9(path, "utf8");
   if (GITIGNORE_ENV_PATTERN.test(content)) {
     return false;
   }
@@ -1748,11 +1789,11 @@ function addGitignoreEnv(projectDir) {
 var AGENT_ARTIFACT_DIRS = [".factory/", ".goose/", ".uzys-agent-harness/"];
 var GITIGNORE_AGENT_ARTIFACT_HEADER = "# agent CLI / harness \uC790\uB3D9 \uC0DD\uC131\uBB3C (auto-added by agent-harness)";
 function addGitignoreAgentArtifacts(projectDir) {
-  const path = join9(projectDir, ".gitignore");
-  if (!existsSync9(path)) {
+  const path = join10(projectDir, ".gitignore");
+  if (!existsSync10(path)) {
     return [];
   }
-  const content = readFileSync8(path, "utf8");
+  const content = readFileSync9(path, "utf8");
   const missing = AGENT_ARTIFACT_DIRS.filter((pattern) => {
     const lineRegex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\//g, "/")}\\s*$`, "m");
     return !lineRegex.test(content);
@@ -1771,10 +1812,14 @@ ${block}
 // src/external-installer.ts
 init_esm_shims();
 import { spawnSync } from "child_process";
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var DEFAULT_SPAWN_TIMEOUT_MS = 12e4;
+var NPM_SPAWN_TIMEOUT_MS = 6e5;
+function spawnTimeoutFor(kind) {
+  return kind === "npm" || kind === "npx-run" ? NPM_SPAWN_TIMEOUT_MS : DEFAULT_SPAWN_TIMEOUT_MS;
+}
 function selectExternalTargets(assets, ctx) {
   const conditionPassed = filterApplicableAssets(assets, ctx).filter(
     (a) => a.method.kind !== "internal"
@@ -1849,8 +1894,8 @@ function installOne(asset, ctx) {
         cwd
       );
     case "shell-script": {
-      const scriptPath = join10(ctx.harnessRoot, method.script);
-      if (!existsSync10(scriptPath)) {
+      const scriptPath = join11(ctx.harnessRoot, method.script);
+      if (!existsSync11(scriptPath)) {
         return {
           asset,
           ok: false,
@@ -1946,8 +1991,17 @@ function installPlugin(asset, spawn, method, scope, cwd) {
   );
 }
 function runSpawn(asset, spawn, cmd, args, cwd) {
-  const result = spawn(cmd, args, spawnOpts(cwd));
+  const timeout = spawnTimeoutFor(asset.method.kind);
+  const result = spawn(cmd, args, spawnOpts(cwd, timeout));
   if (result.error) {
+    const code = result.error.code;
+    if (code === "ETIMEDOUT") {
+      return {
+        asset,
+        ok: false,
+        message: `timed out after ${Math.round(timeout / 1e3)}s \u2014 finish it yourself: ${cmd} ${args.join(" ")}`
+      };
+    }
     return { asset, ok: false, message: result.error.message };
   }
   if ((result.status ?? 1) !== 0) {
@@ -1961,11 +2015,11 @@ function runSpawn(asset, spawn, cmd, args, cwd) {
   }
   return { asset, ok: true };
 }
-function spawnOpts(cwd) {
+function spawnOpts(cwd, timeout = DEFAULT_SPAWN_TIMEOUT_MS) {
   return {
     encoding: "utf8",
     stdio: "pipe",
-    timeout: DEFAULT_SPAWN_TIMEOUT_MS,
+    timeout,
     ...cwd ? { cwd } : {}
   };
 }
@@ -1980,17 +2034,17 @@ function detectVersion(method, spawn) {
         if (at2 <= 0) return void 0;
         const plugin = method.pluginId.slice(0, at2);
         const marketplaceShort = method.pluginId.slice(at2 + 1);
-        const cacheBase = join10(homedir2(), ".claude/plugins/cache", marketplaceShort, plugin);
-        if (!existsSync10(cacheBase)) return void 0;
+        const cacheBase = join11(homedir2(), ".claude/plugins/cache", marketplaceShort, plugin);
+        if (!existsSync11(cacheBase)) return void 0;
         const versions = readdirSync2(cacheBase).filter((v2) => /^\d/.test(v2)).sort();
         return versions.at(-1);
       }
       case "npm": {
         const npmRoot = getNpmGlobalRoot(spawn);
         if (!npmRoot) return void 0;
-        const pkgJson = join10(npmRoot, method.pkg, "package.json");
-        if (!existsSync10(pkgJson)) return void 0;
-        const parsed = JSON.parse(readFileSync9(pkgJson, "utf8"));
+        const pkgJson = join11(npmRoot, method.pkg, "package.json");
+        if (!existsSync11(pkgJson)) return void 0;
+        const parsed = JSON.parse(readFileSync10(pkgJson, "utf8"));
         return parsed.version;
       }
       default:
@@ -2017,7 +2071,7 @@ function getNpmGlobalRoot(spawn) {
 
 // src/mcp-merge.ts
 init_esm_shims();
-import { existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
 function parseTrackMcpMap(raw) {
   const rows = [];
   for (const line of raw.split(/\r?\n/)) {
@@ -2068,15 +2122,15 @@ function mergeMcpServers(base, rows, tracks) {
   return out;
 }
 function composeMcpJson(opts) {
-  const base = JSON.parse(readFileSync10(opts.templateMcpPath, "utf8"));
-  const merged = opts.existingPath && existsSync11(opts.existingPath) ? mergeUserBase(base, opts.existingPath) : base;
-  const mapRaw = existsSync11(opts.trackMapPath) ? readFileSync10(opts.trackMapPath, "utf8") : "";
+  const base = JSON.parse(readFileSync11(opts.templateMcpPath, "utf8"));
+  const merged = opts.existingPath && existsSync12(opts.existingPath) ? mergeUserBase(base, opts.existingPath) : base;
+  const mapRaw = existsSync12(opts.trackMapPath) ? readFileSync11(opts.trackMapPath, "utf8") : "";
   const rows = parseTrackMcpMap(mapRaw);
   return mergeMcpServers(merged, rows, opts.tracks);
 }
 function mergeUserBase(base, existingPath) {
   try {
-    const existing = JSON.parse(readFileSync10(existingPath, "utf8"));
+    const existing = JSON.parse(readFileSync11(existingPath, "utf8"));
     return {
       ...base,
       mcpServers: { ...base.mcpServers, ...existing.mcpServers }
@@ -2094,37 +2148,52 @@ function writeMcpJson(path, mcp) {
 init_esm_shims();
 import {
   copyFileSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
+  rmdirSync,
+  statSync,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync5
 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join11 } from "path";
+import { basename as basename4, dirname as dirname3, join as join12 } from "path";
 var LEGACY_ANCHOR_FILE = ".claude/CLAUDE.md";
-function buildUpdateSpec(projectDir, tracks) {
+function buildUpdateSpec(projectDir, tracks, only) {
   return {
     tracks: [...tracks],
     options: DEFAULT_OPTIONS,
     cli: ["claude"],
     projectDir,
-    scope: readInstallLog(projectDir)?.scope ?? "project"
+    scope: readInstallLog(projectDir)?.scope ?? "project",
+    // 전부 골랐으면 "제한 없음"과 같다 — 화면·기록에 제한이 있었던 것처럼 남기지 않는다.
+    ...only !== void 0 && only.length > 0 && only.length < UPDATE_GROUPS.length ? { updateOnly: [...only] } : {}
   };
 }
-function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}) {
-  const claudeDir = join11(projectDir, ".claude");
+function parseUpdateOnly(raw) {
+  const invalid = raw.filter((v2) => !UPDATE_GROUPS.includes(v2));
+  if (invalid.length > 0) return { ok: false, invalid };
+  return { ok: true, groups: [...new Set(raw)] };
+}
+function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}, only) {
+  const claudeDir = join12(projectDir, ".claude");
+  const startedAt = Date.now();
+  const wants = (g) => only === void 0 || only.includes(g);
   const report = {
     updated: {},
     pruned: {},
     staleHookRefs: [],
     claudeMdUpdated: false,
+    backups: [],
+    skippedGroups: only === void 0 ? [] : UPDATE_GROUPS.filter((g) => !only.includes(g)),
+    anchorBackedUp: false,
     anchorCreated: false,
     rootImportAdded: false,
     rootBlockRefreshed: false,
     legacyAnchor: null,
     skillsBackedUp: [],
     skillsSkippedLinks: [],
+    skillsPruned: [],
     policyBackedUp: [],
     externalUpdated: 0,
     externalBackedUp: [],
@@ -2140,14 +2209,15 @@ function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}) {
     demotedAgents: [],
     mcpAllowlistRetired: null
   };
-  const fresh = installNewAssets(projectDir, templatesDir);
+  const fresh = installNewAssets(projectDir, templatesDir, wants);
   report.installedNew = fresh.installed;
   report.restored = fresh.restored;
   report.needsReinstall = fresh.needsReinstall;
   const policyBase = policyBaseline(projectDir);
   for (const { dir, ext } of POLICY_DIRS) {
-    const target = join11(claudeDir, dir);
-    const source = join11(templatesDir, dir);
+    if (!wants(dir === "hooks" ? "hooks" : "rules")) continue;
+    const target = join12(claudeDir, dir);
+    const source = join12(templatesDir, dir);
     const label = `.claude/${dir}`;
     const ctx = { prefix: dir, baseline: policyBase };
     const synced = updateDir(target, source, ext, ctx);
@@ -2155,30 +2225,38 @@ function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}) {
     report.policyBackedUp.push(...synced.backedUp);
     report.pruned[label] = pruneOrphans(target, source, ext, ctx);
   }
-  refreshPolicyBaseline(projectDir, templatesDir);
-  const skillSync = syncSkills(
-    join11(claudeDir, "skills"),
-    join11(templatesDir, "skills"),
+  const syncedDirs = POLICY_DIRS.filter((d2) => wants(d2.dir === "hooks" ? "hooks" : "rules")).map(
+    (d2) => d2.dir
+  );
+  if (syncedDirs.length > 0) refreshPolicyBaseline(projectDir, templatesDir, syncedDirs);
+  const skillSync = wants("skills") ? syncSkills(
+    join12(claudeDir, "skills"),
+    join12(templatesDir, "skills"),
     skillBaseline(projectDir),
     /* @__PURE__ */ new Date(),
     (relInSkills) => foreignOwnedTarget(projectDir, `.claude/skills/${relInSkills}`)
-  );
-  report.updated[".claude/skills"] = skillSync.updated;
+  ) : { updated: 0, backedUp: [], skippedLinks: [], foreignOwned: [], pruned: [] };
+  if (wants("skills")) report.updated[".claude/skills"] = skillSync.updated;
   report.skillsBackedUp = skillSync.backedUp;
   report.skillsSkippedLinks = skillSync.skippedLinks;
-  refreshSkillBaseline(projectDir);
+  report.skillsPruned = skillSync.pruned;
+  const newSkills = wants("new-skills") ? installNewSkillDirs(projectDir, templatesDir, installedTracks(projectDir)) : { installed: [], foreignOwned: [] };
+  report.installedNew.push(...newSkills.installed);
+  if (wants("skills")) refreshSkillBaseline(projectDir, templatesDir);
+  else if (newSkills.installed.length > 0)
+    recordNewSkillBaseline(projectDir, templatesDir, newSkills.installed);
   const installLog = readInstallLog(projectDir);
-  if (existsSync12(claudeDir) && (installLog === null || installLog.spec.cli.includes("claude"))) {
-    syncHarnessAnchor(projectDir, templatesDir, report);
+  if (existsSync13(claudeDir) && (installLog === null || installLog.spec.cli.includes("claude"))) {
+    if (wants("anchor")) syncHarnessAnchor(projectDir, templatesDir, report);
   }
-  const settingsPath = join11(claudeDir, "settings.json");
-  if (existsSync12(settingsPath)) {
+  const settingsPath = join12(claudeDir, "settings.json");
+  if (wants("hooks") && existsSync13(settingsPath)) {
     report.staleHookRefs = cleanStaleHookRefs(settingsPath, claudeDir);
   }
-  report.mcpAllowlistRetired = retireMcpAllowlist(projectDir);
+  if (wants("hooks")) report.mcpAllowlistRetired = retireMcpAllowlist(projectDir);
   report.retiredAgents = staleAgentFiles(claudeDir);
   report.demotedAgents = demotedAgentFiles(claudeDir, installedTracks(projectDir));
-  const external = refreshExternalCli(projectDir, harnessRoot);
+  const external = wants("external") ? refreshExternalCli(projectDir, harnessRoot) : { externalUpdated: 0, externalBackedUp: [], externalForeignOwned: [] };
   report.externalUpdated = external.externalUpdated;
   report.externalBackedUp = external.externalBackedUp;
   const saidBySlotRow = new Set(report.skillsSkippedLinks.map((id) => `.claude/skills/${id}`));
@@ -2186,12 +2264,13 @@ function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}) {
   for (const f of [
     ...skillSync.foreignOwned,
     ...fresh.foreignOwned,
+    ...newSkills.foreignOwned,
     ...external.externalForeignOwned
   ]) {
     if (!saidBySlotRow.has(f) && !merged.includes(f)) merged.push(f);
   }
   report.foreignOwned = merged;
-  const skillRefresh = (deps.refreshSkills ?? refreshExternalSkills)(projectDir);
+  const skillRefresh = wants("external") ? (deps.refreshSkills ?? refreshExternalSkills)(projectDir) : { attempted: 0, refreshed: 0, failed: [], notInCatalog: [], unknown: false };
   report.externalSkillsRefreshed = skillRefresh.refreshed;
   report.externalSkillsFailed = skillRefresh.failed;
   report.externalSkillsNotInCatalog = [
@@ -2199,29 +2278,31 @@ function runUpdateMode(projectDir, templatesDir, harnessRoot, deps = {}) {
     ...staleSkillDirs(claudeDir).filter((id) => !skillRefresh.notInCatalog.includes(id))
   ];
   report.externalSkillsUnknown = skillRefresh.unknown;
+  report.backups = collectRunBackups(projectDir, startedAt);
+  writeBackupList(projectDir, report.backups);
   return report;
 }
 function staleSkillDirs(claudeDir) {
-  const dir = join11(claudeDir, "skills");
-  if (!existsSync12(dir)) return [];
+  const dir = join12(claudeDir, "skills");
+  if (!existsSync13(dir)) return [];
   const stale = (id) => RENAMED_SKILL_IDS[id] !== void 0 || RETIRED_SKILL_IDS.includes(id);
   return readdirSync3(dir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && stale(e2.name)).map((e2) => e2.name);
 }
 function staleAgentFiles(claudeDir) {
-  const dir = join11(claudeDir, "agents");
-  if (!existsSync12(dir)) return [];
+  const dir = join12(claudeDir, "agents");
+  if (!existsSync13(dir)) return [];
   return readdirSync3(dir, { withFileTypes: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".md")).map((e2) => basename4(e2.name, ".md")).filter((id) => RETIRED_AGENT_IDS.includes(id));
 }
 function demotedAgentFiles(claudeDir, tracks) {
   if (tracks.length === 0) return [];
-  const dir = join11(claudeDir, "agents");
-  if (!existsSync12(dir)) return [];
+  const dir = join12(claudeDir, "agents");
+  if (!existsSync13(dir)) return [];
   const demoted = TRACK_AGENTS.filter(([, pattern]) => !anyTrack(tracks, pattern)).map(
     ([id]) => id
   );
   return readdirSync3(dir, { withFileTypes: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".md")).map((e2) => basename4(e2.name, ".md")).filter((id) => demoted.includes(id));
 }
-function installNewAssets(projectDir, templatesDir) {
+function installNewAssets(projectDir, templatesDir, wants = () => true) {
   const installed = [];
   const restored = [];
   const needsReinstall = [];
@@ -2231,17 +2312,19 @@ function installNewAssets(projectDir, templatesDir) {
   const baselineExcluded = new Set(log?.spec.baselineExclude ?? []);
   const priorBaseline = policyBaseline(projectDir);
   for (const entry of trackOnlyFileAssets(installedTracks(projectDir))) {
+    const group = entry.target.startsWith(".claude/hooks/") || entry.target === ".claude/settings.json" ? "hooks" : "rules";
+    if (!wants(group)) continue;
     if (entry.target === HARNESS_ANCHOR_FILE) continue;
     if (isBaselineExcluded(entry.target, baselineExcluded)) continue;
-    const target = join11(projectDir, entry.target);
+    const target = join12(projectDir, entry.target);
     const foreign = foreignOwnedTarget(projectDir, entry.target);
     if (foreign !== null) {
       if (!foreignOwned.includes(foreign)) foreignOwned.push(foreign);
       continue;
     }
-    if (existsSync12(target)) continue;
-    const source = join11(templatesDir, entry.source);
-    if (!existsSync12(source)) continue;
+    if (existsSync13(target)) continue;
+    const source = join12(templatesDir, entry.source);
+    if (!existsSync13(source)) continue;
     if (entry.target.startsWith(".claude/")) {
       if (!claudeSelected) continue;
       if (entry.target.startsWith(".claude/hooks/") || entry.target === ".claude/settings.json") {
@@ -2257,6 +2340,77 @@ function installNewAssets(projectDir, templatesDir) {
   }
   return { installed, restored, needsReinstall, foreignOwned };
 }
+var BACKUP_SUFFIX = /\.backup-\d{8}T\d{6}(-\d+)?$/;
+var BACKUP_SCAN_DIRS = [".claude", ".codex", ".opencode", ".agents"];
+function collectRunBackups(projectDir, startedAt) {
+  const out = [];
+  const consider = (rel) => {
+    if (!BACKUP_SUFFIX.test(rel)) return;
+    const abs = join12(projectDir, rel);
+    if (statSync(abs).mtimeMs < startedAt - 1e3) return;
+    out.push({ path: rel.replace(BACKUP_SUFFIX, ""), backup: rel });
+  };
+  for (const e2 of readdirSync3(projectDir, { withFileTypes: true }))
+    if (e2.isFile()) consider(e2.name);
+  for (const dir of BACKUP_SCAN_DIRS) {
+    for (const rel of listFilesRecursive(join12(projectDir, dir))) consider(`${dir}/${rel}`);
+  }
+  return out.sort((a, b2) => a.path.localeCompare(b2.path));
+}
+function writeBackupList(projectDir, backups) {
+  const dir = join12(projectDir, ".uzys-agent-harness");
+  const file = join12(dir, "update-backups.json");
+  try {
+    if (backups.length === 0) {
+      if (existsSync13(file)) unlinkSync2(file);
+      return;
+    }
+    if (!existsSync13(dir)) return;
+    writeFileSync5(
+      file,
+      `${JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString(), note: "update \uAC00 \uB0A8\uAE34 \uBC31\uC5C5 \uC30D. \uC6D0\uBCF8(path)\uC740 \uCD5C\uC2E0 \uBC88\uB4E4\uD310, \uBC31\uC5C5(backup)\uC740 \uB2F9\uC2E0\uC758 \uD3B8\uC9D1\uBD84. \uD3B8\uC9D1\uC744 \uC0C8 \uD310\uC5D0 \uB2E4\uC2DC \uC5B9\uC73C\uB824\uBA74 \uB450 \uD30C\uC77C\uC758 diff \uB97C \uBCF4\uB77C.", backups }, null, 2)}
+`
+    );
+  } catch {
+  }
+}
+function installNewSkillDirs(projectDir, templatesDir, tracks) {
+  const installed = [];
+  const foreignOwned = [];
+  const log = readInstallLog(projectDir);
+  const excluded = new Set(log?.spec.baselineExclude ?? []);
+  if (!(log?.spec.cli ?? ["claude"]).includes("claude")) return { installed, foreignOwned };
+  const spec = buildAssetSpec({ tracks, options: DEFAULT_OPTIONS });
+  for (const entry of buildManifest(spec)) {
+    if (entry.type !== "dir" || !entry.target.startsWith(".claude/skills/")) continue;
+    if (!entry.applies(spec) || isBaselineExcluded(entry.target, excluded)) continue;
+    const target = join12(projectDir, entry.target);
+    const foreign = foreignOwnedTarget(projectDir, entry.target);
+    if (foreign !== null) {
+      if (!foreignOwned.includes(foreign)) foreignOwned.push(foreign);
+      continue;
+    }
+    if (existsSync13(target)) continue;
+    const source = join12(templatesDir, entry.source);
+    if (!existsSync13(source)) continue;
+    copyDir(source, target, (rel) => foreignOwnedTarget(projectDir, `${entry.target}/${rel}`));
+    installed.push(entry.target);
+  }
+  return { installed, foreignOwned };
+}
+function recordNewSkillBaseline(projectDir, templatesDir, targets) {
+  const log = readInstallLog(projectDir);
+  if (!log) return;
+  const ids = new Set(targets.map((t) => t.slice(".claude/skills/".length)));
+  const added = collectSkillHashes(projectDir, templatesDir).filter(
+    (f) => ids.has(f.path.split("/")[0] ?? "")
+  );
+  const kept = (log.skillFiles ?? []).filter((f) => !ids.has(f.path.split("/")[0] ?? ""));
+  try {
+    writeInstallLog(projectDir, { ...log, skillFiles: [...kept, ...added] });
+  } catch {
+  }
+}
 function trackOnlyFileAssets(tracks) {
   const base = { tracks, selectedInternalSkills: [] };
   const optedOut = { ...base, withEcc: false, withTauri: false };
@@ -2265,34 +2419,45 @@ function trackOnlyFileAssets(tracks) {
     (e2) => e2.type === "file" && e2.applies(optedOut) && e2.applies(optedIn)
   );
 }
-function syncHarnessAnchor(projectDir, templatesDir, report) {
-  if (existsSync12(join11(projectDir, LEGACY_ANCHOR_FILE))) {
+function syncHarnessAnchor(projectDir, templatesDir, report, now = /* @__PURE__ */ new Date()) {
+  if (existsSync13(join12(projectDir, LEGACY_ANCHOR_FILE))) {
     report.legacyAnchor = LEGACY_ANCHOR_FILE;
   }
-  const templateMd = join11(templatesDir, "CLAUDE.md");
-  if (!existsSync12(templateMd)) return;
-  const anchor = join11(projectDir, HARNESS_ANCHOR_FILE);
-  const existed = existsSync12(anchor);
-  copyFileSync(templateMd, anchor);
+  const templateMd = join12(templatesDir, "CLAUDE.md");
+  if (!existsSync13(templateMd)) return;
+  const anchor = join12(projectDir, HARNESS_ANCHOR_FILE);
+  const existed = existsSync13(anchor);
   if (existed) {
+    const current = readFileSync12(anchor, "utf8");
+    if (current !== readFileSync12(templateMd, "utf8")) {
+      const recorded = readInstallLog(projectDir)?.templates.rootClaudeMd;
+      const owned = recorded?.path === HARNESS_ANCHOR_FILE && hashContent(current) === recorded.sha256;
+      if (!owned) {
+        backupFile(anchor, now);
+        report.anchorBackedUp = true;
+      }
+      copyFileSync(templateMd, anchor);
+    }
     report.claudeMdUpdated = true;
+    recordAnchorBaseline(projectDir, anchor);
     report.rootBlockRefreshed = upsertRootImport(projectDir);
     return;
   }
+  copyFileSync(templateMd, anchor);
   report.anchorCreated = true;
   report.rootImportAdded = upsertRootImport(projectDir);
   recordAnchorBaseline(projectDir, anchor);
 }
 function upsertRootImport(projectDir) {
-  const target = join11(projectDir, "CLAUDE.md");
-  const existing = existsSync12(target) ? readFileSync11(target, "utf8") : null;
+  const target = join12(projectDir, "CLAUDE.md");
+  const existing = existsSync13(target) ? readFileSync12(target, "utf8") : null;
   const next = upsertHarnessImport(existing, {
     projectName: basename4(projectDir),
     tracks: installedTracks(projectDir),
     // ADR-085 — update 는 선택 목록을 인자로 받지 않는다. `syncSkills` 와 같은 판정을 쓴다:
     // `.claude/skills/<id>` 가 있으면 그 스킬은 이 설치가 고른 것이다.
     continuousSkills: CONTINUOUS_SKILLS.map((s) => s.id).filter(
-      (id) => existsSync12(join11(projectDir, ".claude/skills", id))
+      (id) => existsSync13(join12(projectDir, ".claude/skills", id))
     )
   });
   if (next === existing) return false;
@@ -2312,7 +2477,7 @@ function recordAnchorBaseline(projectDir, anchor) {
       ...log.templates,
       rootClaudeMd: {
         path: HARNESS_ANCHOR_FILE,
-        sha256: hashContent(readFileSync11(anchor, "utf8"))
+        sha256: hashContent(readFileSync12(anchor, "utf8"))
       }
     }
   };
@@ -2354,16 +2519,16 @@ function isHarnessOwned2(ctx, rel, current) {
   return isHarnessOwned(ctx.baseline, `${ctx.prefix}/${rel}`, current);
 }
 function updateDir(target, source, ext, ctx, now = /* @__PURE__ */ new Date()) {
-  if (!existsSync12(target) || !existsSync12(source)) return { updated: 0, backedUp: [] };
+  if (!existsSync13(target) || !existsSync13(source)) return { updated: 0, backedUp: [] };
   let updated = 0;
   const backedUp = [];
   for (const file of readdirSync3(target)) {
     if (!file.endsWith(ext)) continue;
-    const targetFile = join11(target, file);
-    const sourceFile = join11(source, file);
-    if (!existsSync12(sourceFile)) continue;
-    const next = readFileSync11(sourceFile, "utf8");
-    const current = readFileSync11(targetFile, "utf8");
+    const targetFile = join12(target, file);
+    const sourceFile = join12(source, file);
+    if (!existsSync13(sourceFile)) continue;
+    const next = readFileSync12(sourceFile, "utf8");
+    const current = readFileSync12(targetFile, "utf8");
     if (current === next) continue;
     if (!isHarnessOwned2(ctx, file, current)) {
       backupFile(targetFile, now);
@@ -2375,35 +2540,36 @@ function updateDir(target, source, ext, ctx, now = /* @__PURE__ */ new Date()) {
   return { updated, backedUp };
 }
 function syncSkills(targetDir, sourceDir, baseline, now = /* @__PURE__ */ new Date(), foreignOf) {
-  if (!existsSync12(targetDir) || !existsSync12(sourceDir))
-    return { updated: 0, backedUp: [], skippedLinks: [], foreignOwned: [] };
+  if (!existsSync13(targetDir) || !existsSync13(sourceDir))
+    return { updated: 0, backedUp: [], skippedLinks: [], foreignOwned: [], pruned: [] };
   let updated = 0;
   const backedUp = [];
   const skippedLinks = [];
   const foreignOwned = [];
+  const pruned = [];
   for (const skill of readdirSync3(sourceDir, { withFileTypes: true })) {
     if (!skill.isDirectory()) continue;
-    const targetSkill = join11(targetDir, skill.name);
+    const targetSkill = join12(targetDir, skill.name);
     if (occupiedByNonDirectory(targetSkill)) {
       skippedLinks.push(skill.name);
       continue;
     }
-    if (!existsSync12(targetSkill)) continue;
-    for (const rel of listFilesRecursive(join11(sourceDir, skill.name))) {
-      const targetFile = join11(targetSkill, rel);
+    if (!existsSync13(targetSkill)) continue;
+    for (const rel of listFilesRecursive(join12(sourceDir, skill.name))) {
+      const targetFile = join12(targetSkill, rel);
       const foreign = foreignOf(`${skill.name}/${rel}`);
       if (foreign !== null) {
         if (!foreignOwned.includes(foreign)) foreignOwned.push(foreign);
         continue;
       }
-      const next = readFileSync11(join11(sourceDir, skill.name, rel), "utf8");
-      if (!existsSync12(targetFile)) {
+      const next = readFileSync12(join12(sourceDir, skill.name, rel), "utf8");
+      if (!existsSync13(targetFile)) {
         mkdirSync3(dirname3(targetFile), { recursive: true });
         writeFileSync5(targetFile, next);
         updated++;
         continue;
       }
-      const current = readFileSync11(targetFile, "utf8");
+      const current = readFileSync12(targetFile, "utf8");
       if (current === next) continue;
       const recorded = baseline.get(`${skill.name}/${rel}`);
       if (recorded === void 0 || hashContent(current) !== recorded) {
@@ -2413,8 +2579,23 @@ function syncSkills(targetDir, sourceDir, baseline, now = /* @__PURE__ */ new Da
       writeFileSync5(targetFile, next);
       updated++;
     }
+    const bundled = new Set(listFilesRecursive(join12(sourceDir, skill.name)));
+    for (const rel of listFilesRecursive(targetSkill)) {
+      if (bundled.has(rel) || basename4(rel).includes(".backup-")) continue;
+      if (foreignOf(`${skill.name}/${rel}`) !== null) continue;
+      const targetFile = join12(targetSkill, rel);
+      const recorded = baseline.get(`${skill.name}/${rel}`);
+      if (recorded === void 0 || hashContent(readFileSync12(targetFile, "utf8")) !== recorded) {
+        backupFile(targetFile, now);
+        backedUp.push(`${skill.name}/${rel}`);
+      }
+      unlinkSync2(targetFile);
+      pruned.push(`${skill.name}/${rel}`);
+      for (let d2 = dirname3(targetFile); d2 !== targetSkill && readdirSync3(d2).length === 0; d2 = dirname3(d2))
+        rmdirSync(d2);
+    }
   }
-  return { updated, backedUp, skippedLinks, foreignOwned };
+  return { updated, backedUp, skippedLinks, foreignOwned, pruned };
 }
 function skillBaseline(projectDir) {
   const log = readInstallLog(projectDir);
@@ -2424,10 +2605,14 @@ function policyBaseline(projectDir) {
   const log = readInstallLog(projectDir);
   return new Map((log?.policyFiles ?? []).map((f) => [f.path, f.sha256]));
 }
-function refreshPolicyBaseline(projectDir, templatesDir) {
+function refreshPolicyBaseline(projectDir, templatesDir, dirs) {
   const log = readInstallLog(projectDir);
   if (!log) return;
-  const policyFiles = collectPolicyHashes(projectDir, templatesDir);
+  const inDirs = (path) => dirs === void 0 || dirs.some((d2) => path.startsWith(`${d2}/`));
+  const policyFiles = [
+    ...(log.policyFiles ?? []).filter((f) => !inDirs(f.path)),
+    ...collectPolicyHashes(projectDir, templatesDir).filter((f) => inDirs(f.path))
+  ];
   const next = { ...log };
   if (policyFiles.length > 0) next.policyFiles = policyFiles;
   else delete next.policyFiles;
@@ -2436,10 +2621,10 @@ function refreshPolicyBaseline(projectDir, templatesDir) {
   } catch {
   }
 }
-function refreshSkillBaseline(projectDir) {
+function refreshSkillBaseline(projectDir, templatesDir) {
   const log = readInstallLog(projectDir);
   if (!log) return;
-  const skillFiles = collectSkillHashes(projectDir);
+  const skillFiles = collectSkillHashes(projectDir, templatesDir);
   const next = { ...log };
   if (skillFiles.length > 0) next.skillFiles = skillFiles;
   else delete next.skillFiles;
@@ -2449,16 +2634,16 @@ function refreshSkillBaseline(projectDir) {
   }
 }
 function pruneOrphans(target, source, ext, ctx, now = /* @__PURE__ */ new Date()) {
-  if (!existsSync12(target) || !existsSync12(source)) return [];
+  if (!existsSync13(target) || !existsSync13(source)) return [];
   const removed = [];
   for (const file of readdirSync3(target)) {
     if (!file.endsWith(ext)) continue;
-    const sourceFile = join11(source, file);
-    if (!existsSync12(sourceFile)) {
-      const targetFile = join11(target, file);
+    const sourceFile = join12(source, file);
+    if (!existsSync13(sourceFile)) {
+      const targetFile = join12(target, file);
       if (!ctx.baseline.has(`${ctx.prefix}/${file}`)) continue;
       try {
-        const current = readFileSync11(targetFile, "utf8");
+        const current = readFileSync12(targetFile, "utf8");
         if (!isHarnessOwned2(ctx, file, current)) backupFile(targetFile, now);
         unlinkSync2(targetFile);
         removed.push(file);
@@ -2469,8 +2654,8 @@ function pruneOrphans(target, source, ext, ctx, now = /* @__PURE__ */ new Date()
   return removed;
 }
 function retireMcpAllowlist(projectDir, now = /* @__PURE__ */ new Date()) {
-  const target = join11(projectDir, ".mcp-allowlist");
-  if (!existsSync12(target)) return null;
+  const target = join12(projectDir, ".mcp-allowlist");
+  if (!existsSync13(target)) return null;
   try {
     const backup = backupFile(target, now);
     unlinkSync2(target);
@@ -2482,7 +2667,7 @@ function retireMcpAllowlist(projectDir, now = /* @__PURE__ */ new Date()) {
 function cleanStaleHookRefs(settingsPath, claudeDir) {
   let settings;
   try {
-    settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
+    settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
   } catch {
     return [];
   }
@@ -2509,7 +2694,7 @@ function cleanStaleHookRefs(settingsPath, claudeDir) {
 function keepHookRef(hook, claudeDir, removed) {
   const relPath = projectAnchoredRef(hook?.command ?? "", claudeDir);
   if (relPath === void 0) return true;
-  const exists = existsSync12(join11(claudeDir, relPath));
+  const exists = existsSync13(join12(claudeDir, relPath));
   if (!exists && !removed.includes(relPath)) removed.push(relPath);
   return exists;
 }
@@ -2536,14 +2721,14 @@ function projectAnchoredRef(command, claudeDir) {
 function runInstall(ctx) {
   const { harnessRoot, projectDir, spec } = ctx;
   const mode = ctx.mode ?? "fresh";
-  const templatesDir = join12(harnessRoot, "templates");
-  if (!existsSync13(templatesDir)) {
+  const templatesDir = join13(harnessRoot, "templates");
+  if (!existsSync14(templatesDir)) {
     throw new Error(`Templates dir not found: ${templatesDir}`);
   }
-  const claudeDir = join12(projectDir, ".claude");
+  const claudeDir = join13(projectDir, ".claude");
   const previousLog = readInstallLog(projectDir);
   const claudeWasSelected = previousLog?.spec.cli.includes("claude") ?? false;
-  if (mode === "update" && !existsSync13(claudeDir) && (previousLog === null || claudeWasSelected)) {
+  if (mode === "update" && !existsSync14(claudeDir) && (previousLog === null || claudeWasSelected)) {
     throw new Error(
       claudeWasSelected ? `Update mode found a broken install at ${projectDir} \u2014 this project installed Claude Code assets but \`.claude/\` is gone. Reinstall instead: agent-harness install --track <name>` : `Update mode requires an existing install at ${projectDir}`
     );
@@ -2628,9 +2813,9 @@ function runInstall(ctx) {
 }
 function healStaleHookRefs(spec, projectDir) {
   if (!spec.cli.includes("claude")) return [];
-  const settingsPath = join12(projectDir, ".claude/settings.json");
-  if (!existsSync13(settingsPath)) return [];
-  return cleanStaleHookRefs(settingsPath, join12(projectDir, ".claude"));
+  const settingsPath = join13(projectDir, ".claude/settings.json");
+  if (!existsSync14(settingsPath)) return [];
+  return cleanStaleHookRefs(settingsPath, join13(projectDir, ".claude"));
 }
 function resolveBackupPath(ctx, mode, claudeDir) {
   const wantBackup = ctx.backup ?? (mode === "update" || mode === "reinstall");
@@ -2638,7 +2823,13 @@ function resolveBackupPath(ctx, mode, claudeDir) {
   return mode === "update" ? copyBackupDir(claudeDir) : backupDir(claudeDir);
 }
 function runUpdateInstall(ctx, templatesDir, backupPath) {
-  const updateReport = runUpdateMode(ctx.projectDir, templatesDir, ctx.harnessRoot);
+  const updateReport = runUpdateMode(
+    ctx.projectDir,
+    templatesDir,
+    ctx.harnessRoot,
+    {},
+    ctx.spec.updateOnly
+  );
   const baseline = {
     filesCopied: 0,
     dirsCopied: 0,
@@ -2696,12 +2887,12 @@ function installCliNeutralAssets(manifestSpec, projectDir, templatesDir, baselin
       continue;
     }
     if (!isCliNeutralTarget(entry.target)) continue;
-    const source = join12(templatesDir, entry.source);
-    if (!existsSync13(source)) {
+    const source = join13(templatesDir, entry.source);
+    if (!existsSync14(source)) {
       result.skipped += 1;
       continue;
     }
-    copyFile(source, join12(projectDir, entry.target));
+    copyFile(source, join13(projectDir, entry.target));
     result.filesCopied += 1;
   }
   return result;
@@ -2713,9 +2904,9 @@ function backupEditedPolicyFile(entryTarget, target, source, baseline) {
   if (!POLICY_DIRS.some(({ dir, ext }) => rel.startsWith(`${dir}/`) && rel.endsWith(ext))) {
     return null;
   }
-  if (!existsSync13(target)) return null;
-  const current = readFileSync12(target, "utf-8");
-  if (current === readFileSync12(source, "utf-8")) return null;
+  if (!existsSync14(target)) return null;
+  const current = readFileSync13(target, "utf-8");
+  if (current === readFileSync13(source, "utf-8")) return null;
   const recorded = baseline.get(rel);
   if (recorded !== void 0 && recorded === hashContent(current)) return null;
   return backupFile(target);
@@ -2728,14 +2919,14 @@ function installClaudeBaseline(manifestSpec, projectDir, templatesDir, policyBas
     if (!entry.applies(manifestSpec)) {
       continue;
     }
-    const target = join12(projectDir, entry.target);
+    const target = join13(projectDir, entry.target);
     if (isBaselineExcluded(entry.target, baselineExcluded)) {
       result.excluded.push(entry.target);
-      if (existsSync13(target)) result.excludedOnDisk.push(entry.target);
+      if (existsSync14(target)) result.excludedOnDisk.push(entry.target);
       continue;
     }
-    const source = join12(templatesDir, entry.source);
-    if (!existsSync13(source)) {
+    const source = join13(templatesDir, entry.source);
+    if (!existsSync14(source)) {
       result.skipped += 1;
       continue;
     }
@@ -2746,7 +2937,7 @@ function installClaudeBaseline(manifestSpec, projectDir, templatesDir, policyBas
     }
     if (entry.type === "file") {
       if (entry.target === ".claude/settings.json") {
-        const backup = backupFileIfChanged(target, readFileSync12(source, "utf-8"));
+        const backup = backupFileIfChanged(target, readFileSync13(source, "utf-8"));
         if (backup) {
           result.backups.push(backup);
         }
@@ -2770,8 +2961,8 @@ function installClaudeBaseline(manifestSpec, projectDir, templatesDir, policyBas
     }
     accumulateCategory(result.categories, entry);
   }
-  const hookDir = join12(projectDir, ".claude/hooks");
-  if (existsSync13(hookDir)) {
+  const hookDir = join13(projectDir, ".claude/hooks");
+  if (existsSync14(hookDir)) {
     chmodHooksSync(hookDir);
   }
   writeInstalledTracks(projectDir, manifestSpec.tracks);
@@ -2785,9 +2976,9 @@ function installClaudeBaseline(manifestSpec, projectDir, templatesDir, policyBas
   return result;
 }
 function harnessAnchorLog(projectDir) {
-  const anchor = join12(projectDir, HARNESS_ANCHOR_FILE);
-  if (!existsSync13(anchor)) return null;
-  return { path: HARNESS_ANCHOR_FILE, sha256: hashContent(readFileSync12(anchor, "utf-8")) };
+  const anchor = join13(projectDir, HARNESS_ANCHOR_FILE);
+  if (!existsSync14(anchor)) return null;
+  return { path: HARNESS_ANCHOR_FILE, sha256: hashContent(readFileSync13(anchor, "utf-8")) };
 }
 function writeEnvironmentFiles(projectDir, tracks) {
   return {
@@ -2845,8 +3036,8 @@ function writeInstallLogSafe(ctx, externalFiles, external, rootClaudeMdLog, prev
       claudeDirMovedAside,
       rootFiles
     );
-    const skillFiles = collectSkillHashes(ctx.projectDir);
-    const policyFiles = collectPolicyHashes(ctx.projectDir, join12(ctx.harnessRoot, "templates"));
+    const skillFiles = collectSkillHashes(ctx.projectDir, join13(ctx.harnessRoot, "templates"));
+    const policyFiles = collectPolicyHashes(ctx.projectDir, join13(ctx.harnessRoot, "templates"));
     const merged = mergeExternalFiles(ctx.projectDir, previousLog?.externalFiles, externalFiles);
     writeInstallLog(ctx.projectDir, {
       ...log,
@@ -2862,11 +3053,11 @@ function writeInstallLogSafe(ctx, externalFiles, external, rootClaudeMdLog, prev
   }
 }
 function composeAndWriteMcp(harnessRoot, projectDir, spec) {
-  const mcpPath = join12(projectDir, ".mcp.json");
-  const created = !existsSync13(mcpPath);
+  const mcpPath = join13(projectDir, ".mcp.json");
+  const created = !existsSync14(mcpPath);
   const composed = composeMcpJson({
-    templateMcpPath: join12(harnessRoot, "templates/mcp.json"),
-    trackMapPath: join12(harnessRoot, "templates/track-mcp-map.tsv"),
+    templateMcpPath: join13(harnessRoot, "templates/mcp.json"),
+    trackMapPath: join13(harnessRoot, "templates/track-mcp-map.tsv"),
     existingPath: mcpPath,
     tracks: spec.tracks
   });
@@ -2919,15 +3110,15 @@ function accumulateCategory(cats, entry) {
   }
 }
 function writeInstalledTracks(projectDir, tracks) {
-  const path = join12(projectDir, ".claude/.installed-tracks");
+  const path = join13(projectDir, ".claude/.installed-tracks");
   mkdirSync4(dirname4(path), { recursive: true });
   const sorted = [...new Set(tracks)].sort().join("\n");
   writeFileSync6(path, `${sorted}
 `);
 }
 function writeRootClaudeMd(projectDir, tracks, continuousSkills) {
-  const target = join12(projectDir, "CLAUDE.md");
-  const existing = existsSync13(target) ? readFileSync12(target, "utf-8") : null;
+  const target = join13(projectDir, "CLAUDE.md");
+  const existing = existsSync14(target) ? readFileSync13(target, "utf-8") : null;
   const content = upsertHarnessImport(existing, {
     projectName: basename5(projectDir),
     tracks,
@@ -2952,8 +3143,8 @@ function listHookFiles(hookDir) {
 
 // src/commands/install-render.ts
 init_esm_shims();
-import { existsSync as existsSync14, readdirSync as readdirSync5 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5 } from "fs";
+import { join as join14 } from "path";
 
 // src/preset-recommend.ts
 init_esm_shims();
@@ -3022,7 +3213,11 @@ function renderInstallHeader(log, spec, mode) {
     if (mode !== "update") {
       const assetSpec = buildManifestSpec(spec);
       const cost = formatResidentCostLine(
-        residentCost(buildManifest(assetSpec).filter((e2) => e2.applies(assetSpec))),
+        residentCost(
+          buildManifest(assetSpec).filter(
+            (e2) => e2.applies(assetSpec) && landsOnDisk(e2.target, spec.cli)
+          )
+        ),
         summarizeContextCost(finalAssets).unmeasuredCount
       );
       if (cost) log(`              ${c.dim(`\xB7 ${cost}`)}`);
@@ -3071,6 +3266,10 @@ function createInstallRenderer(log, spec, verbose) {
           log(`  ${c.bold(`\u2501\u2501 ${CATEGORY_TITLES[asset.category]} \u2501\u2501`)}`);
           currentCategory = asset.category;
         }
+        if (asset.method.kind === "npm" || asset.method.kind === "npx-run") {
+          const what = asset.method.kind === "npm" ? `npm install ${asset.method.pkg}@${asset.method.version}` : `npx ${asset.method.cmd}@${asset.method.version}`;
+          log(`  ${c.dim(`\u2026 ${asset.id}  ${what} \u2014 running, may take a few minutes`)}`);
+        }
       },
       onAssetResult: (result) => {
         const meta = result.ok ? formatAssetMeta(result.asset, result.version) : result.message ?? "failed";
@@ -3095,18 +3294,33 @@ function renderUpdateSummary(log, spec, report) {
     summarizeContextCost(finalSelectedAssets(spec.tracks, spec.userOverride)).unmeasuredCount
   );
   if (cost) log(infoRow("CONTEXT", cost));
+  const backups = report.updateMode?.backups ?? [];
+  if (backups.length > 0) {
+    log(
+      infoRow(
+        "BACKUPS",
+        `${backups.length} edited file(s) kept as *.backup-<time> \xB7 list: .uzys-agent-harness/update-backups.json`
+      )
+    );
+    log(
+      infoRow(
+        "NEXT",
+        'to re-apply your edits on the new version, ask audit-harness-fit: "update \uBC31\uC5C5\uBCF8\uC758 \uB0B4 \uD3B8\uC9D1\uC744 \uC0C8 \uD310\uC5D0 \uB2E4\uC2DC \uC5B9\uC5B4\uC918"'
+      )
+    );
+  }
   log("");
 }
 function residentEntriesOnDisk(spec) {
   const assetSpec = buildManifestSpec(spec);
   const planned = buildManifest(assetSpec).filter((e2) => e2.applies(assetSpec));
-  const agentsDir = join13(spec.projectDir, ".claude", "agents");
-  const onDisk = existsSync14(agentsDir) ? readdirSync5(agentsDir, { withFileTypes: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".md")).map((e2) => ({
+  const agentsDir = join14(spec.projectDir, ".claude", "agents");
+  const onDisk = existsSync15(agentsDir) ? readdirSync5(agentsDir, { withFileTypes: true }).filter((e2) => e2.isFile() && e2.name.endsWith(".md")).map((e2) => ({
     source: `agents/${e2.name}`,
     target: `.claude/agents/${e2.name}`,
     // 배포판이 아니라 **이 프로젝트의 파일**을 잰다 — 사용자가 고친 descriptor 도,
     // 배포판에 더는 없는 에이전트도 실제로 상주하는 것은 이쪽이다.
-    file: join13(agentsDir, e2.name)
+    file: join14(agentsDir, e2.name)
   })) : [];
   return [...planned.filter((e2) => !e2.target.startsWith(".claude/agents/")), ...onDisk];
 }
@@ -3314,9 +3528,27 @@ function renderPhase1Rows(log, baseline, verbose = false, withEcc = false, claud
         log(assetRow("skip", `${dir} orphan prune`, `${removed.length} removed`));
       }
     }
+    if (baseline.updateMode.skippedGroups.length > 0) {
+      log(
+        assetRow(
+          "skip",
+          "not selected \u2014 untouched",
+          `${baseline.updateMode.skippedGroups.join(", ")} \xB7 run again with --only or the wizard to include`
+        )
+      );
+    }
     if (baseline.updateMode.claudeMdUpdated) {
       log(assetRow("success", HARNESS_ANCHOR_FILE, "refreshed from template"));
     }
+    if (baseline.updateMode.anchorBackedUp) {
+      log(
+        assetRow(
+          "skip",
+          `${HARNESS_ANCHOR_FILE} edited`,
+          "your edits backed up as *.backup-<time> \u2014 latest template is now active"
+        )
+      );
+    }
     if (baseline.updateMode.anchorCreated) {
       log(assetRow("success", HARNESS_ANCHOR_FILE, "created from template (anchor migration)"));
     }
@@ -3350,6 +3582,15 @@ function renderPhase1Rows(log, baseline, verbose = false, withEcc = false, claud
         )
       );
     }
+    if (baseline.updateMode.skillsPruned.length > 0) {
+      log(
+        assetRow(
+          "success",
+          ".claude/skills not in bundle",
+          `${baseline.updateMode.skillsPruned.length} files deleted \xB7 ${baseline.updateMode.skillsPruned.join(", ")}`
+        )
+      );
+    }
     if (baseline.updateMode.skillsSkippedLinks.length > 0) {
       log(
         assetRow(
@@ -3844,8 +4085,8 @@ function registerInstallCommand(cli2) {
 
 // src/commands/list.ts
 init_esm_shims();
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
-import { join as join14, resolve as resolve3 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { join as join15, resolve as resolve3 } from "path";
 function listAction(options = {}, deps = {}) {
   const log = deps.log ?? console.log;
   const err = deps.err ?? console.error;
@@ -3908,8 +4149,8 @@ function formatTemplateRows(log, projectDir) {
   const rows = [`    ${c.dim(dirs.join("  "))}`];
   const rootMd = log.templates.rootClaudeMd;
   if (rootMd) {
-    const path = join14(projectDir, rootMd.path);
-    const modified = existsSync15(path) && hashContent(readFileSync13(path, "utf8")) !== rootMd.sha256;
+    const path = join15(projectDir, rootMd.path);
+    const modified = existsSync16(path) && hashContent(readFileSync14(path, "utf8")) !== rootMd.sha256;
     rows.push(
       modified ? `    ${c.dim(rootMd.path)}  ${c.yellow("(\uC218\uC815\uB428 \u2014 uninstall \uC2DC \uBCF4\uC874)")}` : `    ${c.dim(rootMd.path)}`
     );
@@ -3917,7 +4158,7 @@ function formatTemplateRows(log, projectDir) {
   return rows;
 }
 function formatRootFileRows(rootFiles, projectDir) {
-  const present = rootFiles.filter((f) => existsSync15(join14(projectDir, f.path)));
+  const present = rootFiles.filter((f) => existsSync16(join15(projectDir, f.path)));
   const width = Math.max(0, ...present.map((f) => f.path.length));
   return present.map(
     (f) => `    ${c.dim(padDisplay(f.path, width))}  ${c.dim(f.change === "created" ? "\uC0DD\uC131" : "\uBCD1\uD569")}  ${c.dim(f.notes.join(" / "))}`
@@ -3935,15 +4176,15 @@ function registerListCommand(cli2) {
 init_esm_shims();
 import { spawnSync as spawnSync2 } from "child_process";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   lstatSync as lstatSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync14,
-  rmdirSync,
+  readFileSync as readFileSync15,
+  rmdirSync as rmdirSync2,
   rmSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname5, join as join15, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
+import { dirname as dirname5, join as join16, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 
 // src/uninstall-interactive.ts
 init_esm_shims();
@@ -5183,7 +5424,7 @@ function settleLog(ctx, io) {
       return true;
     }
   } else {
-    io.rm(join15(projectDir, INSTALL_LOG_DIR));
+    io.rm(join16(projectDir, INSTALL_LOG_DIR));
     io.rm(legacyInstallLogPath(projectDir));
     io.log(`  ${status.success("install log removed")}`);
   }
@@ -5233,7 +5474,7 @@ function advisoryLines(plan, projectDir, rootFiles) {
   return lines;
 }
 function rootFileAdvisoryLines(rootFiles, projectDir) {
-  const present = rootFiles.filter((f) => existsSync16(join15(projectDir, f.path)));
+  const present = rootFiles.filter((f) => existsSync17(join16(projectDir, f.path)));
   if (present.length === 0) return [];
   return [
     "",
@@ -5334,16 +5575,16 @@ function buildGlobalAdvisoryCmd(asset) {
   }
 }
 function removeTemplates(log, projectDir, rm) {
-  rm(join15(projectDir, log.templates.claudeDir));
-  if (log.templates.codexDir) rm(join15(projectDir, log.templates.codexDir));
-  if (log.templates.opencodeDir) rm(join15(projectDir, log.templates.opencodeDir));
+  rm(join16(projectDir, log.templates.claudeDir));
+  if (log.templates.codexDir) rm(join16(projectDir, log.templates.codexDir));
+  if (log.templates.opencodeDir) rm(join16(projectDir, log.templates.opencodeDir));
   const external = removeExternalFiles(log, projectDir, rm);
   const importStripped = stripRootImport(projectDir);
   const rootMd = log.templates.rootClaudeMd;
   if (rootMd) {
     if (rootClaudeMdModified(log, projectDir))
       return { rootClaudeMdKept: true, importStripped, external };
-    rm(join15(projectDir, rootMd.path));
+    rm(join16(projectDir, rootMd.path));
   }
   return { rootClaudeMdKept: false, importStripped, external };
 }
@@ -5351,17 +5592,17 @@ function removeExternalFiles(log, projectDir, rm) {
   const removed = [];
   const kept = [];
   for (const { path, sha256 } of log.externalFiles ?? []) {
-    const abs = join15(projectDir, path);
-    if (!existsSync16(abs)) continue;
+    const abs = join16(projectDir, path);
+    if (!existsSync17(abs)) continue;
     if (!lstatSync2(abs).isFile()) continue;
-    if (hashContent(readFileSync14(abs, "utf8")) !== sha256) {
+    if (hashContent(readFileSync15(abs, "utf8")) !== sha256) {
       kept.push(path);
       continue;
     }
     rm(abs);
     removed.push(path);
   }
-  for (const path of removed) pruneEmptyDirsUpward(projectDir, dirname5(join15(projectDir, path)));
+  for (const path of removed) pruneEmptyDirsUpward(projectDir, dirname5(join16(projectDir, path)));
   return { removed, kept };
 }
 function pruneEmptyDirsUpward(projectDir, startDir) {
@@ -5371,7 +5612,7 @@ function pruneEmptyDirsUpward(projectDir, startDir) {
     if (rel === "" || rel.startsWith(`..${sep2}`) || rel === "..") return;
     try {
       if (readdirSync6(cursor).length > 0) return;
-      rmdirSync(cursor);
+      rmdirSync2(cursor);
     } catch {
       return;
     }
@@ -5383,7 +5624,7 @@ function stripRootImport(projectDir) {
   const stripped = current === null ? null : stripHarnessImport(current);
   if (stripped === null) return false;
   try {
-    writeFileSync7(join15(projectDir, "CLAUDE.md"), stripped, "utf8");
+    writeFileSync7(join16(projectDir, "CLAUDE.md"), stripped, "utf8");
     return true;
   } catch {
     return false;
@@ -5393,9 +5634,9 @@ function previewExternalLines(installLog, projectDir) {
   const lines = [];
   let removable = 0;
   for (const { path, sha256 } of installLog.externalFiles ?? []) {
-    const abs = join15(projectDir, path);
-    if (!existsSync16(abs)) continue;
-    if (hashContent(readFileSync14(abs, "utf8")) !== sha256) {
+    const abs = join16(projectDir, path);
+    if (!existsSync17(abs)) continue;
+    if (hashContent(readFileSync15(abs, "utf8")) !== sha256) {
       lines.push(`  \u25CB keep ${path} (modified since install \u2014 preserved)`);
       continue;
     }
@@ -5421,10 +5662,10 @@ function hasRootImport(projectDir) {
   return current !== null && stripHarnessImport(current) !== null;
 }
 function readRootClaudeMd(projectDir) {
-  const path = join15(projectDir, "CLAUDE.md");
-  if (!existsSync16(path)) return null;
+  const path = join16(projectDir, "CLAUDE.md");
+  if (!existsSync17(path)) return null;
   try {
-    return readFileSync14(path, "utf8");
+    return readFileSync15(path, "utf8");
   } catch {
     return null;
   }
@@ -5432,9 +5673,9 @@ function readRootClaudeMd(projectDir) {
 function rootClaudeMdModified(log, projectDir) {
   const rootMd = log.templates.rootClaudeMd;
   if (!rootMd) return false;
-  const path = join15(projectDir, rootMd.path);
-  if (!existsSync16(path)) return false;
-  return hashContent(readFileSync14(path, "utf8")) !== rootMd.sha256;
+  const path = join16(projectDir, rootMd.path);
+  if (!existsSync17(path)) return false;
+  return hashContent(readFileSync15(path, "utf8")) !== rootMd.sha256;
 }
 function formatTemplateList(log) {
   const items = [log.templates.claudeDir];
@@ -5446,7 +5687,7 @@ function defaultSpawn2(cmd, args) {
   return spawnSync2(cmd, [...args], { encoding: "utf8", stdio: "pipe", timeout: 12e4 });
 }
 function defaultRm(path) {
-  if (existsSync16(path)) {
+  if (existsSync17(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
@@ -5494,8 +5735,8 @@ import { resolve as resolve5 } from "path";
 
 // src/state.ts
 init_esm_shims();
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
+import { join as join17 } from "path";
 var META_FILE = ".claude/.installed-tracks";
 var LEGACY_SIGNATURES = [
   { rule: "htmx.md", track: "ssr-htmx" },
@@ -5505,11 +5746,11 @@ var LEGACY_SIGNATURES = [
   { rule: "cli-development.md", track: "tooling" }
 ];
 function detectInstallState(projectDir) {
-  const claudeDir = join16(projectDir, ".claude");
-  const hasClaudeDir = existsSync17(claudeDir);
+  const claudeDir = join17(projectDir, ".claude");
+  const hasClaudeDir = existsSync18(claudeDir);
   if (hasClaudeDir) {
-    const metaPath = join16(projectDir, META_FILE);
-    if (existsSync17(metaPath)) {
+    const metaPath = join17(projectDir, META_FILE);
+    if (existsSync18(metaPath)) {
       const tracks2 = readMetafile(metaPath);
       return { state: "existing", tracks: tracks2, source: "metafile", hasClaudeDir: true };
     }
@@ -5531,7 +5772,7 @@ function tracksFromLog(tracks) {
   return [...new Set(tracks.filter(isTrack))].sort();
 }
 function readMetafile(path) {
-  const raw = readFileSync15(path, "utf8");
+  const raw = readFileSync16(path, "utf8");
   const seen = /* @__PURE__ */ new Set();
   for (const line of raw.split(/\s+/)) {
     const trimmed = line.trim();
@@ -5542,13 +5783,13 @@ function readMetafile(path) {
   return [...seen].sort();
 }
 function inferFromLegacySignatures(projectDir) {
-  const rulesDir = join16(projectDir, ".claude/rules");
-  if (!existsSync17(rulesDir)) {
+  const rulesDir = join17(projectDir, ".claude/rules");
+  if (!existsSync18(rulesDir)) {
     return [];
   }
   const found = /* @__PURE__ */ new Set();
   for (const sig of LEGACY_SIGNATURES) {
-    if (existsSync17(join16(rulesDir, sig.rule))) {
+    if (existsSync18(join17(rulesDir, sig.rule))) {
       found.add(sig.track);
     }
   }
@@ -5570,8 +5811,21 @@ function updateAction(options = {}, deps = {}) {
     exit(1);
     return;
   }
+  const rawOnly = options.only === void 0 ? [] : [options.only].flat().map((v2) => typeof v2 === "string" ? v2 : "(missing value)");
+  const parsed = parseUpdateOnly(rawOnly);
+  if (!parsed.ok) {
+    err(status.failure(c.red(`Unknown --only value: ${parsed.invalid.join(", ")}`)));
+    err(c.dim(`  Valid groups: ${UPDATE_GROUPS.join(" | ")}`));
+    exit(1);
+    return;
+  }
   log(c.dim(`Updating installed harness files in ${projectDir}`));
-  execute(buildUpdateSpec(projectDir, state.tracks), { log, err, exit, mode: "update" });
+  execute(buildUpdateSpec(projectDir, state.tracks, parsed.groups), {
+    log,
+    err,
+    exit,
+    mode: "update"
+  });
 }
 function registerUpdateCommand(cli2) {
   cli2.command(
@@ -5579,7 +5833,10 @@ function registerUpdateCommand(cli2) {
     "Refresh installed policy files (rules / agents / commands / hooks / skills)"
   ).option("--project-dir <path>", "[Project] Target project directory", {
     default: process.cwd()
-  }).action((options) => {
+  }).option(
+    "--only <group>",
+    `[Scope] Update only this group (repeatable): ${UPDATE_GROUPS.join(" | ")}`
+  ).action((options) => {
     updateAction(options);
   });
 }
@@ -5694,19 +5951,6 @@ var INSTALL_TARGET_PAGES = [
   { label: "Visual & Media (Slides \xB7 Diagrams \xB7 Motion \xB7 Video)", cats: ["visual-media"] },
   { label: "Workflow & ECC Suite", cats: ["workflow", "ecc-suite"] }
 ];
-var DEV_METHOD_BUNDLE_VALUE = "bundle:dev-method";
-var DEV_METHOD_BUNDLE_CATEGORY = "workflow";
-var bundleMemberValues = () => DEV_METHOD_SKILL_IDS.map((id) => `asset:${id}`);
-function collapseDevMethodBundle(ids) {
-  const members = new Set(bundleMemberValues());
-  const rest = ids.filter((v2) => !members.has(v2));
-  const anyMember = ids.some((v2) => members.has(v2));
-  return anyMember ? [...rest, DEV_METHOD_BUNDLE_VALUE] : rest;
-}
-function expandDevMethodBundle(ids) {
-  const rest = ids.filter((v2) => v2 !== DEV_METHOD_BUNDLE_VALUE);
-  return ids.includes(DEV_METHOD_BUNDLE_VALUE) ? [...rest, ...bundleMemberValues()] : rest;
-}
 var BASELINE_TITLES = {
   rules: "Rules \u2014 \uC0C1\uC2DC \uC0C1\uC8FC\uD558\uB294 \uB300\uC6D0\uCE59 (4 CLI \uC804\uBD80\uC5D0 \uC124\uCE58)",
   hooks: "Hooks \u2014 \uACB0\uC815\uB860\uC801 \uAC00\uB4DC (\uD574\uC81C\uD558\uBA74 settings.json \uBC30\uC120\uB3C4 \uD568\uAED8 \uBE60\uC9C4\uB2E4)",
@@ -5720,7 +5964,8 @@ function buildPageGroups(cats, initialSet, installedSet = /* @__PURE__ */ new Se
   for (const kind of baselineKinds) {
     const items = baselineTargets.filter((t) => t.kind === kind).map((t) => ({
       value: t.id,
-      label: `    ${t.name}${installedMark(t.id)}`
+      label: `    ${t.name}${installedMark(t.id)}`,
+      ...t.hint ? { hint: t.hint } : {}
     }));
     if (items.length === 0) continue;
     groups[BASELINE_TITLES[kind]] = items;
@@ -5736,16 +5981,10 @@ function buildPageGroups(cats, initialSet, installedSet = /* @__PURE__ */ new Se
         hint: o.hint
       });
     }
-    if (cat === DEV_METHOD_BUNDLE_CATEGORY) {
-      items.push({
-        value: DEV_METHOD_BUNDLE_VALUE,
-        label: `    uzys \uD558\uB124\uC2A4 \uBC29\uBC95\uB860 ${DEV_METHOD_SKILL_IDS.length}\uC885  [uzys]  \u2605 official${installedMark(DEV_METHOD_BUNDLE_VALUE)}`,
-        hint: DEV_METHOD_SKILL_IDS.join(", ")
-      });
-    }
     const tierOrder = { official: 0, vetted: 1, experimental: 2 };
-    const devMethod = new Set(DEV_METHOD_SKILL_IDS);
-    const catAssets = [...EXTERNAL_ASSETS.filter((x) => x.category === cat)].filter((x) => !devMethod.has(x.id)).sort((a, b2) => tierOrder[assetTrustTier(a.id)] - tierOrder[assetTrustTier(b2.id)]);
+    const catAssets = [...EXTERNAL_ASSETS.filter((x) => x.category === cat)].sort(
+      (a, b2) => tierOrder[assetTrustTier(a.id)] - tierOrder[assetTrustTier(b2.id)]
+    );
     for (const a of catAssets) {
       const tier = assetTrustTier(a.id);
       const badge = tier === "official" ? "  \u2605 official" : tier === "experimental" ? "  \u26A0 experimental (opt-in)" : "";
@@ -5851,6 +6090,42 @@ var defaultPrompts = {
     });
     return q(result) ? null : result;
   },
+  selectUpdateGroups: async () => {
+    const result = await ve({
+      message: "What to update  (space = toggle \xB7 your edits are always backed up)",
+      options: [
+        { value: "skills", label: "Skills", hint: "installed bundled skills \u2192 latest" },
+        {
+          value: "new-skills",
+          label: "New skills",
+          hint: "bundled skills added since your install"
+        },
+        {
+          value: "rules",
+          label: "Rules \xB7 agents \xB7 commands",
+          hint: "your edited files \u2192 *.backup-<time>"
+        },
+        {
+          value: "anchor",
+          label: "CLAUDE-uzys-harness.md anchor",
+          hint: "your edited anchor \u2192 *.backup-<time>"
+        },
+        {
+          value: "hooks",
+          label: "Hooks \xB7 settings.json",
+          hint: "stale hook refs cleaned"
+        },
+        {
+          value: "external",
+          label: "Codex / OpenCode / Antigravity + external skills",
+          hint: "rendered artifacts + npx skills"
+        }
+      ],
+      initialValues: [...UPDATE_GROUPS],
+      required: true
+    });
+    return q(result) ? null : result;
+  },
   confirmInstall: async (summary) => {
     const result = await ue({
       message: `${summary}
@@ -5862,14 +6137,11 @@ Proceed?`,
   },
   selectInstallTargets: async (initialChecked, step, recap) => {
     const pages = INSTALL_TARGET_PAGES;
-    const baselineTargets = listBaselineTargets({ tracks: recap?.tracks ?? [] });
-    const displayInitial = collapseDevMethodBundle(initialChecked);
-    const initialSet = new Set(displayInitial);
-    const collected = new Set(displayInitial);
+    const baselineTargets = withBaselineHints(listBaselineTargets({ tracks: recap?.tracks ?? [] }));
+    const initialSet = new Set(initialChecked);
+    const collected = new Set(initialChecked);
     const recapLine = recap ? `Tracks: ${recap.tracks.join(", ")}  \xB7  CLIs: ${recap.cli.join(", ")}` : "";
-    const installedSet = new Set(
-      collapseDevMethodBundle(recap?.installed ?? [])
-    );
+    const installedSet = new Set(recap?.installed ?? []);
     process.stdout.write("\x1B[?1049h");
     let resultIds = null;
     let aborted = false;
@@ -5929,7 +6201,7 @@ Proceed?`,
         pageIdx++;
       }
       if (!aborted) {
-        resultIds = expandDevMethodBundle([...collected]);
+        resultIds = [...collected];
       }
     } finally {
       process.stdout.write("\x1B[?1049l");
@@ -6019,11 +6291,15 @@ async function runInteractive(projectDir, deps = {}) {
     }
     if (action === "update") {
       mode = "update";
-      const spec = buildUpdateSpec(projectDir, state.tracks);
-      const confirmed = await prompts.confirmInstall(
-        `UPDATE policy files only:
-${formatSummary(spec)}`
-      );
+      const groups = prompts.selectUpdateGroups ? await prompts.selectUpdateGroups() : null;
+      if (groups === null && prompts.selectUpdateGroups) {
+        prompts.cancel("Cancelled.");
+        return { ok: false, reason: "cancelled" };
+      }
+      const spec = buildUpdateSpec(projectDir, state.tracks, groups ?? void 0);
+      const scopeLine = spec.updateOnly ? `UPDATE ${spec.updateOnly.join(" \xB7 ")} only (untouched: ${UPDATE_GROUPS.filter((g) => !spec.updateOnly?.includes(g)).join(", ")}):` : "UPDATE installed harness files:";
+      const confirmed = await prompts.confirmInstall(`${scopeLine}
+${formatSummary(spec)}`);
       if (!confirmed) {
         prompts.outro("Cancelled.");
         return { ok: false, reason: "cancelled" };
@@ -6170,7 +6446,7 @@ function formatSummary(spec) {
     const cost = formatResidentCostLine(
       residentCost(
         buildManifest(assetSpec).filter(
-          (e2) => e2.applies(assetSpec) && !isBaselineExcluded(e2.target, baselineExcluded)
+          (e2) => e2.applies(assetSpec) && !isBaselineExcluded(e2.target, baselineExcluded) && landsOnDisk(e2.target, spec.cli)
         )
       ),
       summarizeContextCost(finalAssets).unmeasuredCount