@alessandroraffa/tangyr 0.9.0 → 0.10.0

package/README.md

@@ -21,23 +21,16 @@ tangyr <command>
 
 ### Kit management
 
-| Command                       | Description                                                         |
-| ----------------------------- | ------------------------------------------------------------------- |
-| `tangyr install --kit <name>` | Install a kit; runs assess, resolves conflicts, writes artifacts    |
-| `tangyr uninstall`            | Remove Tangyr from the target scope                                 |
-| `tangyr sync`                 | Synchronize installed kit to the latest version                     |
-| `tangyr verify`               | Check installation integrity against the manifest                   |
-| `tangyr cleanup`              | Remove managed artifacts; delegates to uninstall if manifest exists |
-| `tangyr assess`               | Pre-installation conflict analysis                                  |
-| `tangyr list`                 | Display available and installed kits                                |
-
-### Authentication
-
-| Command              | Description                           |
-| -------------------- | ------------------------------------- |
-| `tangyr auth login`  | Store a license key for the Full tier |
-| `tangyr auth status` | Show current authentication state     |
-| `tangyr auth logout` | Remove stored credentials             |
+| Command                            | Description                                                                                          |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `tangyr install --kit <name>`      | Install a kit resolved from configured search paths (`kitSearchPaths`/`kit` in `tangyr.config.yaml`) |
+| `tangyr install --kit-path <path>` | Install a kit from an explicit kit root path                                                         |
+| `tangyr uninstall`                 | Remove Tangyr from the target scope                                                                  |
+| `tangyr sync`                      | Synchronize installed kit to the latest version                                                      |
+| `tangyr verify`                    | Check installation integrity against the manifest                                                    |
+| `tangyr cleanup`                   | Remove managed artifacts; delegates to uninstall if manifest exists                                  |
+| `tangyr assess`                    | Pre-installation conflict analysis                                                                   |
+| `tangyr list`                      | Display kits discovered in configured search paths and any installed manifests                       |
 
 ### Environment
 
@@ -58,15 +51,16 @@ tangyr <command>
 
 ## Global flags
 
-| Flag                | Description                            |
-| ------------------- | -------------------------------------- |
-| `--config <path>`   | Use an explicit configuration file     |
-| `--kit-path <path>` | Use an explicit operating kit root     |
-| `--dry-run`         | Report actions without modifying files |
-| `--yes`             | Skip confirmation prompts              |
-| `--verbose`         | Detailed output                        |
-| `--quiet`           | Errors only                            |
-| `--no-color`        | Disable colors                         |
+| Flag                         | Description                                                                                           |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `--config <path>`            | Use an explicit configuration file                                                                    |
+| `--kit-path <path>`          | Use an explicit operating kit root                                                                    |
+| `--dry-run`                  | Report actions without modifying files                                                                |
+| `--yes`                      | Skip confirmation prompts                                                                             |
+| `--verbose`                  | Detailed output                                                                                       |
+| `--quiet`                    | Errors only                                                                                           |
+| `--no-color`                 | Disable colors                                                                                        |
+| `--claude-config-dir <path>` | Claude Code global root directory (repeatable). Overrides `claudeCodeGlobalPaths` in the config file. |
 
 ## Supported tools
 
@@ -83,14 +77,12 @@ tangyr <command>
 # Initialize a configuration in your project
 npx @alessandroraffa/tangyr init
 
-# Install a kit (dry-run first to preview)
-npx @alessandroraffa/tangyr install --kit lite --dry-run
-npx @alessandroraffa/tangyr install --kit lite
+# Install a kit by path (preview with --dry-run first)
+npx @alessandroraffa/tangyr install --kit-path ./path/to/operating-kit --dry-run
+npx @alessandroraffa/tangyr install --kit-path ./path/to/operating-kit
 
-# Check installation status
+# Check installation status, then sync after a kit update
 npx @alessandroraffa/tangyr status
