@event4u/agent-config 9.10.0 → 9.11.0

package/dist/cli-delegate/chunk-TFG57JJM.js

@@ -0,0 +1,1969 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  artefact_roots,
+  iter_all_sources,
+  resolve_logical,
+  strip_source_prefix
+} from "./chunk-BJGXZNPM.js";
+import {
+  MODEL_TIER_RE,
+  TIER_TO_CLAUDE_MODEL,
+  build_claude_hook_matrix,
+  is_claude_builtin_name
+} from "./chunk-7DSAMZFU.js";
+import {
+  load_agent_settings,
+  project_settings_path
+} from "./chunk-HJ6DAJHR.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/install/rule_scope.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/scripts/condense.ts
+var YAML = __toESM(require_dist(), 1);
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/scripts/_lib/compile_time_toggles.ts
+var COMPILE_TIME_TOGGLES = {
+  // `speak` defaults FALSE (dormant) per docs/adrs/telegraph/0002 — the absent-key
+  // fallback used to be `true`, which silently contradicted ADR 0001 (accepted,
+  // "default off until bench"). Measured basis: median vs_terse −9.27% (API) /
+  // −5.47% (exact cl100k_base) — telegraph emits MORE than a plain "be terse".
+  // Opt back in with an explicit `telegraph.speak: true` once an output-side bench
+  // clears the kill-criterion bar. `enabled` keeps its true default: it is the
+  // family master switch, and flipping it would silence sibling telegraph settings
+  // that were never measured negative.
+  //
+  // This predicate deliberately does NOT read `speak_scope`. That key disables the
+  // rule's *behaviour* and never removed its token cost — the trap the measurement
+  // exposed.
+  "telegraph-speak": (s) => {
+    const tg = s["telegraph"] ?? {};
+    const enabled = tg["enabled"] === void 0 ? true : tg["enabled"];
+    const speak = tg["speak"] === void 0 ? false : tg["speak"];
+    return Boolean(enabled) && Boolean(speak);
+  }
+};
+function rule_is_compile_enabled(rule_id, settings) {
+  const predicate = COMPILE_TIME_TOGGLES[rule_id];
+  return predicate === void 0 ? true : predicate(settings);
+}
+
+// src/scripts/_lib/script_output.ts
+var VALID_LEVELS = ["silent", "minimal", "verbose"];
+var DEFAULT_LEVEL = "minimal";
+var ENV_VAR = "AGENT_SCRIPT_VERBOSITY";
+var ENV_ALIAS = "SCRIPT_OUTPUT_VERBOSE";
+var SETTINGS_FILE = ".agent-settings.yml";
+var _resolved_level = null;
+var _pending_summary = [];
+function _read_settings_level(settings_path) {
+  const data = load_agent_settings({ project_path: settings_path });
+  const section = data["verbosity"];
+  if (typeof section !== "object" || section === null || Array.isArray(section)) {
+    return null;
+  }
+  const value = section["script_output"];
+  if (typeof value === "string" && VALID_LEVELS.includes(value)) {
+    return value;
+  }
+  return null;
+}
+function resolve_level(settings_path = null) {
+  if (_resolved_level !== null) {
+    return _resolved_level;
+  }
+  const env_value = (process.env[ENV_VAR] ?? "").trim().toLowerCase();
+  if (VALID_LEVELS.includes(env_value)) {
+    _resolved_level = env_value;
+  } else if ((process.env[ENV_ALIAS] ?? "").trim() === "1") {
+    _resolved_level = "verbose";
+  } else {
+    const p = settings_path ?? SETTINGS_FILE;
+    _resolved_level = _read_settings_level(p) ?? DEFAULT_LEVEL;
+  }
+  process.env[ENV_VAR] = _resolved_level;
+  return _resolved_level;
+}
+function info(message) {
+  if (resolve_level() === "verbose") {
+    process.stdout.write(`${message}
+`);
+  }
+}
+function success(message) {
+  const level = resolve_level();
+  if (level === "verbose") {
+    process.stdout.write(`${message}
+`);
+  } else if (level === "minimal") {
+    _pending_summary.push(message);
+  }
+}
+function flush_summary(headline = null) {
+  const level = resolve_level();
+  if (level !== "minimal" || _pending_summary.length === 0) {
+    return;
+  }
+  if (headline) {
+    process.stdout.write(`${headline}
+`);
+  } else {
+    process.stdout.write(`${_pending_summary[_pending_summary.length - 1]}
+`);
+  }
+  _pending_summary.length = 0;
+}
+
+// src/scripts/condense.ts
+var _SLUG_PREFIX_RE = /^slug_prefix:\s*"?([a-z][a-z0-9-]*)"?\s*$/m;
+function _yamlParse(text) {
+  try {
+    const data = YAML.parse(text, { version: "1.1" });
+    return data === void 0 ? null : data;
+  } catch {
+    return null;
+  }
+}
+function _exists(p) {
+  try {
+    fs.lstatSync(p);
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _existsOrSymlink(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function _isDirNoFollow(p) {
+  try {
+    return fs.lstatSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _readText(p) {
+  return fs.readFileSync(p, "utf-8");
+}
+function _writeText(p, text) {
+  fs.writeFileSync(p, text, "utf-8");
+}
+function _mkdirp(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+function _iterdirSorted(p) {
+  let names;
+  try {
+    names = fs.readdirSync(p);
+  } catch {
+    return [];
+  }
+  names.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return names.map((n) => path.join(p, n));
+}
+function _rglobSorted(root, pattern) {
+  const out = [];
+  const suffix = pattern === "*" ? null : pattern.slice(1);
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      const matches = suffix === null ? true : ent.name.endsWith(suffix);
+      if (matches) {
+        out.push(full);
+      }
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir(full)) {
+        walk(full);
+      }
+    }
+  };
+  walk(root);
+  out.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return out;
+}
+function _relativeToPosix(child, root) {
+  const rel = path.relative(root, child);
+  return rel.split(path.sep).join("/");
+}
+function _isUnder(child, root) {
+  const rel = path.relative(root, child);
+  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function _posixParts(p) {
+  return p.split("/").filter((s) => s.length > 0);
+}
+function _lstrip(s) {
+  return s.replace(/^\s+/u, "");
+}
+function _strip(s) {
+  return s.replace(/^\s+/u, "").replace(/\s+$/u, "");
+}
+function _lstripNewlines(s) {
+  return s.replace(/^\n+/, "");
+}
+function _stripChars(s, chars) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && chars.includes(s[start])) start += 1;
+  while (end > start && chars.includes(s[end - 1])) end -= 1;
+  return s.slice(start, end);
+}
+var _HERE = path.dirname(fileURLToPath(import.meta.url));
+var _DEFAULT_PROJECT_ROOT = path.resolve(_HERE, "..", "..");
+function _deriveState(root) {
+  return {
+    PROJECT_ROOT: root,
+    SOURCE_DIR: path.join(root, ".agent-src.uncondensed"),
+    TARGET_DIR: path.join(root, "dist/agent-src"),
+    AUGMENT_DIR: path.join(root, ".augment"),
+    SETTINGS_FILE: project_settings_path(root),
+    RULES_SOURCE: path.join(root, "dist/agent-src", "rules"),
+    SKILLS_SOURCE: path.join(root, "dist/agent-src", "skills"),
+    COMMANDS_SOURCE: path.join(root, "dist/agent-src", "commands"),
+    PERSONAS_SOURCE: path.join(root, "dist/agent-src", "personas"),
+    USER_TYPES_SOURCE: path.join(root, "dist/agent-src", "user-types"),
+    CLAUDE_SKILLS_DIR: path.join(root, ".claude", "skills"),
+    // ADR-109: subagents project from src/ directly (NOT dist/) — a subagent
+    // is an executable system prompt Claude Code runs verbatim; telegraph
+    // condensation would alter its behaviour, and it is not routed through the
+    // pack/discovery condensation flow.
+    CLAUDE_AGENTS_DIR: path.join(root, ".claude", "agents"),
+    SUBAGENTS_SOURCE: path.join(root, "src", "subagents"),
+    PLUGIN_SKILLS_DIR: path.join(root, ".claude-plugin", "skills"),
+    iter_all_sources,
+    resolve_logical,
+    artefact_roots
+  };
+}
+var MODULE_STATE = _deriveState(_DEFAULT_PROJECT_ROOT);
+function _iter_sources() {
+  return MODULE_STATE.iter_all_sources();
+}
+function _resolve_source(relative2) {
+  return MODULE_STATE.resolve_logical(relative2);
+}
+function _any_source_root_exists() {
+  return [...MODULE_STATE.artefact_roots()].length > 0;
+}
+function _active_tools() {
+  const tools_file = path.join(MODULE_STATE.PROJECT_ROOT, "agents", ".agent-tools.yml");
+  if (!_exists(tools_file)) {
+    return null;
+  }
+  let data = _yamlParse(_readText(tools_file));
+  if (data === null || data === void 0) {
+    data = {};
+  }
+  const tools = typeof data === "object" && data !== null && !Array.isArray(data) ? data["tools"] : null;
+  if (!Array.isArray(tools)) {
+    return null;
+  }
+  return new Set(tools.filter((t) => typeof t === "string"));
+}
+function _tool_active(tool_id) {
+  const active = _active_tools();
+  return active === null ? true : active.has(tool_id);
+}
+var COPY_AS_IS = /* @__PURE__ */ new Set(["README.md"]);
+var COPY_AS_IS_DIRS = /* @__PURE__ */ new Set(["ghostwriter"]);
+function _read_augment_rules_use_symlinks() {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const augment = data["augment"];
+  if (typeof augment !== "object" || augment === null || Array.isArray(augment)) {
+    return false;
+  }
+  const value = augment["rules_use_symlinks"];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return ["true", "yes", "on", "1"].includes(value.trim().toLowerCase());
+  }
+  if (typeof value === "number") {
+    return value === 1;
+  }
+  return false;
+}
+var USER_SCOPE_RULE_DIRS = {
+  ".claude/rules": path.join(".claude", "rules")
+};
+function _read_projection_scope_dedup() {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const projection = data["projection"];
+  if (typeof projection !== "object" || projection === null || Array.isArray(projection)) {
+    return false;
+  }
+  const value = projection["scope_dedup"];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return ["true", "yes", "on", "1"].includes(value.trim().toLowerCase());
+  }
+  return false;
+}
+function _dedupable_rules(tool_dir, rules, userHome) {
+  const relative2 = USER_SCOPE_RULE_DIRS[tool_dir];
+  if (relative2 === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  let userDirStat;
+  const userDir = path.join(userHome, relative2);
+  try {
+    userDirStat = fs.statSync(userDir);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  if (!userDirStat.isDirectory()) {
+    return /* @__PURE__ */ new Set();
+  }
+  if ((userDirStat.mode & 2) !== 0) {
+    _print(`  \u26A0\uFE0F  ${tool_dir}: user-scope rules dir is world-writable \u2014 scope-dedup skipped`);
+    return /* @__PURE__ */ new Set();
+  }
+  const skip = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    const twin = path.join(userDir, rule);
+    const source = path.join(MODULE_STATE.RULES_SOURCE, rule);
+    try {
+      if (!_isFile(twin) || !_isFile(source)) continue;
+      if (fs.readFileSync(twin).equals(fs.readFileSync(source))) {
+        skip.add(rule);
+      }
+    } catch {
+    }
+  }
+  return skip;
+}
+function _lean_projection_mode() {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const lean = data["lean_projection"];
+  if (typeof lean === "object" && lean !== null && !Array.isArray(lean) && String(lean["mode"] ?? "").trim().toLowerCase() === "thin") {
+    return "thin";
+  }
+  return "eager-all";
+}
+function apply_path_rewriter(relative_path) {
+  const target = path.join(MODULE_STATE.TARGET_DIR, relative_path);
+  if (!_exists(target) || !relative_path.endsWith(".md")) {
+    return false;
+  }
+  const original = _readText(target);
+  const rewritten = _rewrite_paths(original, relative_path);
+  if (rewritten === original) {
+    return false;
+  }
+  _writeText(target, rewritten);
+  return true;
+}
+function is_projection_stale(relative2) {
+  const source = _resolve_source(relative2);
+  if (source === null) {
+    return false;
+  }
+  if (skip_compile_disabled_rule(relative2)) {
+    return false;
+  }
+  const target = path.join(MODULE_STATE.TARGET_DIR, relative2);
+  if (!_exists(target)) {
+    return true;
+  }
+  return _readText(target) !== _rewrite_paths(_readText(source), relative2);
+}
+function list_changed_md(_source_dir) {
+  const changed = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [, relative2] of _iter_sources()) {
+    if (seen.has(relative2)) {
+      continue;
+    }
+    seen.add(relative2);
+    const source = _resolve_source(relative2);
+    if (source === null || !should_condense(source)) {
+      continue;
+    }
+    if (is_projection_stale(relative2)) {
+      changed.push(relative2);
+    }
+  }
+  return changed;
+}
+function should_condense(filepath) {
+  if (path.extname(filepath) !== ".md") {
+    return false;
+  }
+  if (COPY_AS_IS.has(path.basename(filepath))) {
+    return false;
+  }
+  let rel_parts = filepath.split(path.sep).filter((s) => s.length > 0);
+  for (const root of MODULE_STATE.artefact_roots()) {
+    if (filepath !== root && !_isUnder(filepath, root)) {
+      continue;
+    }
+    rel_parts = _relativeToPosix(filepath, root).split("/");
+    break;
+  }
+  if (rel_parts.length > 0 && COPY_AS_IS_DIRS.has(rel_parts[0])) {
+    return false;
+  }
+  return true;
+}
+function copy_file(source, target) {
+  _mkdirp(path.dirname(target));
+  fs.copyFileSync(source, target);
+  try {
+    const st = fs.statSync(source);
+    fs.utimesSync(target, st.atime, st.mtime);
+    fs.chmodSync(target, st.mode);
+  } catch {
+  }
+}
+function cleanup_stale(_source_dir, target_dir) {
+  let deleted = 0;
+  if (!_exists(target_dir)) {
+    return 0;
+  }
+  for (const target_file of _rglobSorted(target_dir, "*")) {
+    if (_isDir(target_file)) {
+      continue;
+    }
+    const relative2 = _relativeToPosix(target_file, target_dir);
+    if (_resolve_source(relative2) === null) {
+      _print(`  Deleting stale: ${relative2}`);
+      fs.unlinkSync(target_file);
+      deleted += 1;
+    }
+  }
+  const dirs = _rglobSorted(target_dir, "*").filter((p) => _isDir(p)).sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+  for (const dirpath of dirs) {
+    try {
+      if (fs.readdirSync(dirpath).length === 0) {
+        fs.rmdirSync(dirpath);
+        _print(`  Removing empty dir: ${_relativeToPosix(dirpath, target_dir)}`);
+      }
+    } catch {
+    }
+  }
+  return deleted;
+}
+var COPY_MD_VERBATIM = true;
+function skip_compile_disabled_rule(relative2) {
+  const posix = relative2.split(path.sep).join("/");
+  if (!posix.startsWith("rules/") || !posix.endsWith(".md")) {
+    return false;
+  }
+  const rule_id = path.basename(posix, ".md");
+  const settings = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  return !rule_is_compile_enabled(rule_id, settings);
+}
+function sync_non_md(_source_dir, target_dir) {
+  let copied = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [source_file, relative2] of _iter_sources()) {
+    if (!COPY_MD_VERBATIM && should_condense(source_file)) {
+      continue;
+    }
+    if (seen.has(relative2)) {
+      continue;
+    }
+    if (skip_compile_disabled_rule(relative2)) {
+      continue;
+    }
+    seen.add(relative2);
+    const target_file = path.join(target_dir, relative2);
+    copy_file(source_file, target_file);
+    if (COPY_MD_VERBATIM && relative2.endsWith(".md")) {
+      apply_path_rewriter(relative2);
+    }
+    _print(`  Copied: ${relative2}`);
+    copied += 1;
+  }
+  return copied;
+}
+function list_md_files(_source_dir) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [source_file, relative2] of _iter_sources()) {
+    if (!should_condense(source_file)) {
+      continue;
+    }
+    if (seen.has(relative2)) {
+      continue;
+    }
+    seen.add(relative2);
+    files.push(relative2);
+  }
+  return files.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function check_sync(_source_dir, target_dir) {
+  const missing = [];
+  const stale = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [, relative2] of _iter_sources()) {
+    if (seen.has(relative2)) {
+      continue;
+    }
+    seen.add(relative2);
+    if (skip_compile_disabled_rule(relative2)) {
+      continue;
+    }
+    if (!_exists(path.join(target_dir, relative2))) {
+      missing.push(relative2);
+    }
+  }
+  if (_exists(target_dir)) {
+    for (const target_file of _rglobSorted(target_dir, "*")) {
+      if (_isDir(target_file)) {
+        continue;
+      }
+      const relative2 = _relativeToPosix(target_file, target_dir);
+      if (_resolve_source(relative2) === null || skip_compile_disabled_rule(relative2)) {
+        stale.push(relative2);
+      }
+    }
+  }
+  return [missing, stale];
+}
+var TOOL_DIRS = {
+  ".claude/rules": "../../dist/agent-src/rules",
+  ".cursor/rules": "../../dist/agent-src/rules",
+  ".clinerules": "../dist/agent-src/rules"
+};
+var PERSONA_TOOL_DIRS = {
+  ".claude/personas": "../../dist/agent-src/personas",
+  ".cursor/personas": "../../dist/agent-src/personas"
+};
+var USER_TYPE_TOOL_DIRS = {
+  ".claude/user-types": "../../dist/agent-src/user-types",
+  ".cursor/user-types": "../../dist/agent-src/user-types"
+};
+var _DIR_TOOL_ID = {
+  ".claude/rules": "claude-code",
+  ".cursor/rules": "cursor",
+  ".clinerules": "cline",
+  ".claude/personas": "claude-code",
+  ".cursor/personas": "cursor",
+  ".claude/user-types": "claude-code",
+  ".cursor/user-types": "cursor"
+};
+function _filter_tool_dirs(mapping) {
+  const out = {};
+  for (const [d, p] of Object.entries(mapping)) {
+    if (_tool_active(_DIR_TOOL_ID[d] ?? "claude-code")) {
+      out[d] = p;
+    }
+  }
+  return out;
+}
+function strip_frontmatter(content) {
+  if (content.startsWith("---")) {
+    const end = content.indexOf("---", 3);
+    if (end !== -1) {
+      content = _lstripNewlines(content.slice(end + 3));
+    }
+  }
+  return content;
+}
+var _LEGACY_SRC_PREFIX = ".agent-src.uncondensed/";
+var _PROJECTED_SRC_PREFIX = "dist/agent-src/";
+var _LEGACY_PROJECTED_SRC_PREFIX = ".agent-src/";
+var _FM_LIST_ITEM_RE = /^(\s*-\s*)(["']?)([^"'\n]+?\.md)(["']?)\s*$/;
+var _FM_PATH_PREFIX_RE = /^(\s*(?:-\s+)?path_prefix:\s*)(["']?)([^"'\n]+?)(["']?)\s*$/;
+var _BODY_DOCS_RE = /\.\.\/\.\.\/(docs\/(?:guidelines|contracts)\/[^)\s]+\.md)/g;
+var _FM_PLAIN_LIST_RE = /^\s*-\s*(["']?)([^"'\n]+?)\1\s*$/;
+var _HRR_BANNER_MARKER = "<!-- agent-config:human-review-banner -->";
+function _depth_prefix(source_relative_path) {
+  const parts = _posixParts(source_relative_path);
+  const depth = Math.max(parts.length - 1, 1);
+  return "../".repeat(depth);
+}
+function _split_frontmatter(content) {
+  if (!content.startsWith("---\n")) {
+    return [null, content];
+  }
+  const end = content.indexOf("\n---\n", 4);
+  if (end === -1) {
+    return [null, content];
+  }
+  const fm_text = content.slice(4, end);
+  const body = content.slice(end + "\n---\n".length);
+  return [fm_text.split("\n"), body];
+}
+function _rewrite_load_context_value(value, prefix) {
+  if (value.startsWith("../") || value.startsWith("./") || value.startsWith("/")) {
+    return value;
+  }
+  if (value.startsWith(_LEGACY_SRC_PREFIX)) {
+    return prefix + value.slice(_LEGACY_SRC_PREFIX.length);
+  }
+  if (value.startsWith(_PROJECTED_SRC_PREFIX)) {
+    return prefix + value.slice(_PROJECTED_SRC_PREFIX.length);
+  }
+  if (value.startsWith(_LEGACY_PROJECTED_SRC_PREFIX)) {
+    return prefix + value.slice(_LEGACY_PROJECTED_SRC_PREFIX.length);
+  }
+  return prefix + value;
+}
+function _rewrite_path_prefix_value(value) {
+  return value;
+}
+function _rewrite_frontmatter_lines(lines, prefix) {
+  let in_load_context = false;
+  const out = [];
+  for (const line of lines) {
+    const bare = _lstrip(line);
+    if (bare.startsWith("load_context:") || bare.startsWith("load_context_eager:")) {
+      in_load_context = true;
+      out.push(line);
+      continue;
+    }
+    if (in_load_context) {
+      const m = _FM_LIST_ITEM_RE.exec(line);
+      if (m) {
+        const indent = m[1] ?? "";
+        const q1 = m[2] ?? "";
+        const value = m[3] ?? "";
+        const q2 = m[4] ?? "";
+        out.push(`${indent}${q1}${_rewrite_load_context_value(value, prefix)}${q2}`);
+        continue;
+      }
+      in_load_context = false;
+    }
+    const pm = _FM_PATH_PREFIX_RE.exec(line);
+    if (pm) {
+      const head = pm[1] ?? "";
+      const q1 = pm[2] ?? "";
+      const value = pm[3] ?? "";
+      const q2 = pm[4] ?? "";
+      out.push(`${head}${q1}${_rewrite_path_prefix_value(value)}${q2}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out;
+}
+function _rewrite_body_links(body, prefix) {
+  return body.replace(_BODY_DOCS_RE, (_m, tail) => prefix + tail);
+}
+function _parse_trust_and_owner(fm_lines) {
+  let level = "core";
+  let hrr = false;
+  const packs = [];
+  const workspaces = [];
+  let in_trust = false;
+  let in_packs = false;
+  let in_workspaces = false;
+  for (const line of fm_lines) {
+    const stripped = _lstrip(line);
+    const indent = line.length - stripped.length;
+    if (indent === 0 && stripped.endsWith(":")) {
+      const key = stripped.slice(0, -1);
+      in_trust = key === "trust";
+      in_packs = key === "packs";
+      in_workspaces = key === "workspaces";
+      continue;
+    }
+    if (in_trust && stripped.startsWith("level:")) {
+      const after = stripped.slice(stripped.indexOf(":") + 1);
+      level = _stripChars(_stripChars(_strip(after), '"'), "'");
+    } else if (in_trust && stripped.startsWith("human_review_required:")) {
+      const after = stripped.slice(stripped.indexOf(":") + 1);
+      hrr = _strip(after).toLowerCase() === "true";
+    } else if (in_packs || in_workspaces) {
+      const m = _FM_PLAIN_LIST_RE.exec(line);
+      if (m) {
+        const value = _strip(m[2] ?? "");
+        (in_packs ? packs : workspaces).push(value);
+      }
+    }
+  }
+  let owner = "unknown";
+  if (packs.length > 0) {
+    owner = packs[0].split("-")[0];
+  } else if (workspaces.length > 0) {
+    owner = workspaces[0];
+  }
+  return [level, hrr, owner];
+}
+function _inject_hrr_banner(body, level, owner) {
+  if (body.includes(_HRR_BANNER_MARKER)) {
+    return body;
+  }
+  const banner = `${_HRR_BANNER_MARKER}
+> HUMAN REVIEW REQUIRED \xB7 trust: ${level} \xB7 owner: ${owner}
+
+`;
+  return banner + _lstripNewlines(body);
+}
+function _rewrite_paths(content, source_relative_path) {
+  const prefix = _depth_prefix(source_relative_path);
+  const [fm_lines, bodyInitial] = _split_frontmatter(content);
+  let body = _rewrite_body_links(bodyInitial, prefix);
+  if (fm_lines === null) {
+    return body;
+  }
+  const new_fm = _rewrite_frontmatter_lines(fm_lines, prefix);
+  const [level, hrr, owner] = _parse_trust_and_owner(fm_lines);
+  if (hrr && level) {
+    body = _inject_hrr_banner(body, level, owner);
+  }
+  return "---\n" + new_fm.join("\n") + "\n---\n" + body;
+}
+function _read_projection_list(key) {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const proj = data["projection"];
+  const value = typeof proj === "object" && proj !== null && !Array.isArray(proj) ? proj[key] : null;
+  if (Array.isArray(value) && value.length > 0) {
+    return value.map((v) => String(v));
+  }
+  return null;
+}
+function _read_rule_workspaces() {
+  return _read_projection_list("rule_workspaces");
+}
+function _read_rule_packs() {
+  return _read_projection_list("rule_packs");
+}
+function rule_in_scope(source_path, scope, pack_scope = null, role_scope = null) {
+  if (scope === null && pack_scope === null && role_scope === null) {
+    return true;
+  }
+  const [meta] = _parse_frontmatter(_readText(source_path));
+  if (meta["type"] === "always" || meta["alwaysApply"] === true) {
+    return true;
+  }
+  const axis = (key, configured) => {
+    if (configured === null) {
+      return true;
+    }
+    const values = Array.isArray(meta[key]) ? meta[key].map((w) => String(w)) : [];
+    if (values.length === 0) {
+      return true;
+    }
+    return values.some((v) => configured.includes(v));
+  };
+  return axis("workspaces", scope) && axis("packs", pack_scope) && axis("roles", role_scope);
+}
+function _scoped_rule_basenames() {
+  const scope = _read_rule_workspaces();
+  const pack_scope = _read_rule_packs();
+  return _iterdirSorted(MODULE_STATE.RULES_SOURCE).filter((p) => p.endsWith(".md") && _isFile(p)).filter((p) => rule_in_scope(p, scope, pack_scope)).filter((p) => !skip_compile_disabled_rule(`rules/${path.basename(p)}`)).map((p) => path.basename(p)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function generate_rule_symlinks() {
+  const rules = _scoped_rule_basenames();
+  const tool_dirs = _filter_tool_dirs(TOOL_DIRS);
+  let thin_files = null;
+  if (_lean_projection_mode() === "thin") {
+    throw new Error(
+      "lean_projection.mode=thin requires project_thin_rules (not ported in condense.ts)"
+    );
+  }
+  const dedup_on = _read_projection_scope_dedup();
+  const user_home = process.env["HOME"] ?? os.homedir();
+  const skipped_per_tool = {};
+  let total = 0;
+  for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+    const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+    const skip = dedup_on ? _dedupable_rules(tool_dir, rules, user_home) : /* @__PURE__ */ new Set();
+    skipped_per_tool[tool_dir] = skip;
+    _mkdirp(target_dir);
+    for (const item of _iterdirSorted(target_dir)) {
+      const name = path.basename(item);
+      if (_isSymlink(item) && (!rules.includes(name) || skip.has(name)) && name !== "README.md") {
+        fs.unlinkSync(item);
+      }
+    }
+    for (const rule of rules) {
+      if (skip.has(rule)) {
+        continue;
+      }
+      const link = path.join(target_dir, rule);
+      if (_existsOrSymlink(link)) {
+        fs.unlinkSync(link);
+      }
+      if (thin_files !== null) {
+        _writeText(link, thin_files[rule]);
+      } else {
+        fs.symlinkSync(path.join(rel_prefix, rule), link);
+      }
+      total += 1;
+    }
+  }
+  const source_count = rules.length;
+  for (const tool_dir of Object.keys(tool_dirs)) {
+    const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+    const emitted = new Set(rules);
+    const tool_count = _iterdirSorted(target_dir).filter((f) => emitted.has(path.basename(f))).length;
+    const skipped = (skipped_per_tool[tool_dir] ?? /* @__PURE__ */ new Set()).size;
+    const expected = source_count - skipped;
+    if (tool_count !== expected) {
+      _print(`  \u26A0\uFE0F  ${tool_dir}: ${tool_count} rules (expected ${expected})`);
+    }
+    if (skipped > 0) {
+      _print(
+        `  \u2139\uFE0F  ${tool_dir}: ${skipped} rule(s) skipped \u2014 byte-identical twin already installed at user scope`
+      );
+    }
+  }
+  info(
+    `  \u2705  Created ${total} rule symlinks across ${Object.keys(tool_dirs).length} tool directories (${source_count} rules each)`
+  );
+  return total;
+}
+function generate_windsurfrules() {
+  const rules = _scoped_rule_basenames();
+  const parts = ["# Auto-generated from dist/agent-src/rules/ \u2014 do not edit directly\n"];
+  for (const rule of rules) {
+    const p = path.join(MODULE_STATE.RULES_SOURCE, rule);
+    const content = strip_frontmatter(_readText(p));
+    parts.push(`---
+
+${_strip(content)}
+`);
+  }
+  const output = path.join(MODULE_STATE.PROJECT_ROOT, ".windsurfrules");
+  _writeText(output, parts.join("\n") + "\n");
+  info(`  \u2705  Generated .windsurfrules (${rules.length} rules)`);
+  return rules.length;
+}
+function _CURSOR_RULES_MDC_DIR() {
+  return path.join(MODULE_STATE.PROJECT_ROOT, ".cursor", "rules");
+}
+function _WINDSURF_RULES_DIR() {
+  return path.join(MODULE_STATE.PROJECT_ROOT, ".windsurf", "rules");
+}
+function _WINDSURF_WORKFLOWS_DIR() {
+  return path.join(MODULE_STATE.PROJECT_ROOT, ".windsurf", "workflows");
+}
+function _CURSOR_COMMANDS_DIR() {
+  return path.join(MODULE_STATE.PROJECT_ROOT, ".cursor", "commands");
+}
+function _parse_frontmatter(content) {
+  if (!content.startsWith("---")) {
+    return [{}, content];
+  }
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) {
+    return [{}, content];
+  }
+  const raw = _strip(content.slice(3, end));
+  const body = _lstripNewlines(content.slice(end + 4));
+  let meta = _yamlParse(raw);
+  if (meta === null || meta === void 0) {
+    meta = {};
+  }
+  if (typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
+    return [meta, body];
+  }
+  return [{}, body];
+}
+function _yaml_scalar(value) {
+  return JSON.stringify(value);
+}
+function derive_trigger_globs(meta) {
+  const triggers = meta["triggers"];
+  if (!Array.isArray(triggers)) {
+    return [];
+  }
+  const globs = [];
+  for (const t of triggers) {
+    if (t === null || typeof t !== "object" || Array.isArray(t)) continue;
+    const obj = t;
+    if (typeof obj["file_pattern"] === "string" && obj["file_pattern"]) {
+      globs.push(obj["file_pattern"]);
+    } else if (typeof obj["path_prefix"] === "string" && obj["path_prefix"]) {
+      const prefix = obj["path_prefix"];
+      globs.push(prefix.endsWith("/") ? `${prefix}**` : `${prefix}**`);
+    }
+  }
+  return [...new Set(globs)];
+}
+function _emit_cursor_mdc(source, target) {
+  const [meta, body] = _parse_frontmatter(_readText(source));
+  const description = _strip(String(meta["description"] ?? "").replace(/\n/g, " "));
+  const always_apply = Boolean(meta["alwaysApply"] || meta["type"] === "always");
+  const globs = always_apply ? [] : derive_trigger_globs(meta);
+  const lines = [
+    "---",
+    `description: ${_yaml_scalar(description)}`,
+    `globs: ${globs.join(",")}`,
+    `alwaysApply: ${always_apply ? "true" : "false"}`,
+    "---",
+    "",
+    _pyRstrip(body) + "\n"
+  ];
+  _mkdirp(path.dirname(target));
+  _writeText(target, lines.join("\n"));
+}
+function _emit_windsurf_rule(source, target) {
+  const [meta, body] = _parse_frontmatter(_readText(source));
+  const description = _strip(String(meta["description"] ?? "").replace(/\n/g, " "));
+  const always_apply = Boolean(meta["alwaysApply"] || meta["type"] === "always");
+  const globs = always_apply ? [] : derive_trigger_globs(meta);
+  const trigger = always_apply ? "always_on" : globs.length > 0 ? "glob" : "model_decision";
+  const lines = [
+    "---",
+    `trigger: ${trigger}`,
+    `description: ${_yaml_scalar(description)}`,
+    `globs: ${globs.join(",")}`,
+    "---",
+    "",
+    _pyRstrip(body) + "\n"
+  ];
+  _mkdirp(path.dirname(target));
+  _writeText(target, lines.join("\n"));
+}
+function _pyRstrip(s) {
+  return s.replace(/\s+$/u, "");
+}
+function _clean_modern_dir(target_dir, valid_names) {
+  if (!_exists(target_dir)) {
+    return;
+  }
+  for (const item of _iterdirSorted(target_dir)) {
+    const name = path.basename(item);
+    if (name === "README.md") {
+      continue;
+    }
+    if (!valid_names.has(name)) {
+      if (_isDir(item) && !_isSymlink(item)) {
+        fs.rmSync(item, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(item);
+      }
+    }
+  }
+}
+function generate_cursor_mdc_rules() {
+  const scope = _read_rule_workspaces();
+  const pack_scope = _read_rule_packs();
+  const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, "*.md").filter((p) => _isFile(p)).filter((p) => rule_in_scope(p, scope, pack_scope));
+  const stems = rules.map((r) => path.basename(r, ".md"));
+  const valid = /* @__PURE__ */ new Set([
+    ...stems.map((s) => `${s}.mdc`),
+    ...rules.map((r) => path.basename(r))
+  ]);
+  _clean_modern_dir(_CURSOR_RULES_MDC_DIR(), valid);
+  for (const rule of rules) {
+    _emit_cursor_mdc(rule, path.join(_CURSOR_RULES_MDC_DIR(), `${path.basename(rule, ".md")}.mdc`));
+  }
+  info(`  \u2705  Wrote ${rules.length} \`.cursor/rules/*.mdc\` files`);
+  return rules.length;
+}
+function generate_windsurf_modern_rules() {
+  const scope = _read_rule_workspaces();
+  const pack_scope = _read_rule_packs();
+  const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, "*.md").filter((p) => _isFile(p)).filter((p) => rule_in_scope(p, scope, pack_scope));
+  const valid = new Set(rules.map((r) => path.basename(r)));
+  _clean_modern_dir(_WINDSURF_RULES_DIR(), valid);
+  for (const rule of rules) {
+    _emit_windsurf_rule(rule, path.join(_WINDSURF_RULES_DIR(), path.basename(rule)));
+  }
+  info(`  \u2705  Wrote ${rules.length} \`.windsurf/rules/*.md\` files`);
+  return rules.length;
+}
+function generate_cursor_commands(active_command_slugs = null) {
+  if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains"))) {
+    return 0;
+  }
+  const cmds = [...iterCommands()].filter(
+    ([, slug]) => active_command_slugs === null || active_command_slugs.has(slug)
+  );
+  const valid = new Set(cmds.map(([, slug]) => `${slug}.md`));
+  _clean_modern_dir(_CURSOR_COMMANDS_DIR(), valid);
+  _mkdirp(_CURSOR_COMMANDS_DIR());
+  let count = 0;
+  for (const [source_file, slug] of cmds) {
+    const link = path.join(_CURSOR_COMMANDS_DIR(), `${slug}.md`);
+    if (_existsOrSymlink(link)) {
+      fs.unlinkSync(link);
+    }
+    const rel = path.join("../..", _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT));
+    fs.symlinkSync(rel, link);
+    count += 1;
+  }
+  info(`  \u2705  Linked ${count} \`.cursor/commands/*.md\` files`);
+  return count;
+}
+function generate_windsurf_workflows(active_command_slugs = null) {
+  if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains"))) {
+    return 0;
+  }
+  const cmds = [...iterCommands()].filter(
+    ([, slug]) => active_command_slugs === null || active_command_slugs.has(slug)
+  );
+  const valid = new Set(cmds.map(([, slug]) => `${slug}.md`));
+  _clean_modern_dir(_WINDSURF_WORKFLOWS_DIR(), valid);
+  _mkdirp(_WINDSURF_WORKFLOWS_DIR());
+  let count = 0;
+  for (const [source_file, slug] of cmds) {
+    const link = path.join(_WINDSURF_WORKFLOWS_DIR(), `${slug}.md`);
+    if (_existsOrSymlink(link)) {
+      fs.unlinkSync(link);
+    }
+    const rel = path.join("../..", _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT));
+    fs.symlinkSync(rel, link);
+    count += 1;
+  }
+  info(`  \u2705  Linked ${count} \`.windsurf/workflows/*.md\` files`);
+  return count;
+}
+function generate_gemini_md() {
+  const link = path.join(MODULE_STATE.PROJECT_ROOT, "GEMINI.md");
+  if (_existsOrSymlink(link)) {
+    fs.unlinkSync(link);
+  }
+  fs.symlinkSync("AGENTS.md", link);
+  info("  \u2705  Created GEMINI.md \u2192 AGENTS.md symlink");
+}
+function* iterCommands() {
+  const src_domains = path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains");
+  if (!_isDir(src_domains)) {
+    return;
+  }
+  for (const source_file of _rglobSorted(src_domains, "command.md")) {
+    if (!_isFile(source_file)) {
+      continue;
+    }
+    const rel = _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT);
+    let slug = _command_path_to_slug(rel);
+    if (!slug) {
+      continue;
+    }
+    const pack_id = _relativeToPosix(source_file, src_domains).split("/")[0];
+    const prefix = _domains_slug_prefix(pack_id);
+    if (prefix && slug !== prefix && !slug.startsWith(prefix + "-")) {
+      slug = `${prefix}-${slug}`;
+    }
+    yield [source_file, slug];
+  }
+}
+function _read_model_auto_switch() {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const model = data["model"];
+  const value = typeof model === "object" && model !== null && !Array.isArray(model) ? model["auto_switch"] : null;
+  if (typeof value === "string" && ["auto", "suggest", "off"].includes(value.trim().toLowerCase())) {
+    return value.trim().toLowerCase();
+  }
+  return "suggest";
+}
+function _read_projection_mode() {
+  const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+  const proj = data["projection"];
+  const value = typeof proj === "object" && proj !== null && !Array.isArray(proj) ? proj["mode"] : null;
+  if (typeof value === "string" && ["legacy-all", "scoped"].includes(value.trim().toLowerCase())) {
+    return value.trim().toLowerCase();
+  }
+  return "legacy-all";
+}
+function _domains_slug_prefix(pack_id) {
+  const manifest = path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains", pack_id, "pack.yaml");
+  if (!_isFile(manifest)) {
+    return "";
+  }
+  const m = _SLUG_PREFIX_RE.exec(_readText(manifest));
+  return m ? m[1] : "";
+}
+function _command_path_to_slug(manifest_path) {
+  const logical = strip_source_prefix(manifest_path);
+  if (logical && logical.startsWith("commands/")) {
+    return _posixParts(logical.slice("commands/".length).replace(/\.md$/, "")).join("-");
+  }
+  const parts = manifest_path.split(path.sep).filter((s) => s.length > 0);
+  const i = parts.indexOf("commands");
+  return parts.slice(i + 1).join("/").replace(/\.md$/, "").split("/").join("-");
+}
+function _resolve_active_predicates() {
+  if (_read_projection_mode() !== "scoped") {
+    return [null, null];
+  }
+  throw new Error("projection.mode=scoped requires the config package (not ported in condense.ts)");
+}
+function _model_tier(skill_md) {
+  if (!_exists(skill_md)) {
+    return null;
+  }
+  const text = fs.readFileSync(skill_md).toString("utf-8");
+  if (!text.startsWith("---\n")) {
+    return null;
+  }
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) {
+    return null;
+  }
+  const m = MODEL_TIER_RE.exec(text.slice(4, end));
+  return m ? m[1] : null;
+}
+function _render_native_model_md(src_md, tier) {
+  const text = _readText(src_md);
+  const model = TIER_TO_CLAUDE_MODEL[tier];
+  return text.replace(MODEL_TIER_RE, `model: ${model}`);
+}
+function generate_claude_skills(active_skill_names = null) {
+  if (!_exists(MODULE_STATE.SKILLS_SOURCE)) {
+    process.stderr.write("  \u26A0\uFE0F  dist/agent-src/skills/ not found \u2014 skipping skills\n");
+    return 0;
+  }
+  let skills = _iterdirSorted(MODULE_STATE.SKILLS_SOURCE).filter((p) => _isDir(p)).map((p) => path.basename(p)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  if (active_skill_names !== null) {
+    skills = skills.filter((s) => active_skill_names.has(s));
+  }
+  const skill_set = new Set(skills);
+  const command_slugs = new Set([...iterCommands()].map(([, slug]) => slug));
+  _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
+  const auto = _read_model_auto_switch() === "auto";
+  for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
+    const name = path.basename(item);
+    if (skill_set.has(name) || command_slugs.has(name) || name === "README.md") {
+      continue;
+    }
+    if (_isSymlink(item)) {
+      fs.unlinkSync(item);
+    } else if (_isDirNoFollow(item)) {
+      const skill_md = path.join(item, "SKILL.md");
+      if (_isFile(skill_md) && !_isSymlink(skill_md)) {
+        fs.rmSync(item, { recursive: true, force: true });
+      }
+    }
+  }
+  let count = 0;
+  let rendered = 0;
+  for (const skill of skills) {
+    const link = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, skill);
+    const src_dir = path.join(MODULE_STATE.SKILLS_SOURCE, skill);
+    const value = auto ? _model_tier(path.join(src_dir, "SKILL.md")) : null;
+    if (_isSymlink(link)) {
+      fs.unlinkSync(link);
+    } else if (_isDirNoFollow(link)) {
+      fs.rmSync(link, { recursive: true, force: true });
+    } else if (_existsOrSymlink(link)) {
+      fs.unlinkSync(link);
+    }
+    if (value !== null && value in TIER_TO_CLAUDE_MODEL) {
+      _mkdirp(link);
+      for (const entry of _iterdirSorted(src_dir)) {
+        const entryName = path.basename(entry);
+        if (entryName === "SKILL.md") {
+          _writeText(
+            path.join(link, "SKILL.md"),
+            _render_native_model_md(entry, value)
+          );
+        } else {
+          fs.symlinkSync(
+            path.join("../../../dist/agent-src/skills", skill, entryName),
+            path.join(link, entryName)
+          );
+        }
+      }
+      rendered += 1;
+    } else {
+      fs.symlinkSync(path.join("../../dist/agent-src/skills", skill), link);
+    }
+    count += 1;
+  }
+  const suffix = rendered ? ` (${rendered} rendered with native model:)` : "";
+  info(`  \u2705  Created ${count} skill entries in .claude/skills/${suffix}`);
+  return count;
+}
+function generate_claude_commands(active_command_slugs = null) {
+  if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains"))) {
+    process.stderr.write("  \u26A0\uFE0F  src/domains/ not found \u2014 skipping commands\n");
+    return 0;
+  }
+  _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
+  let skill_names = /* @__PURE__ */ new Set();
+  if (_exists(MODULE_STATE.SKILLS_SOURCE)) {
+    skill_names = new Set(
+      _iterdirSorted(MODULE_STATE.SKILLS_SOURCE).filter((p) => _isDir(p)).map((p) => path.basename(p))
+    );
+  }
+  const current_slugs = /* @__PURE__ */ new Set();
+  let count = 0;
+  let skipped = 0;
+  let reserved = 0;
+  let rendered = 0;
+  const auto = _read_model_auto_switch() === "auto";
+  for (const [source_file, slug] of iterCommands()) {
+    if (active_command_slugs !== null && !active_command_slugs.has(slug)) {
+      continue;
+    }
+    if (skill_names.has(slug)) {
+      skipped += 1;
+      continue;
+    }
+    if (is_claude_builtin_name(slug)) {
+      reserved += 1;
+      continue;
+    }
+    current_slugs.add(slug);
+    const skill_dir = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, slug);
+    _mkdirp(skill_dir);
+    const skill_file = path.join(skill_dir, "SKILL.md");
+    if (_existsOrSymlink(skill_file)) {
+      fs.unlinkSync(skill_file);
+    }
+    const rel_path = _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT);
+    const value = auto ? _model_tier(source_file) : null;
+    if (value !== null && value in TIER_TO_CLAUDE_MODEL) {
+      _writeText(skill_file, _render_native_model_md(source_file, value));
+      rendered += 1;
+    } else {
+      const rel_target = path.join("../../..", rel_path);
+      fs.symlinkSync(rel_target, skill_file);
+    }
+    count += 1;
+  }
+  let removed_dirs = 0;
+  for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
+    if (!_isDirNoFollow(item) || _isSymlink(item)) {
+      continue;
+    }
+    const name = path.basename(item);
+    if (skill_names.has(name) || current_slugs.has(name)) {
+      continue;
+    }
+    const skill_md = path.join(item, "SKILL.md");
+    if (_isSymlink(skill_md) || _isFile(skill_md)) {
+      const entries = _iterdirSorted(item);
+      if (entries.length === 1 && path.basename(entries[0]) === "SKILL.md") {
+        fs.unlinkSync(skill_md);
+        fs.rmdirSync(item);
+        removed_dirs += 1;
+      }
+    }
+  }
+  let msg = `  \u2705  Created ${count} command entries in .claude/skills/`;
+  if (rendered) {
+    msg += ` (${rendered} rendered with native model:)`;
+  }
+  if (skipped) {
+    msg += ` (${skipped} skipped \u2014 same-name skill exists)`;
+  }
+  if (reserved) {
+    msg += ` (${reserved} withheld \u2014 Claude Code built-in name)`;
+  }
+  if (removed_dirs) {
+    msg += ` (${removed_dirs} stale dirs removed)`;
+  }
+  info(msg);
+  return count;
+}
+function generate_claude_subagents() {
+  if (!_isDir(MODULE_STATE.SUBAGENTS_SOURCE)) {
+    return 0;
+  }
+  _mkdirp(MODULE_STATE.CLAUDE_AGENTS_DIR);
+  const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, "*.md").filter(
+    (p) => _isFile(p) && !path.basename(p).startsWith("_")
+  );
+  const current = /* @__PURE__ */ new Set();
+  let count = 0;
+  const defensePath = path.join(MODULE_STATE.SUBAGENTS_SOURCE, "_prompt-defense.md");
+  const defense = _isFile(defensePath) ? _readText(defensePath).trim() : "";
+  for (const src of sources) {
+    const stem = path.basename(src, ".md");
+    const text = _readText(src);
+    if (!text.startsWith("---\n")) {
+      continue;
+    }
+    const end = text.indexOf("\n---\n", 4);
+    if (end === -1) {
+      continue;
+    }
+    const fmBlock = text.slice(4, end);
+    const body = text.slice(end + 5);
+    const fm = _yamlParse(fmBlock);
+    if (fm === null) {
+      continue;
+    }
+    const name = typeof fm["name"] === "string" ? fm["name"] : stem;
+    const description = typeof fm["description"] === "string" ? fm["description"] : "";
+    const toolsRaw = fm["tools"];
+    const tools = Array.isArray(toolsRaw) ? toolsRaw.map((t) => String(t)).join(", ") : String(toolsRaw ?? "");
+    const tier = typeof fm["model_tier"] === "string" ? fm["model_tier"] : "inherit";
+    const model = tier === "inherit" ? "inherit" : TIER_TO_CLAUDE_MODEL[tier] ?? "inherit";
+    const effort = typeof fm["effort"] === "string" ? fm["effort"] : null;
+    const guardedBody = defense !== "" && !body.includes("prompt-defense-preamble") ? `
+${defense}
+${body}` : body;
+    const out = `---
+name: ${name}
+description: ${description}
+tools: ${tools}
+model: ${model}
+` + (effort !== null ? `effort: ${effort}
+` : "") + "---\n" + guardedBody;
+    const target = path.join(MODULE_STATE.CLAUDE_AGENTS_DIR, `${name}.md`);
+    _writeText(target, out);
+    current.add(`${name}.md`);
+    count += 1;
+  }
+  for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_AGENTS_DIR)) {
+    const base = path.basename(item);
+    if (base === "README.md" || current.has(base)) {
+      continue;
+    }
+    if (_isFile(item) && base.endsWith(".md") && !_isSymlink(item)) {
+      fs.unlinkSync(item);
+    }
+  }
+  info(`  \u2705  Created ${count} subagent entries in .claude/agents/`);
+  return count;
+}
+function generate_subagent_host_contexts() {
+  if (!_isDir(MODULE_STATE.SUBAGENTS_SOURCE)) {
+    return 0;
+  }
+  const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, "*.md").filter((p) => _isFile(p));
+  const rendered = [];
+  for (const src of sources) {
+    const stem = path.basename(src, ".md");
+    const text = _readText(src);
+    if (!text.startsWith("---\n")) {
+      continue;
+    }
+    const end = text.indexOf("\n---\n", 4);
+    if (end === -1) {
+      continue;
+    }
+    const fm = _yamlParse(text.slice(4, end));
+    if (fm === null) {
+      continue;
+    }
+    const body = text.slice(end + 5);
+    const name = typeof fm["name"] === "string" ? fm["name"] : stem;
+    const description = typeof fm["description"] === "string" ? fm["description"] : "";
+    const trustRaw = fm["trust"];
+    const trust = typeof trustRaw === "string" ? trustRaw : typeof trustRaw === "object" && trustRaw !== null && typeof trustRaw["level"] === "string" ? trustRaw["level"] : "unknown";
+    const lifecycle = typeof fm["lifecycle"] === "string" ? fm["lifecycle"] : "unknown";
+    const tier = typeof fm["model_tier"] === "string" ? fm["model_tier"] : "inherit";
+    const toolsRaw = fm["tools"];
+    const tools = Array.isArray(toolsRaw) ? toolsRaw.map((t) => String(t)).join(", ") : String(toolsRaw ?? "");
+    const out = `---
+description: ${description}
+---
+
+# Subagent (passive reference): ${name}
+
+> Passive subagent reference. This host has **no native subagent dispatch** \u2014
+> there is no \`@${name}\` here. Load this discipline manually and apply it.
+> Governance parity (trust / lifecycle / model tier) is preserved below;
+> feature parity is not (ADR-109 \xA74).
+
+- trust: ${trust}
+- lifecycle: ${lifecycle}
+- model tier: ${tier}
+` + (tools ? `- tools: ${tools}
+` : "") + "\n" + _pyRstrip(body) + "\n";
+    rendered.push({ name, text: out });
+  }
+  const targets = [
+    {
+      active: _tool_active("cursor"),
+      dir: path.join(MODULE_STATE.PROJECT_ROOT, ".cursor", "subagents"),
+      file: (n) => `${n}.md`,
+      owns: (b) => b.endsWith(".md")
+    },
+    {
+      active: _tool_active("windsurf"),
+      dir: path.join(MODULE_STATE.PROJECT_ROOT, ".windsurf", "subagents"),
+      file: (n) => `${n}.md`,
+      owns: (b) => b.endsWith(".md")
+    },
+    {
+      active: _tool_active("cline"),
+      dir: path.join(MODULE_STATE.PROJECT_ROOT, ".clinerules"),
+      file: (n) => `${n}.subagent.md`,
+      owns: (b) => b.endsWith(".subagent.md")
+    }
+  ];
+  let count = 0;
+  for (const t of targets) {
+    if (!t.active) {
+      continue;
+    }
+    const current = new Set(rendered.map((r) => t.file(r.name)));
+    _mkdirp(t.dir);
+    for (const r of rendered) {
+      _writeText(path.join(t.dir, t.file(r.name)), r.text);
+      count += 1;
+    }
+    if (_exists(t.dir)) {
+      for (const item of _iterdirSorted(t.dir)) {
+        const base = path.basename(item);
+        if (base === "README.md" || current.has(base)) {
+          continue;
+        }
+        if (_isFile(item) && !_isSymlink(item) && t.owns(base)) {
+          fs.unlinkSync(item);
+        }
+      }
+    }
+  }
+  info(`  \u2705  Projected ${count} passive subagent context file(s) to non-Claude-Code hosts`);
+  return count;
+}
+var PLUGIN_POINTER_SLUG = "install-agent-config";
+var PLUGIN_POINTER_SKILL_BODY = `---
+name: install-agent-config
+description: >-
+  Install or upgrade the event4u agent-config suite. This marketplace plugin
+  is a bootstrap shim \u2014 it ships hooks plus this pointer only; ALL skills,
+  rules, and commands are installed via \`npx -y @event4u/agent-config init\`.
+  Use when the user asks to install, set up, or upgrade agent-config, or
+  wonders why this plugin contains no other skills.
+---
+
+# Install agent-config
+
+This plugin is a **bootstrap shim**. It exists so the marketplace listing
+stays discoverable and existing plugin installs keep working hooks \u2014 the
+content surface (skills, rules, commands, personas) is distributed as a
+file projection, not through this plugin.
+
+## Install (canonical, one command)
+
+\`\`\`bash
+npx -y @event4u/agent-config init
+\`\`\`
+
+The installer writes the full content projection, registers the dispatcher
+hooks as a managed block in \`~/.claude/settings.json\` (byte-identical to
+this plugin's hooks, so nothing double-fires), and keeps everything
+upgradeable via \`agent-config upgrade\`.
+
+## Already installed both?
+
+Run \`agent-config doctor\` to check for duplicate surfaces, and
+\`agent-config converge\` to clean up consented duplicates.
+`;
+function generate_plugin_command_skills() {
+  if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, "src", "domains"))) {
+    return 0;
+  }
+  _mkdirp(MODULE_STATE.PLUGIN_SKILLS_DIR);
+  const pointer_dir = path.join(MODULE_STATE.PLUGIN_SKILLS_DIR, PLUGIN_POINTER_SLUG);
+  _mkdirp(pointer_dir);
+  const pointer_file = path.join(pointer_dir, "SKILL.md");
+  if (_isSymlink(pointer_file)) {
+    fs.unlinkSync(pointer_file);
+  }
+  if (!_isFile(pointer_file) || fs.readFileSync(pointer_file, "utf-8") !== PLUGIN_POINTER_SKILL_BODY) {
+    fs.writeFileSync(pointer_file, PLUGIN_POINTER_SKILL_BODY);
+  }
+  let removed_dirs = 0;
+  for (const item of _iterdirSorted(MODULE_STATE.PLUGIN_SKILLS_DIR)) {
+    if (!_isDirNoFollow(item) || _isSymlink(item)) {
+      continue;
+    }
+    if (path.basename(item) === PLUGIN_POINTER_SLUG) {
+      continue;
+    }
+    const entries = _iterdirSorted(item);
+    const all_symlinks = entries.length > 0 && entries.every((e) => _isSymlink(e));
+    const single_skill_md = entries.length === 1 && path.basename(entries[0]) === "SKILL.md" && _isFile(entries[0]);
+    if (all_symlinks || single_skill_md) {
+      for (const e of entries) {
+        fs.unlinkSync(e);
+      }
+      fs.rmdirSync(item);
+      removed_dirs += 1;
+    }
+  }
+  let msg = "  \u2705  Plugin skills: bootstrap shim (1 pointer skill) in .claude-plugin/skills/";
+  if (removed_dirs) {
+    msg += ` (${removed_dirs} content entries pruned)`;
+  }
+  info(msg);
+  return 1;
+}
+function generate_persona_symlinks() {
+  if (!_exists(MODULE_STATE.PERSONAS_SOURCE)) {
+    _print("  \u26A0\uFE0F  dist/agent-src/personas/ not found \u2014 skipping personas");
+    return 0;
+  }
+  const personas = _rglobSorted(MODULE_STATE.PERSONAS_SOURCE, "*.md").filter((p) => _isFile(p) && path.basename(p, ".md") !== "README").map((p) => path.basename(p)).filter((name) => _isFile(path.join(MODULE_STATE.PERSONAS_SOURCE, name)));
+  const direct = _iterdirSorted(MODULE_STATE.PERSONAS_SOURCE).filter((p) => p.endsWith(".md") && _isFile(p) && path.basename(p, ".md") !== "README").map((p) => path.basename(p)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  void personas;
+  const list = direct;
+  const tool_dirs = _filter_tool_dirs(PERSONA_TOOL_DIRS);
+  let total = 0;
+  for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+    const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+    _mkdirp(target_dir);
+    for (const item of _iterdirSorted(target_dir)) {
+      const name = path.basename(item);
+      if (_isSymlink(item) && !list.includes(name) && name !== "README.md") {
+        fs.unlinkSync(item);
+      }
+    }
+    for (const persona of list) {
+      const link = path.join(target_dir, persona);
+      const target = path.join(rel_prefix, persona);
+      if (_existsOrSymlink(link)) {
+        fs.unlinkSync(link);
+      }
+      fs.symlinkSync(target, link);
+      total += 1;
+    }
+  }
+  info(
+    `  \u2705  Created ${total} persona symlinks across ${Object.keys(tool_dirs).length} tool directories (${list.length} personas each)`
+  );
+  return total;
+}
+function generate_user_type_symlinks() {
+  if (!_exists(MODULE_STATE.USER_TYPES_SOURCE)) {
+    _print("  \u26A0\uFE0F  dist/agent-src/user-types/ not found \u2014 skipping user-types");
+    return 0;
+  }
+  const user_types = _iterdirSorted(MODULE_STATE.USER_TYPES_SOURCE).filter((p) => p.endsWith(".md") && _isFile(p) && path.basename(p, ".md") !== "README").map((p) => path.basename(p)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const tool_dirs = _filter_tool_dirs(USER_TYPE_TOOL_DIRS);
+  let total = 0;
+  for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
+    const target_dir = path.join(MODULE_STATE.PROJECT_ROOT, tool_dir);
+    _mkdirp(target_dir);
+    for (const item of _iterdirSorted(target_dir)) {
+      const name = path.basename(item);
+      if (_isSymlink(item) && !user_types.includes(name) && name !== "README.md") {
+        fs.unlinkSync(item);
+      }
+    }
+    for (const user_type of user_types) {
+      const link = path.join(target_dir, user_type);
+      const target = path.join(rel_prefix, user_type);
+      if (_existsOrSymlink(link)) {
+        fs.unlinkSync(link);
+      }
+      fs.symlinkSync(target, link);
+      total += 1;
+    }
+  }
+  info(
+    `  \u2705  Created ${total} user-type symlinks across ${Object.keys(tool_dirs).length} tool directories (${user_types.length} user-types each)`
+  );
+  return total;
+}
+function generate_plugin_hooks() {
+  const manifest_path = path.join(
+    MODULE_STATE.PROJECT_ROOT,
+    "src",
+    "scripts",
+    "hook_manifest.yaml"
+  );
+  if (!_exists(manifest_path)) {
+    process.stderr.write("  \u26A0\uFE0F  scripts/hook_manifest.yaml not found \u2014 skipping plugin hooks\n");
+    return 0;
+  }
+  const matrix = build_claude_hook_matrix(manifest_path);
+  const hooks = {};
+  for (const [native, command] of Object.entries(matrix)) {
+    hooks[native] = [{ hooks: [{ type: "command", command }] }];
+  }
+  const hooks_dir = path.join(MODULE_STATE.PROJECT_ROOT, "hooks");
+  _mkdirp(hooks_dir);
+  const out = path.join(hooks_dir, "hooks.json");
+  _writeText(out, _jsonDumpsHooks({ hooks }) + "\n");
+  info(`  \u2705  Generated hooks/hooks.json (${Object.keys(hooks).length} Claude plugin hooks)`);
+  return Object.keys(hooks).length;
+}
+function _jsonDumpsHooks(obj) {
+  return _pyJson(obj, 0);
+}
+function _pyJson(value, indent) {
+  const pad = "  ".repeat(indent);
+  const padInner = "  ".repeat(indent + 1);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((v) => padInner + _pyJson(v, indent + 1));
+    return `[
+${items.join(",\n")}
+${pad}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const items = entries.map(([k, v]) => `${padInner}${JSON.stringify(k)}: ${_pyJson(v, indent + 1)}`);
+    return `{
+${items.join(",\n")}
+${pad}}`;
+  }
+  return JSON.stringify(value);
+}
+function _generate_tools_inner(cmd_slugs, skill_names) {
+  info("\u{1F527}  Generating multi-agent tool directories...\n");
+  const rules = generate_rule_symlinks();
+  const windsurfrules = _tool_active("windsurf") ? generate_windsurfrules() : 0;
+  if (_tool_active("gemini")) {
+    generate_gemini_md();
+  }
+  const skills = _tool_active("claude-code") ? generate_claude_skills(skill_names) : 0;
+  const commands = _tool_active("claude-code") ? generate_claude_commands(cmd_slugs) : 0;
+  const subagents = _tool_active("claude-code") ? generate_claude_subagents() : 0;
+  const subagent_contexts = generate_subagent_host_contexts();
+  const plugin_cmd_skills = _tool_active("claude-code") ? generate_plugin_command_skills() : 0;
+  const plugin_hooks = _tool_active("claude-code") ? generate_plugin_hooks() : 0;
+  const personas = generate_persona_symlinks();
+  const user_types = generate_user_type_symlinks();
+  const cursor_mdc = _tool_active("cursor") ? generate_cursor_mdc_rules() : 0;
+  const windsurf_modern = _tool_active("windsurf") ? generate_windsurf_modern_rules() : 0;
+  const cursor_cmds = _tool_active("cursor") ? generate_cursor_commands(cmd_slugs) : 0;
+  const windsurf_wf = _tool_active("windsurf") ? generate_windsurf_workflows(cmd_slugs) : 0;
+  const summary = `\u2705  generate-tools \u2014 rules=${rules} skills=${skills} commands=${commands} subagents=${subagents} subagent_contexts=${subagent_contexts} plugin_cmd_skills=${plugin_cmd_skills} plugin_hooks=${plugin_hooks} personas=${personas} user_types=${user_types} cursor_mdc=${cursor_mdc} windsurf_rules=${windsurf_modern} cursor_commands=${cursor_cmds} windsurf_workflows=${windsurf_wf} windsurfrules=${windsurfrules}`;
+  if (resolve_level() === "verbose") {
+    _print(`
+${summary}`);
+  } else {
+    success(summary);
+    flush_summary();
+  }
+}
+function generate_tools() {
+  const [cmd_slugs, skill_names] = _resolve_active_predicates();
+  const scoped = cmd_slugs !== null;
+  try {
+    _generate_tools_inner(cmd_slugs, skill_names);
+  } catch (e) {
+    if (scoped) {
+      info("  \u26A0\uFE0F  scoped projection failed \u2014 restoring full (legacy-all) projection");
+      _generate_tools_inner(null, null);
+    }
+    throw e;
+  }
+  if (!scoped) {
+    info(
+      "  \u2139\uFE0F  Profile mode available \u2014 focused surface. Run `agent-config use --profile=developer`."
+    );
+  }
+}
+var AUGMENT_SYMLINK_DIRS = [
+  "skills",
+  "commands",
+  "guidelines",
+  "personas",
+  "user-types",
+  "templates",
+  "contexts",
+  "scripts"
+];
+var AUGMENT_SYMLINK_FILES = ["README.md"];
+function project_to_augment() {
+  if (!_exists(MODULE_STATE.TARGET_DIR)) {
+    _print(`  \u26A0\uFE0F  ${path.basename(MODULE_STATE.TARGET_DIR)}/ not found \u2014 nothing to project`);
+    return;
+  }
+  _mkdirp(MODULE_STATE.AUGMENT_DIR);
+  const use_symlinks = _read_augment_rules_use_symlinks();
+  const src_rules = path.join(MODULE_STATE.TARGET_DIR, "rules");
+  const dst_rules = path.join(MODULE_STATE.AUGMENT_DIR, "rules");
+  _mkdirp(dst_rules);
+  const existing = new Set(
+    _iterdirSorted(dst_rules).filter((f) => _isFile(f) || _isSymlink(f)).map((f) => path.basename(f))
+  );
+  const current = /* @__PURE__ */ new Set();
+  let written = 0;
+  if (_exists(src_rules)) {
+    const rules = _iterdirSorted(src_rules).filter((p) => p.endsWith(".md") && _isFile(p)).map((p) => path.basename(p)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    for (const rule of rules) {
+      const target = path.join(dst_rules, rule);
+      if (_isSymlink(target) || _existsOrSymlink(target)) {
+        fs.unlinkSync(target);
+      }
+      if (use_symlinks) {
+        fs.symlinkSync(path.join("..", "..", "dist/agent-src", "rules", rule), target);
+      } else {
+        copy_file(path.join(src_rules, rule), target);
+      }
+      current.add(rule);
+      written += 1;
+    }
+  }
+  let removed_rules = 0;
+  for (const name of existing) {
+    if (!current.has(name)) {
+      fs.unlinkSync(path.join(dst_rules, name));
+      removed_rules += 1;
+    }
+  }
+  const mode_label = use_symlinks ? "Symlinked" : "Copied";
+  _print(
+    `  \u2705  ${mode_label} ${written} rules to .augment/rules/` + (removed_rules ? ` (${removed_rules} stale removed)` : "")
+  );
+  for (const sub of AUGMENT_SYMLINK_DIRS) {
+    const dst = path.join(MODULE_STATE.AUGMENT_DIR, sub);
+    if (_isSymlink(dst) || _existsOrSymlink(dst)) {
+      if (_isDir(dst) && !_isSymlink(dst)) {
+        fs.rmSync(dst, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(dst);
+      }
+    }
+    const src = path.join(MODULE_STATE.TARGET_DIR, sub);
+    if (_exists(src)) {
+      fs.symlinkSync(path.join("..", "dist/agent-src", sub), dst);
+      _print(`  \u2705  Symlinked .augment/${sub} \u2192 ../dist/agent-src/${sub}`);
+    }
+  }
+  for (const name of AUGMENT_SYMLINK_FILES) {
+    const dst = path.join(MODULE_STATE.AUGMENT_DIR, name);
+    const src = path.join(MODULE_STATE.TARGET_DIR, name);
+    if (_isSymlink(dst) || _existsOrSymlink(dst)) {
+      fs.unlinkSync(dst);
+    }
+    if (_exists(src)) {
+      fs.symlinkSync(path.join("..", "dist/agent-src", name), dst);
+      _print(`  \u2705  Symlinked .augment/${name} \u2192 ../dist/agent-src/${name}`);
+    }
+  }
+  const known = /* @__PURE__ */ new Set([...AUGMENT_SYMLINK_DIRS, ...AUGMENT_SYMLINK_FILES, "rules", "state"]);
+  for (const item of _iterdirSorted(MODULE_STATE.AUGMENT_DIR)) {
+    const name = path.basename(item);
+    if (known.has(name)) {
+      continue;
+    }
+    if (_isSymlink(item) || _isFile(item)) {
+      fs.unlinkSync(item);
+      _print(`  \u{1F5D1}\uFE0F  Removed stale .augment/${name}`);
+    } else if (_isDir(item)) {
+      fs.rmSync(item, { recursive: true, force: true });
+      _print(`  \u{1F5D1}\uFE0F  Removed stale .augment/${name}/`);
+    }
+  }
+}
+function clean_tools() {
+  const targets = [
+    path.join(MODULE_STATE.PROJECT_ROOT, ".claude"),
+    path.join(MODULE_STATE.PROJECT_ROOT, ".cursor"),
+    path.join(MODULE_STATE.PROJECT_ROOT, ".clinerules"),
+    path.join(MODULE_STATE.PROJECT_ROOT, ".windsurf"),
+    path.join(MODULE_STATE.PROJECT_ROOT, ".windsurfrules"),
+    path.join(MODULE_STATE.PROJECT_ROOT, "GEMINI.md")
+  ];
+  for (const t of targets) {
+    if (_isDirNoFollow(t) && !_isSymlink(t)) {
+      fs.rmSync(t, { recursive: true, force: true });
+      _print(`  \u{1F5D1}\uFE0F  Removed ${_relativeToPosix(t, MODULE_STATE.PROJECT_ROOT)}`);
+    } else if (_existsOrSymlink(t)) {
+      fs.unlinkSync(t);
+      _print(`  \u{1F5D1}\uFE0F  Removed ${_relativeToPosix(t, MODULE_STATE.PROJECT_ROOT)}`);
+    }
+  }
+  _print("\u2705  All generated tool files cleaned");
+}
+function _print(line) {
+  process.stdout.write(`${line}
+`);
+}
+function main(argv = process.argv.slice(2)) {
+  if (!_exists(MODULE_STATE.SOURCE_DIR) && !_any_source_root_exists()) {
+    _print(
+      `\u274C  No source directory found (looked at the artefact roots under src/ and ${MODULE_STATE.SOURCE_DIR})`
+    );
+    return 1;
+  }
+  const arg = argv.length > 0 ? argv[0] : "--sync";
+  if (arg === "--list") {
+    const files = list_md_files(MODULE_STATE.SOURCE_DIR);
+    _print(`\u{1F4C4}  ${files.length} .md files total:
+`);
+    for (const f of files) {
+      _print(`  ${f}`);
+    }
+  } else if (arg === "--changed") {
+    const changed = list_changed_md(MODULE_STATE.SOURCE_DIR);
+    if (changed.length === 0) {
+      _print("\u2705  Every .md projection matches its source");
+      return 0;
+    }
+    _print(`\u{1F4DD}  ${changed.length} .md projection(s) out of date \u2014 run 'task sync':
+`);
+    for (const f of changed) {
+      _print(`  ${f}`);
+    }
+  } else if (arg === "--check") {
+    const [missing, stale] = check_sync(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+    if (missing.length === 0 && stale.length === 0) {
+      _print("\u2705  dist/agent-src/ is in sync with the artefact roots under src/");
+      return 0;
+    }
+    if (missing.length > 0) {
+      _print(`\u274C  Missing in dist/agent-src/ (${missing.length}):`);
+      for (const f of missing) {
+        _print(`  ${f}`);
+      }
+    }
+    if (stale.length > 0) {
+      _print(`\u274C  Stale in dist/agent-src/ (${stale.length}):`);
+      for (const f of stale) {
+        _print(`  ${f}`);
+      }
+    }
+    _print(`
+Run 'task sync' \u2014 the projection is a deterministic copy, so it needs no agent step.`);
+    return 1;
+  } else if (arg === "--sync") {
+    _print(`Source: the artefact roots under src/`);
+    _print(`Target: ${MODULE_STATE.TARGET_DIR}
+`);
+    _print("--- Syncing non-.md files ---");
+    const copied = sync_non_md(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+    _print(`
+--- Cleanup stale files ---`);
+    const deleted = cleanup_stale(MODULE_STATE.SOURCE_DIR, MODULE_STATE.TARGET_DIR);
+    const changed = list_changed_md(MODULE_STATE.SOURCE_DIR);
+    _print(`
+\u2705  Done: ${copied} copied, ${deleted} stale deleted`);
+    if (changed.length > 0) {
+      _print(`\u274C  ${changed.length} .md projection(s) still out of date after sync (run --changed)`);
+    } else {
+      _print(`\u2705  Every .md projection matches its source`);
+    }
+    _print(`
+--- Projecting dist/agent-src/ \u2192 .augment/ ---`);
+    project_to_augment();
+  } else if (arg === "--generate-tools") {
+    generate_tools();
+  } else if (arg === "--clean-tools") {
+    clean_tools();
+  } else if (arg === "--project-augment") {
+    project_to_augment();
+  } else {
+    _print(
+      "Usage: condense [--sync|--list|--changed|--check|--generate-tools|--clean-tools|--project-augment]"
+    );
+    return 1;
+  }
+  return 0;
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var isMain = _isCliEntry();
+if (isMain) {
+  process.exit(main());
+}
+
+// src/install/rule_scope.ts
+var COMPAT_ALWAYS_EXCLUDED = ["source-of-truth.md"];
+var LEGACY_ALL = { workspaces: null, packs: null };
+function _list(value) {
+  if (Array.isArray(value) && value.length > 0) {
+    return value.map((v) => String(v));
+  }
+  return null;
+}
+function ruleScopeFromSettings(settings) {
+  const proj = settings["projection"];
+  if (typeof proj !== "object" || proj === null || Array.isArray(proj)) {
+    return LEGACY_ALL;
+  }
+  const p = proj;
+  return {
+    workspaces: _list(p["rule_workspaces"]),
+    packs: _list(p["rule_packs"]),
+    roles: _list(p["rule_roles"])
+  };
+}
+function ruleFileArrives(sourcePath, scope) {
+  if (!sourcePath.endsWith(".md")) {
+    return true;
+  }
+  const basename3 = path2.basename(sourcePath);
+  if (COMPAT_ALWAYS_EXCLUDED.includes(basename3)) {
+    return false;
+  }
+  return rule_in_scope(sourcePath, scope.workspaces, scope.packs, scope.roles ?? null);
+}
+function excludedRuleBasenames(rulesDir, scope) {
+  let entries;
+  try {
+    entries = fs2.readdirSync(rulesDir).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (!name.endsWith(".md")) {
+      continue;
+    }
+    const full = path2.join(rulesDir, name);
+    try {
+      if (!fs2.statSync(full).isFile()) {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (!ruleFileArrives(full, scope)) {
+      out.push(name);
+    }
+  }
+  return out;
+}
+
+export {
+  LEGACY_ALL,
+  ruleScopeFromSettings,
+  ruleFileArrives,
+  excludedRuleBasenames
+};