-
-# Synchronize after a kit update
 npx @alessandroraffa/tangyr sync
 ```
 
@@ -103,9 +95,26 @@ Every write command accepts `--scope global` or `--scope project`. The CLI flag
 | `global`  | `~/.tangyr/manifest.json` | `~/.claude/`                        |
 | `project` | `.tangyr/manifest.json`   | repo root (`AGENTS.md`, `.claude/`) |
 
-## Distribution model
+## Multiple Claude Code global roots
+
+If you maintain more than one Claude Code account (e.g. `~/.claude` and `~/.claude-work`), you can keep them identical with a single sync operation.
+
+**Via config** (`tangyr.config.yaml`):
+
+```yaml
+claudeCodeGlobalPaths:
+  - ~/.claude
+  - ~/.claude-work
+```
+
+**Via CLI flag** (repeatable, overrides the config field):
+
+```sh
+tangyr sync --claude-config-dir ~/.claude --claude-config-dir ~/.claude-work
+```
+
+Precedence: `--claude-config-dir` flag > `claudeCodeGlobalPaths` in config > default `~/.claude`.
 
-- **Lite** — publicly available, core agents and essential skills
-- **Full** — requires license key, complete agent roster and all skills
+Per-root artifacts (instructions, agents, skills, commands, rules, output-styles, hooks settings) are written under each root. Shared artifacts (`~/.claude.json` for MCP, `~/.agents/hooks` for hooks) are resolved from the platform default and written once regardless of how many roots are configured.
 
-Run `tangyr auth login` to authenticate with a Full-tier license key.
+The manifest records the full set of roots written so that `verify` and `uninstall` operate on all of them.

package/dist/index.js

@@ -1368,8 +1368,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path39 = __require("path");
-    var fs37 = __require("fs");
+    var path40 = __require("path");
+    var fs38 = __require("fs");
     var process5 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2363,7 +2363,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs37.existsSync(executableFile)) return;
+        if (fs38.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2381,11 +2381,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path39.resolve(baseDir, baseName);
-          if (fs37.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path39.extname(baseName))) return void 0;
+          const localBin = path40.resolve(baseDir, baseName);
+          if (fs38.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path40.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs37.existsSync(`${localBin}${ext}`)
+            (ext) => fs38.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2397,21 +2397,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs37.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs38.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path39.resolve(
-            path39.dirname(resolvedScriptPath),
+          executableDir = path40.resolve(
+            path40.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path39.basename(
+            const legacyName = path40.basename(
               this._scriptPath,
-              path39.extname(this._scriptPath)
+              path40.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2422,7 +2422,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path39.extname(executableFile));
+        launchWithNode = sourceExt.includes(path40.extname(executableFile));
         let proc;
         if (process5.platform !== "win32") {
           if (launchWithNode) {
@@ -3337,7 +3337,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path39.basename(filename, path39.extname(filename));
+        this._name = path40.basename(filename, path40.extname(filename));
         return this;
       }
       /**
@@ -3351,9 +3351,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path40) {
-        if (path40 === void 0) return this._executableDir;
-        this._executableDir = path40;
+      executableDir(path41) {
+        if (path41 === void 0) return this._executableDir;
+        this._executableDir = path41;
         return this;
       }
       /**
@@ -3709,17 +3709,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path39) {
-      const ctrl = callVisitor(key, node, visitor, path39);
+    function visit_(key, node, visitor, path40) {
+      const ctrl = callVisitor(key, node, visitor, path40);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path39, ctrl);
-        return visit_(key, ctrl, visitor, path39);
+        replaceNode(key, path40, ctrl);
+        return visit_(key, ctrl, visitor, path40);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path39 = Object.freeze(path39.concat(node));
+          path40 = Object.freeze(path40.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path39);
+            const ci2 = visit_(i, node.items[i], visitor, path40);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3730,13 +3730,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path39 = Object.freeze(path39.concat(node));
-          const ck = visit_("key", node.key, visitor, path39);
+          path40 = Object.freeze(path40.concat(node));
+          const ck = visit_("key", node.key, visitor, path40);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path39);
+          const cv = visit_("value", node.value, visitor, path40);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -3757,17 +3757,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path39) {
-      const ctrl = await callVisitor(key, node, visitor, path39);
+    async function visitAsync_(key, node, visitor, path40) {
+      const ctrl = await callVisitor(key, node, visitor, path40);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path39, ctrl);
-        return visitAsync_(key, ctrl, visitor, path39);
+        replaceNode(key, path40, ctrl);
+        return visitAsync_(key, ctrl, visitor, path40);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path39 = Object.freeze(path39.concat(node));
+          path40 = Object.freeze(path40.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path39);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path40);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3778,13 +3778,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path39 = Object.freeze(path39.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path39);
+          path40 = Object.freeze(path40.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path40);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path39);
+          const cv = await visitAsync_("value", node.value, visitor, path40);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -3811,23 +3811,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path39) {
+    function callVisitor(key, node, visitor, path40) {
       if (typeof visitor === "function")
-        return visitor(key, node, path39);
+        return visitor(key, node, path40);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path39);
+        return visitor.Map?.(key, node, path40);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path39);
+        return visitor.Seq?.(key, node, path40);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path39);
+        return visitor.Pair?.(key, node, path40);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path39);
+        return visitor.Scalar?.(key, node, path40);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path39);
+        return visitor.Alias?.(key, node, path40);
       return void 0;
     }
-    function replaceNode(key, path39, node) {
-      const parent = path39[path39.length - 1];
+    function replaceNode(key, path40, node) {
+      const parent = path40[path40.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -4435,10 +4435,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path39, value) {
+    function collectionFromPath(schema, path40, value) {
       let v2 = value;
-      for (let i = path39.length - 1; i >= 0; --i) {
-        const k2 = path39[i];
+      for (let i = path40.length - 1; i >= 0; --i) {
+        const k2 = path40[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -4457,7 +4457,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path39) => path39 == null || typeof path39 === "object" && !!path39[Symbol.iterator]().next().done;
+    var isEmptyPath = (path40) => path40 == null || typeof path40 === "object" && !!path40[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -4487,11 +4487,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path39, value) {
-        if (isEmptyPath(path39))
+      addIn(path40, value) {
+        if (isEmptyPath(path40))
           this.add(value);
         else {
-          const [key, ...rest] = path39;
+          const [key, ...rest] = path40;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -4505,8 +4505,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path39) {
-        const [key, ...rest] = path39;
+      deleteIn(path40) {
+        const [key, ...rest] = path40;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -4520,8 +4520,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path39, keepScalar) {
-        const [key, ...rest] = path39;
+      getIn(path40, keepScalar) {
+        const [key, ...rest] = path40;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -4539,8 +4539,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path39) {
-        const [key, ...rest] = path39;
+      hasIn(path40) {
+        const [key, ...rest] = path40;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -4550,8 +4550,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path39, value) {
-        const [key, ...rest] = path39;
+      setIn(path40, value) {
+        const [key, ...rest] = path40;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -7063,9 +7063,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path39, value) {
+      addIn(path40, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path39, value);
+          this.contents.addIn(path40, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -7140,14 +7140,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path39) {
-        if (Collection.isEmptyPath(path39)) {
+      deleteIn(path40) {
+        if (Collection.isEmptyPath(path40)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path39) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path40) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -7162,10 +7162,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path39, keepScalar) {
-        if (Collection.isEmptyPath(path39))
+      getIn(path40, keepScalar) {
+        if (Collection.isEmptyPath(path40))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path39, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path40, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -7176,10 +7176,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path39) {
-        if (Collection.isEmptyPath(path39))
+      hasIn(path40) {
+        if (Collection.isEmptyPath(path40))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path39) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path40) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -7196,13 +7196,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path39, value) {
-        if (Collection.isEmptyPath(path39)) {
+      setIn(path40, value) {
+        if (Collection.isEmptyPath(path40)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path39), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path40), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path39, value);
+          this.contents.setIn(path40, value);
         }
       }
       /**
@@ -9159,9 +9159,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path39) => {
+    visit.itemAtPath = (cst, path40) => {
       let item = cst;
-      for (const [field, index] of path39) {
+      for (const [field, index] of path40) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -9170,23 +9170,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path39) => {
-      const parent = visit.itemAtPath(cst, path39.slice(0, -1));
-      const field = path39[path39.length - 1][0];
+    visit.parentCollection = (cst, path40) => {
+      const parent = visit.itemAtPath(cst, path40.slice(0, -1));
+      const field = path40[path40.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path39, item, visitor) {
-      let ctrl = visitor(item, path39);
+    function _visit(path40, item, visitor) {
+      let ctrl = visitor(item, path40);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci2 = _visit(Object.freeze(path39.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path40.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -9197,10 +9197,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path39);
+            ctrl = ctrl(item, path40);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path39) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path40) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -10485,14 +10485,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs37 = this.flowScalar(this.type);
+              const fs38 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map.items.push({ start, key: fs37, sep: [] });
+                map.items.push({ start, key: fs38, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs37);
+                this.stack.push(fs38);
               } else {
-                Object.assign(it2, { key: fs37, sep: [] });
+                Object.assign(it2, { key: fs38, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -10620,13 +10620,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs37 = this.flowScalar(this.type);
+              const fs38 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs37, sep: [] });
+                fc.items.push({ start: [], key: fs38, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs37);
+                this.stack.push(fs38);
               else
-                Object.assign(it2, { key: fs37, sep: [] });
+                Object.assign(it2, { key: fs38, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -15011,7 +15011,10 @@ function normalizeConfig(config) {
     kit: config.kit,
     kitPath: config.kitPath,
     kitSearchPaths: config.kitSearchPaths,
-    scope: config.scope
+    scope: config.scope,
+    // claudeCodeGlobalPaths: pass through as-is; ~ expansion happens at
+    // resolve time so relative entries are not forced absolute here
+    claudeCodeGlobalPaths: config.claudeCodeGlobalPaths
   };
 }
 function findConfigPath(explicitPath) {
@@ -15249,7 +15252,10 @@ function readManifest(scopePath) {
       backupLocation: b.backupLocation,
       integerSuffix: typeof b.integerSuffix === "number" ? b.integerSuffix : 0
     })),
-    managedLinks: Array.isArray(parsed.managedLinks) ? parsed.managedLinks : []
+    managedLinks: Array.isArray(parsed.managedLinks) ? parsed.managedLinks : [],
+    claudeCodeGlobalRoots: Array.isArray(parsed.claudeCodeGlobalRoots) ? parsed.claudeCodeGlobalRoots.filter(
+      (r) => typeof r === "string"
+    ) : void 0
   };
 }
 function readStrictManifest(scopePath) {
@@ -15637,6 +15643,66 @@ function resolveClineProfile(scope, projectRoot, mappings) {
     mcp_file: r(slotMap, "mcp_file")
   };
 }
+var DEFAULT_CLAUDE_ROOT_RAW = "~/.claude";
+function resolveClaudeGlobalRoots(input) {
+  const rawRoots = (input.flag?.length ?? 0) > 0 ? input.flag : (input.config?.length ?? 0) > 0 ? input.config : [DEFAULT_CLAUDE_ROOT_RAW];
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  for (const raw of rawRoots) {
+    const abs = path8.resolve(expandHome(raw));
+    if (!seen.has(abs)) {
+      seen.add(abs);
+      roots.push(abs);
+    }
+  }
+  return roots;
+}
+var UNDER_ROOT_SLOTS = /* @__PURE__ */ new Set([
+  "instructions",
+  "instructions_shim",
+  "agents",
+  "skills",
+  "commands",
+  "rules",
+  "output_styles",
+  "hooks_shared_file",
+  "settings_shared_file"
+]);
+function resolveClaudeCodeProfileForRoot(root, mappings) {
+  const slotMap = mappings.targets["claude-code"];
+  if (!slotMap) {
+    throw new Error(
+      "platform-paths.yaml: missing claude-code target entry \u2014 run the loader validator first"
+    );
+  }
+  const r = makeResolver("global", void 0, "claude-code");
+  const defaultProfile = {
+    instructions: r(slotMap, "instructions"),
+    instructions_shim: r(slotMap, "instructions_shim"),
+    agents: r(slotMap, "agents"),
+    skills: r(slotMap, "skills"),
+    commands: r(slotMap, "commands"),
+    rules: r(slotMap, "rules"),
+    output_styles: r(slotMap, "output_styles"),
+    hooks_shared_file: r(slotMap, "hooks_shared_file"),
+    settings_shared_file: r(slotMap, "settings_shared_file"),
+    mcp_shared_file: r(slotMap, "mcp_shared_file"),
+    hooks: r(slotMap, "hooks")
+  };
+  const defaultRoot = defaultProfile.agents !== void 0 ? path8.dirname(defaultProfile.agents) : path8.resolve(expandHome(DEFAULT_CLAUDE_ROOT_RAW));
+  if (root === defaultRoot) {
+    return defaultProfile;
+  }
+  const profile = { ...defaultProfile };
+  for (const slot of UNDER_ROOT_SLOTS) {
+    const slotValue = defaultProfile[slot];
+    if (slotValue.startsWith(defaultRoot)) {
+      const suffix = slotValue.slice(defaultRoot.length);
+      profile[slot] = root + suffix;
+    }
+  }
+  return profile;
+}
 function makeResolver(scope, projectRoot, tool) {
   return (slotMap, slot) => {
     if (scope === "global") {
@@ -20144,6 +20210,10 @@ function removeManagedPath(managedPath) {
 // src/commands/uninstall.ts
 var codexManagedMcpStart = "# tangyr: managed mcp start";
 var codexManagedMcpEnd = "# tangyr: managed mcp end";
+var SHARED_CLAUDE_SLOTS = /* @__PURE__ */ new Set([
+  "mcp_shared_file",
+  "hooks"
+]);
 async function runUninstallCommand(options, logger) {
   const scope = options.scope === "global" ? "global" : "project";
   const scopePath = resolveScopePath(
@@ -20200,19 +20270,38 @@ async function runUninstallCommand(options, logger) {
       return;
     }
   }
+  const claudeRoots = scope === "global" && selectedTools.has("claude-code") ? resolveClaudeRootsForUninstall(manifest, runtime) : [];
   let removedCount = 0;
   for (const file of manifestArtifacts) {
-    const actualPath = resolveManifestKeyToPath(
-      file.relativePath,
-      scope,
-      runtime
-    );
-    if (actualPath && (fs18.existsSync(actualPath) || isSymlink(actualPath))) {
-      removeManagedPath(actualPath);
-      logger.verbose(`  removed: ${actualPath}`);
-      removedCount++;
+    const isClaudeGlobal = file.relativePath.startsWith("claude-code/") && scope === "global";
+    if (isClaudeGlobal && claudeRoots.length > 0) {
+      const paths = resolveManifestKeyToMultiPaths(
+        file.relativePath,
+        claudeRoots,
+        runtime
+      );
+      for (const actualPath of paths) {
+        if (actualPath && (fs18.existsSync(actualPath) || isSymlink(actualPath))) {
+          removeManagedPath(actualPath);
+          logger.verbose(`  removed: ${actualPath}`);
+          removedCount++;
+        } else {
+          logger.verbose(`  skipped (not found): ${actualPath}`);
+        }
+      }
     } else {
-      logger.verbose(`  skipped (not found): ${file.relativePath}`);
+      const actualPath = resolveManifestKeyToPath(
+        file.relativePath,
+        scope,
+        runtime
+      );
+      if (actualPath && (fs18.existsSync(actualPath) || isSymlink(actualPath))) {
+        removeManagedPath(actualPath);
+        logger.verbose(`  removed: ${actualPath}`);
+        removedCount++;
+      } else {
+        logger.verbose(`  skipped (not found): ${file.relativePath}`);
+      }
     }
   }
   if (runtime) {
@@ -20442,6 +20531,102 @@ function resolveClaudeCodePaths(runtime, scope, projectRoot) {
     output_styles: path17.join(root, ".claude", "output-styles")
   };
 }
+function resolveClaudeRootsForUninstall(manifest, runtime) {
+  if (Array.isArray(manifest.claudeCodeGlobalRoots) && manifest.claudeCodeGlobalRoots.length > 0) {
+    return manifest.claudeCodeGlobalRoots;
+  }
+  if (runtime) {
+    try {
+      const mappings = loadMappings(
+        runtime.sourceRoot,
+        runtime.config,
+        runtime.configDir
+      );
+      const profile = resolveTargetPaths({
+        scope: "global",
+        projectRoot: void 0,
+        mappings: mappings.platformPaths
+      })["claude-code"];
+      return [path17.dirname(profile.agents)];
+    } catch {
+    }
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return [path17.resolve(expandHome(`${home}/.claude`))];
+}
+function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
+  if (claudeRoots.length === 0) {
+    return [];
+  }
+  const afterPrefix = key.slice("claude-code/".length);
+  const slotName = afterPrefix.split("/")[0];
+  const subPath = afterPrefix.slice(slotName.length + 1) || void 0;
+  const isShared = SHARED_CLAUDE_SLOTS.has(slotName);
+  const rootsToResolve = isShared ? [claudeRoots[0]] : claudeRoots;
+  if (!runtime) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const defaultRoot = path17.resolve(expandHome(`${home}/.claude`));
+    return rootsToResolve.flatMap((root) => {
+      const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
+      if (!hardcoded) {
+        return [];
+      }
+      return [subPath ? path17.join(hardcoded, subPath) : hardcoded];
+    });
+  }
+  try {
+    const mappings = loadMappings(
+      runtime.sourceRoot,
+      runtime.config,
+      runtime.configDir
+    );
+    return rootsToResolve.flatMap((root) => {
+      const profile = resolveClaudeCodeProfileForRoot(
+        root,
+        mappings.platformPaths
+      );
+      const effectiveSlot = slotName === "CLAUDE.md" ? "instructions" : slotName;
+      const slotPath = profile[effectiveSlot] ?? null;
+      if (!slotPath) {
+        return [];
+      }
+      return [subPath ? path17.join(slotPath, subPath) : slotPath];
+    });
+  } catch {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const defaultRoot = path17.resolve(expandHome(`${home}/.claude`));
+    return rootsToResolve.flatMap((root) => {
+      const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
+      if (!hardcoded) {
+        return [];
+      }
+      return [subPath ? path17.join(hardcoded, subPath) : hardcoded];
+    });
+  }
+}
+function resolveHardcodedClaudeSlot(root, defaultRoot, slotName) {
+  const slotRelatives = {
+    instructions: "CLAUDE.md",
+    CLAUDE: "CLAUDE.md",
+    "CLAUDE.md": "CLAUDE.md",
+    instructions_shim: "CLAUDE.md",
+    agents: "agents",
+    skills: "skills",
+    commands: "commands",
+    rules: "rules",
+    output_styles: "output-styles",
+    hooks_shared_file: "settings.json",
+    settings_shared_file: "settings.json"
+  };
+  const relative = slotRelatives[slotName];
+  if (!relative) {
+    return null;
+  }
+  if (root === defaultRoot) {
+    return path17.join(root, relative);
+  }
+  return path17.join(root, relative);
+}
 function resolveRuntimeIfAvailable(options, logger) {
   try {
     return resolveRuntime(options, import.meta.url);
@@ -26307,17 +26492,54 @@ function installForTool(tool, config, kitInfo, manifest, options, mappings, logg
   if (tool !== "claude-code") {
     throwUnrecognizedTarget(tool);
   }
-  const placements = getToolPlacements(
-    tool,
-    kitInfo,
-    scope,
-    projectRoot,
-    mappings
-  );
-  let count = 0;
   manifest.artifacts = manifest.artifacts.filter(
     (file) => !file.relativePath.startsWith(`${tool}/`)
   );
+  const claudeRoots = scope === "global" && mappings ? resolveClaudeGlobalRoots({
+    flag: options.claudeConfigDir,
+    config: config.claudeCodeGlobalPaths
+  }) : void 0;
+  let count = 0;
+  if (claudeRoots && claudeRoots.length > 0 && mappings) {
+    for (const claudeRoot of claudeRoots) {
+      if (claudeRoots.length > 1) {
+        logger.info(`  claude-code: installing to root ${claudeRoot}`);
+      }
+      const rootProfile = resolveClaudeCodeProfileForRoot(
+        claudeRoot,
+        mappings.platformPaths
+      );
+      const placements = getClaudeCodePlacementsFromProfile(
+        kitInfo,
+        rootProfile
+      );
+      count += applyClaudeCodePlacements(
+        placements,
+        manifest,
+        skippedTargetPaths,
+        logger
+      );
+    }
+    manifest.claudeCodeGlobalRoots = claudeRoots;
+  } else {
+    const placements = getToolPlacements(
+      tool,
+      kitInfo,
+      scope,
+      projectRoot,
+      mappings
+    );
+    count += applyClaudeCodePlacements(
+      placements,
+      manifest,
+      skippedTargetPaths,
+      logger
+    );
+  }
+  return count;
+}
+function applyClaudeCodePlacements(placements, manifest, skippedTargetPaths, logger) {
+  let count = 0;
   for (const placement of placements) {
     if (skippedTargetPaths.has(placement.destination)) {
       logger.verbose(`  skipped (operator choice): ${placement.destination}`);
@@ -26785,6 +27007,38 @@ function getClaudeCodePlacements(kitInfo, scope = "global", projectRoot, mapping
   }
   return placements;
 }
+function getClaudeCodePlacementsFromProfile(kitInfo, profile) {
+  const placements = [];
+  const claudeMd = path31.join(kitInfo.path, "CLAUDE.md");
+  if (fs30.existsSync(claudeMd)) {
+    placements.push({
+      source: claudeMd,
+      destination: profile.instructions,
+      manifestKey: "claude-code/CLAUDE.md",
+      type: "symlink",
+      isDir: false
+    });
+  }
+  const componentDirMap = {
+    agents: profile.agents,
+    skills: profile.skills,
+    commands: profile.commands,
+    rules: profile.rules
+  };
+  for (const [component, targetPath] of Object.entries(componentDirMap)) {
+    const componentDir = path31.join(kitInfo.path, component);
+    if (fs30.existsSync(componentDir) && fs30.statSync(componentDir).isDirectory()) {
+      placements.push({
+        source: componentDir,
+        destination: targetPath,
+        manifestKey: `claude-code/${component}`,
+        type: "symlink",
+        isDir: true
+      });
+    }
+  }
+  return placements;
+}
 function collectAllFiles(kitInfo) {
   const files = /* @__PURE__ */ new Map();
   const claudeMd = path31.join(kitInfo.path, "CLAUDE.md");
@@ -27017,18 +27271,13 @@ function runStatusCommand(options, logger) {
     if (target !== "claude-code" && target !== "copilot" && target !== "codex") {
       throwUnrecognizedTarget(target);
     }
-    const rows = target === "claude-code" ? [
-      ...claudeDirectArtifacts(
-        sourceRoot,
-        config,
-        configDir,
-        scope,
-        projectRoot
-      ).map(
-        (artifact) => classifyDirectArtifact(artifact, config, sourceRoot)
-      ),
-      ...classifyClaudeSharedFiles(config, sourceRoot)
-    ] : target === "copilot" ? classifyCopilotFiles(config, sourceRoot, configDir) : classifyCodexFiles(config, sourceRoot, configDir);
+    const rows = target === "claude-code" ? classifyClaudeCodeRows(
+      sourceRoot,
+      config,
+      configDir,
+      scope,
+      projectRoot
+    ) : target === "copilot" ? classifyCopilotFiles(config, sourceRoot, configDir) : classifyCodexFiles(config, sourceRoot, configDir);
     for (const row of rows) {
       logger.info(`${row.component}	${row.className}	${row.path}`);
       if (!row.conformant) {
@@ -27297,6 +27546,64 @@ function classifyDirectArtifact(artifact, config, sourceRoot) {
     conformant: artifactClass === "managed-symlink" || artifactClass === "managed-compiled"
   };
 }
+function classifyClaudeCodeRows(sourceRoot, config, configDir, scope, projectRoot) {
+  const extraRoots = [];
+  if (scope === "global") {
+    try {
+      const scopePath = resolveScopePath(scope, projectRoot);
+      const manifest = readManifest(scopePath);
+      if (manifest && Array.isArray(manifest.claudeCodeGlobalRoots) && manifest.claudeCodeGlobalRoots.length > 1) {
+        extraRoots.push(...manifest.claudeCodeGlobalRoots.slice(1));
+      }
+    } catch {
+    }
+  }
+  const defaultArtifactRows = claudeDirectArtifacts(
+    sourceRoot,
+    config,
+    configDir,
+    scope,
+    projectRoot
+  ).map((artifact) => classifyDirectArtifact(artifact, config, sourceRoot));
+  const extraRootRows = [];
+  if (extraRoots.length > 0) {
+    try {
+      const mappings = loadMappings(sourceRoot, config, configDir);
+      for (const root of extraRoots) {
+        const profile = resolveClaudeCodeProfileForRoot(
+          root,
+          mappings.platformPaths
+        );
+        for (const [component, targetPath] of Object.entries(profile)) {
+          if (component.endsWith("_shared_file") || component === "hooks") {
+            continue;
+          }
+          const sourceKey = claudeDirectComponentSourceKeys[component];
+          if (!sourceKey || !targetPath) {
+            continue;
+          }
+          extraRootRows.push(
+            classifyDirectArtifact(
+              {
+                component: `${component.replace(/_/gu, "-")} [${root}]`,
+                path: targetPath,
+                sourceKey
+              },
+              config,
+              sourceRoot
+            )
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  return [
+    ...defaultArtifactRows,
+    ...extraRootRows,
+    ...classifyClaudeSharedFiles(config, sourceRoot)
+  ];
+}
 function classifyClaudeSharedFiles(config, sourceRoot) {
   const settingsPath = resolveTargetPath("~/.claude/settings.json");
   const claudeJsonPath = resolveTargetPath("~/.claude.json");
@@ -28137,7 +28444,9 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
   const scope = options.scope ?? "global";
   const projectRoot = options.projectRoot;
   let profile;
-  if (mappings) {
+  if (options.claudeRoot && mappings) {
+    profile = resolveClaudeCodeProfileForRoot(options.claudeRoot, mappings);
+  } else if (mappings) {
     profile = resolveTargetPaths({
       scope,
       projectRoot,
@@ -28560,19 +28869,42 @@ function runSyncCommand(options, logger) {
   const allMappings = mappings ?? (targets.includes("claude-code") ? loadMappings(sourceRoot, config, configDir) : void 0);
   for (const target of targets) {
     if (target === "claude-code") {
-      results.push(
-        syncClaudeCode(
-          config,
-          sourceRoot,
-          syncOptions,
-          logger,
-          allMappings?.platformPaths,
-          void 0,
-          void 0,
-          allMappings,
-          lossReport
-        )
-      );
+      const claudeRoots = syncOptions.scope === "global" && allMappings ? resolveClaudeGlobalRoots({
+        flag: options.claudeConfigDir,
+        config: config.claudeCodeGlobalPaths
+      }) : void 0;
+      if (claudeRoots && claudeRoots.length > 1) {
+        for (const claudeRoot of claudeRoots) {
+          logger.info(`  claude-code: syncing root ${claudeRoot}`);
+          results.push(
+            syncClaudeCode(
+              config,
+              sourceRoot,
+              { ...syncOptions, claudeRoot },
+              logger,
+              allMappings?.platformPaths,
+              void 0,
+              void 0,
+              allMappings,
+              lossReport
+            )
+          );
+        }
+      } else {
+        results.push(
+          syncClaudeCode(
+            config,
+            sourceRoot,
+            syncOptions,
+            logger,
+            allMappings?.platformPaths,
+            void 0,
+            void 0,
+            allMappings,
+            lossReport
+          )
+        );
+      }
     } else if (target === "copilot") {
       if (!mappings) {
         throw new Error("Copilot mappings were not loaded");
@@ -29444,8 +29776,13 @@ function checkHumanOnlyCommandInvocation(kit) {
 }
 
 // src/commands/verify.ts
+import fs37 from "fs";
+import path39 from "path";
 function runVerifyCommand(options, logger) {
-  const { config, kitInfo } = resolveRuntime(options, import.meta.url);
+  const { config, configDir, sourceRoot, kitInfo } = resolveRuntime(
+    options,
+    import.meta.url
+  );
   const { scope, projectRoot } = resolveScopeContext(
     options.scope,
     config.scope,
@@ -29476,6 +29813,27 @@ function runVerifyCommand(options, logger) {
       );
       inconsistent = true;
     }
+    if (scope === "global" && Array.isArray(manifest.claudeCodeGlobalRoots) && manifest.claudeCodeGlobalRoots.length > 1) {
+      try {
+        const mappings = loadMappings(sourceRoot, config, configDir);
+        const manifestKeys = manifest.artifacts.map((a) => a.relativePath);
+        const rootFailures = verifyClaudeCodeGlobalRoots(
+          manifest.claudeCodeGlobalRoots,
+          manifestKeys,
+          mappings.platformPaths
+        );
+        if (rootFailures.length > 0) {
+          for (const failure of rootFailures) {
+            logger.warn(failure);
+          }
+          inconsistent = true;
+        }
+      } catch (err) {
+        logger.warn(
+          `Multi-root verify skipped (mappings unavailable): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
     if (inconsistent) {
       logger.error("Verification FAILED. Run 'tangyr sync' to update.");
       process.exit(1);
@@ -29487,6 +29845,39 @@ function runVerifyCommand(options, logger) {
   }
   runStatusCommand(options, logger);
 }
+function verifyClaudeCodeGlobalRoots(roots, manifestKeys, mappings) {
+  const failures = [];
+  const perRootSlots = [];
+  for (const key of manifestKeys) {
+    if (!key.startsWith("claude-code/")) {
+      continue;
+    }
+    const afterPrefix = key.slice("claude-code/".length);
+    const slotName = afterPrefix.split("/")[0];
+    const subPath = afterPrefix.slice(slotName.length + 1) || void 0;
+    if (SHARED_CLAUDE_SLOTS.has(slotName)) {
+      continue;
+    }
+    const effectiveSlot = slotName === "CLAUDE.md" ? "instructions" : slotName;
+    perRootSlots.push({ slot: effectiveSlot, subPath });
+  }
+  for (const root of roots) {
+    const profile = resolveClaudeCodeProfileForRoot(root, mappings);
+    for (const { slot, subPath } of perRootSlots) {
+      const slotPath = profile[slot] ?? null;
+      if (!slotPath) {
+        continue;
+      }
+      const fullPath = subPath ? path39.join(slotPath, subPath) : slotPath;
+      if (!fs37.existsSync(fullPath)) {
+        failures.push(
+          `claude-code/${slot}${subPath ? `/${subPath}` : ""} missing in root ${root}: ${fullPath}`
+        );
+      }
+    }
+  }
+  return failures;
+}
 
 // src/utils/logger.ts
 var Logger = class {
@@ -29576,7 +29967,12 @@ function buildProgram() {
   ).option(
     "-y, --yes",
     "Skip interactive confirmation and apply non-interactive conflict handling"
-  ).option("-v, --verbose", "Emit detailed output").option("-q, --quiet", "Emit errors only").option("--no-color", "Disable colorized output");
+  ).option("-v, --verbose", "Emit detailed output").option("-q, --quiet", "Emit errors only").option("--no-color", "Disable colorized output").option(
+    "--claude-config-dir <path>",
+    "Claude Code global root directory (repeatable; overrides claudeCodeGlobalPaths in config)",
+    (value, previous) => [...previous, value],
+    []
+  );
   program2.command("assess").description("Pre-installation conflict analysis").option("--tools <list>", "Comma-separated list of target tools to assess").option("--scope <scope>", "Installation scope: global or project").option("--json", "Emit JSON output").action((options) => {
     const context = commandContext(program2);
     const scope = options.scope === "global" || options.scope === "project" ? options.scope : void 0;
@@ -29585,7 +29981,10 @@ function buildProgram() {
       context.logger
     );
   });
-  program2.command("install").description("Install the Tangyr operating kit into the target scope").option("--kit <name>", "Name of the operating kit to install").option("--tools <list>", "Comma-separated list of target tools").option("--scope <scope>", "Installation scope: global or project").option("--ignore-errors", "Suppress exit code 3 when error-severity loss entries are present").action(
+  program2.command("install").description("Install the Tangyr operating kit into the target scope").option("--kit <name>", "Name of the operating kit to install").option("--tools <list>", "Comma-separated list of target tools").option("--scope <scope>", "Installation scope: global or project").option(
+    "--ignore-errors",
+    "Suppress exit code 3 when error-severity loss entries are present"
+  ).action(
     async (options) => {
       const context = commandContext(program2);
       await runInstallCommand(
@@ -29622,7 +30021,10 @@ function buildProgram() {
       context.logger
     );
   });
-  program2.command("sync").description("Synchronize configured targets with the operating kit").option("--target <tool>", "Limit sync to a single target").option("--component <name>", "Limit sync to a single component type").option("--force", "Rewrite managed artifacts even when provenance matches").option("--loss-report <path>", "Write semantic loss report JSON to a file").option("--scope <scope>", "Installation scope: global or project").option("--ignore-errors", "Suppress exit code 3 when error-severity loss entries are present").action(
+  program2.command("sync").description("Synchronize configured targets with the operating kit").option("--target <tool>", "Limit sync to a single target").option("--component <name>", "Limit sync to a single component type").option("--force", "Rewrite managed artifacts even when provenance matches").option("--loss-report <path>", "Write semantic loss report JSON to a file").option("--scope <scope>", "Installation scope: global or project").option(
+    "--ignore-errors",
+    "Suppress exit code 3 when error-severity loss entries are present"
+  ).action(
     (options) => {
       const context = commandContext(program2);
       const scope = options.scope === "global" || options.scope === "project" ? options.scope : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alessandroraffa/tangyr",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "CLI for the Tangyr discipline — install and manage operating kits for AI coding tools",
   "license": "MIT",
   "type": "module",