auriga-cli 1.19.1 → 1.20.1

package/README.md

@@ -11,10 +11,10 @@ This repo itself is a fully configured harness project. You can clone it to see
 | Module | Description |
 |---|---|
 | **Workflow** | `CLAUDE.md` auriga workflow: requirement clarification -> TDD -> Review, Harness principles, Subagent usage guide |
-| **Skills** | Development process + orchestration skills — brainstorming, systematic-debugging, TDD, verification, planning, playwright, test-designer, incremental-impl |
+| **Skills** | External development process skills — brainstorming, systematic-debugging, TDD, verification, planning, playwright |
 | **Recommended Skills** | Optional utility skills (e.g. `codex-agent`, `claude-code-agent`) you can add on top of the workflow skills |
-| **Plugins** | Recommended Claude Code and Codex plugins — skill-creator, claude-md-management, codex, auriga-go, auriga-git-guards, session-instructions-loader, deep-review |
-| **Hooks** | Claude Code hooks: `notify` (macOS notification, focus-aware sound-only when terminal is frontmost — **opt-in**: not installed by `install --all`, requires `install hooks --hook notify`) |
+| **Plugins** | Recommended Claude Code and Codex plugins — skill-creator, claude-md-management, codex, auriga-go, auriga-git-guards, auriga-workflow-skills, auriga-notify, session-instructions-loader, deep-review |
+| **Hooks** | Legacy Claude Code hook installer. No repo-owned hooks are currently exposed here; `notify` ships as the `auriga-notify` plugin. |
 
 ## Quick Start
 
@@ -41,14 +41,14 @@ The leading `-y` belongs to `npx` (it auto-confirms package installation), **not
 Non-interactive install commands:
 
 ```bash
-npx -y auriga-cli install --all              # workflow + skills + plugins + hooks (atomic)
+npx -y auriga-cli install --all              # workflow + skills + default plugins (atomic)
 npx -y auriga-cli install recommended        # opt-in utility skills (not in --all)
 npx -y auriga-cli install plugins --agent codex --plugin session-instructions-loader
 npx -y auriga-cli install <type> [--flags]   # one of: workflow | skills | recommended | plugins | hooks
 npx -y auriga-cli --help                     # full catalog + flags
 ```
 
-Exit codes: `0` success, `1` fatal (precheck / parse / fetch), `2` partial success — `stderr` lists per-category `[OK]/[FAIL]` and a `Retry:` hint. After install, reload the Claude Code or Codex session so the new `CLAUDE.md` / skills / plugins / hook registrations are picked up.
+Exit codes: `0` success, `1` fatal (precheck / parse / fetch), `2` partial success — `stderr` lists per-category `[OK]/[FAIL]` and a `Retry:` hint. After install, reload the Claude Code or Codex session so the new `CLAUDE.md` / skills / plugins / hook-plugin registrations are picked up.
 
 ### Web UI (opt-in)
 
@@ -102,9 +102,6 @@ Installs selected skills via `npx skills add`, targeting both Claude Code and Co
 | verification-before-completion | [obra/superpowers](https://github.com/obra/superpowers) | Pre-completion verification — evidence before assertions |
 | planning-with-files | [OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files) | File-based task planning and progress tracking |
 | playwright-cli | [microsoft/playwright-cli](https://github.com/microsoft/playwright-cli) | Browser automation and testing |
-| test-designer | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Independent-Evaluation test designer for TDD red phase |
-| incremental-impl | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Decides how to implement a non-trivial change: size, slicing strategy, optional parallel dispatch, per-slice execution discipline |
-| session-compound | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | Post-merge session compounder — distills the session into an interactive HTML report (timeline + token / cache / tool health + playground for skill installs / AGENTS.md edits / new-skill gaps) |
 
 **Recommended Skills (opt-in, not installed by `--all`):**
 
@@ -129,6 +126,8 @@ Examples:
 
 ```bash
 npx -y auriga-cli install plugins --plugin auriga-go
+npx -y auriga-cli install plugins --agent both --plugin auriga-workflow-skills
+npx -y auriga-cli install plugins --plugin auriga-notify
 npx -y auriga-cli install plugins --agent codex --plugin session-instructions-loader
 npx -y auriga-cli install plugins --agent both --plugin auriga-git-guards
 ```
@@ -140,31 +139,24 @@ npx -y auriga-cli install plugins --agent both --plugin auriga-git-guards
 | codex | Claude Code | Codex cross-model collaboration |
 | auriga-go | Claude Code / Codex | Workflow autopilot for the auriga workflow. Reminder-based navigation across the `CLAUDE.md` phases. Bundles two skills: `auriga-go` (description-based NL trigger + `/auriga-go`) and `/goalify` (plans an autonomous goal from a spec or work-in-progress and dispatches it via Claude Code's built-in `/goal` command). |
 | auriga-git-guards | Claude Code / Codex | Three git-lifecycle guardrails plus the bundled `git-workflow` skill. Hooks: `commit-reminder` (PostToolUse on `Edit` / `Write` / `MultiEdit` in Claude Code and on `apply_patch` — Codex's canonical file-edit `tool_name` — so it fires in both runtimes → when uncommitted diff vs `HEAD` exceeds 200 lines or 8 files and the last reminder was ≥ 60 s ago, inject a nudge to commit at the next semantic boundary), `pr-create-guard` (PostToolUse on `gh pr create` → fetch the new PR's body via `gh pr view` and inject headings + TODO counts as `additionalContext` so the Agent can self-verify the five-element PR description: scope / acceptance criteria / design decisions / risks / remaining TODOs), and `pr-ready-guard` (PreToolUse on `gh pr ready` → block on stray planning docs at `findings.md` / `progress.md` / `task_plan.md` / `docs/superpowers/specs/*.md`, unfinalized active specs in `docs/specs/*.md`, or unpushed commits; otherwise inject the body snapshot). The two PostToolUse hooks reach full Claude Code / Codex parity; Codex currently fails open on `pr-ready-guard`'s PreToolUse `additionalContext` informational path (block path identical). |
+| auriga-workflow-skills | Claude Code / Codex | Bundles the auriga-owned workflow execution skills: `incremental-impl`, `test-designer`, and `session-compound`. Installed by default through the plugin path instead of `install skills`. |
+| auriga-notify *(opt-in)* | Claude Code | macOS native notification plugin for Claude Code `Notification` events. Focus-aware sound-only mode, click-to-activate, per-project notification grouping, and migrated `config.json` / `icon.png` support. Not installed by `install --all`; install explicitly with `install plugins --plugin auriga-notify`. |
 | session-instructions-loader | Codex | Codex-only SessionStart plugin that injects ancestor `AGENTS.md` files plus repo-configured extra instruction files. |
 | deep-review | Claude Code / Codex | Multi-dimensional PR review orchestrator — dispatches parallel reviewers (spec-conformance, correctness, test-quality, docs-sync, plus conditional robustness/UX/performance/structure/code-quality/skill-plugin-quality) and synthesizes findings into an actionable punch list. Bundles a companion `reviewer-creator` skill for scaffolding project-level custom reviewers under `docs/rules/review/`. Drives the formal-review phase in `CLAUDE.md`. |
 
 ### Hooks
 
-Installs Claude Code hooks into a chosen scope. Each hook is self-contained under `.claude/hooks/<name>/` and can be customized without editing code.
-
-| Hook | Description |
-|---|---|
-| notify *(opt-in)* | Native macOS notification when Claude needs your attention. Shows the brand mark in the small app-icon position; click brings the originating terminal back to focus. **Focus-aware**: when the launching terminal is already frontmost, drops the banner and plays the sound only (toggle via `soundOnlyWhenFocused` in `config.json`). **Per-project group ID**: new notifications cleanly replace older ones in Notification Center, no process accumulation, no cross-project interference. Auto-installs `alerter` via Homebrew (`vjeantet/tap/alerter`). Customize sound and icon by editing `.claude/hooks/notify/config.json` and `.claude/hooks/notify/icon.png`. macOS-only at runtime; silent no-op on other platforms. |
-
-Scope choices:
-
-- **Project local** (recommended for cross-platform teams): files under `./.claude/hooks/`, registered in `./.claude/settings.local.json` — per-developer, not committed.
-- **Project**: same files, registered in `./.claude/settings.json` — shared with the team via git.
-- **User**: files under `~/.claude/hooks/`, registered in `~/.claude/settings.json` — global across all your projects.
-
-Re-running the installer preserves your customized `config.json` and `icon.png`, overwrites the runtime, and never produces duplicate hook entries (idempotent merge by sentinel marker).
+The traditional hook installer remains for compatibility, but this repo no
+longer exposes a repo-owned hook through `install hooks`. New repo-owned hooks
+should be shipped inside plugins. The former `notify` hook is now the
+`auriga-notify` plugin.
 
 ## Requirements
 
 - Node.js >= 18
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (required for Claude Code Plugins and Hooks modules)
 - Codex CLI (required only for `install plugins --agent codex|both`)
-- [Homebrew](https://brew.sh) (recommended for the `notify` hook to install `alerter`)
+- [Homebrew](https://brew.sh) (recommended for the `auriga-notify` plugin to use `alerter`)
 
 ## Development
 

package/README.zh-CN.md

@@ -11,10 +11,10 @@
 | 模块 | 说明 |
 |---|---|
 | **Workflow** | `CLAUDE.md` 里的 auriga 工作流：需求澄清 → TDD → Review，Harness 原则，Subagent 使用指南 |
-| **Skills** | 开发流程 + 编排类 skills —— brainstorming、systematic-debugging、TDD、verification、planning、playwright、test-designer、incremental-impl |
+| **Skills** | 外部开发流程 skills —— brainstorming、systematic-debugging、TDD、verification、planning、playwright |
 | **Recommended Skills** | 可选的工具类 skills（如 `codex-agent`、`claude-code-agent`），在 workflow skills 之外按需追加 |
-| **Plugins** | 推荐的 Claude Code 和 Codex 插件 —— skill-creator、claude-md-management、codex、auriga-go、auriga-git-guards、session-instructions-loader、deep-review |
-| **Hooks** | Claude Code hooks：`notify`（macOS 通知，终端在焦点时仅放声不弹横幅 —— **opt-in**：`install --all` 不装，需要 `install hooks --hook notify`） |
+| **Plugins** | 推荐的 Claude Code 和 Codex 插件 —— skill-creator、claude-md-management、codex、auriga-go、auriga-git-guards、auriga-workflow-skills、auriga-notify、session-instructions-loader、deep-review |
+| **Hooks** | 传统 Claude Code hook 安装器。目前没有仓库自维护 hook 暴露在这里；`notify` 已迁移为 `auriga-notify` 插件。 |
 
 ## 快速开始
 
@@ -41,7 +41,7 @@ npx -y auriga-cli guide
 非交互安装命令：
 
 ```bash
-npx -y auriga-cli install --all              # workflow + skills + plugins + hooks（原子）
+npx -y auriga-cli install --all              # workflow + skills + 默认 plugins（原子）
 npx -y auriga-cli install recommended        # 可选工具 skills（不在 --all 内）
 npx -y auriga-cli install plugins --agent codex --plugin session-instructions-loader
 npx -y auriga-cli install <type> [--flags]   # 单类：workflow | skills | recommended | plugins | hooks
@@ -102,9 +102,6 @@ npx auriga-cli
 | verification-before-completion | [obra/superpowers](https://github.com/obra/superpowers) | 完成前验证，用证据说话 |
 | planning-with-files | [OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files) | 文件化任务计划与进度跟踪 |
 | playwright-cli | [microsoft/playwright-cli](https://github.com/microsoft/playwright-cli) | 浏览器自动化与测试 |
-| test-designer | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | TDD 红灯阶段的 Independent Evaluation 测试设计器 |
-| incremental-impl | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | 决定如何实现非平凡改动：估算大小、选择切片策略、按需并行派遣、执行片间纪律 |
-| session-compound | [Ben2pc/auriga-cli](https://github.com/Ben2pc/auriga-cli) | PR 合并后的会话复利 skill — 将本次会话沉淀为交互式 HTML 报告（时间线 + token / cache / 工具健康度 + playground：skill 安装 / AGENTS.md 修改 / 新建 skill 缺口） |
 
 **Recommended Skills（可选，不在 `--all` 内）：**
 
@@ -129,6 +126,8 @@ npx auriga-cli
 
 ```bash
 npx -y auriga-cli install plugins --plugin auriga-go
+npx -y auriga-cli install plugins --agent both --plugin auriga-workflow-skills
+npx -y auriga-cli install plugins --plugin auriga-notify
 npx -y auriga-cli install plugins --agent codex --plugin session-instructions-loader
 npx -y auriga-cli install plugins --agent both --plugin auriga-git-guards
 ```
@@ -140,31 +139,23 @@ npx -y auriga-cli install plugins --agent both --plugin auriga-git-guards
 | codex | Claude Code | Codex 跨模型协作 |
 | auriga-go | Claude Code / Codex | auriga 工作流的自动驾驶：按 `CLAUDE.md` 的 phase 做 reminder-based 导航。内置两个 skill：`auriga-go`（按 description 的自然语言触发 + `/auriga-go` slash command）和 `/goalify`（根据 spec 或当前进展 plan 出 goal，并通过 Claude Code 内置的 `/goal` 命令分发执行）。 |
 | auriga-git-guards | Claude Code / Codex | 三个 git-lifecycle guardrail + 内置 `git-workflow` skill。Hooks：`commit-reminder`（Claude Code 下 PostToolUse 匹配 `Edit` / `Write` / `MultiEdit`，Codex 下匹配 `apply_patch`（Codex 文件编辑 canonical `tool_name`），两个 runtime 都触发 —— 未提交 diff 对比 `HEAD` 超过 200 行或 8 个文件，且距上次提醒 ≥ 60 s 时，注入提醒让 Agent 在下一个语义边界 commit）、`pr-create-guard`（`gh pr create` 的 PostToolUse —— 通过 `gh pr view` 拉真实 PR body，扫 `^##` / `^###` headings 并统计 `- [ ]` / `- [x]` 注入 `additionalContext`，让 Agent 对照五要素：scope / acceptance criteria / design decisions / risks / remaining TODOs）、`pr-ready-guard`（`gh pr ready` 的 PreToolUse —— 仅按结构信号拦截：游离 `findings.md` / `progress.md` / `task_plan.md` / `docs/superpowers/specs/*.md`、`docs/specs/*.md` 内未结案的活跃 spec、未 push commits；放行时注入 body 快照）。两个 PostToolUse hook 在 Claude Code / Codex 上完全对齐；Codex 仅对 `pr-ready-guard` 的 PreToolUse `additionalContext` 信息路径 fail-open（block 路径两边一致）。 |
+| auriga-workflow-skills | Claude Code / Codex | 打包 auriga 自维护的工作流执行 skills：`incremental-impl`、`test-designer`、`session-compound`。默认通过插件路径安装，不再通过 `install skills` 作为独立条目安装。 |
+| auriga-notify *(opt-in)* | Claude Code | Claude Code `Notification` 事件的 macOS 原生通知插件。支持焦点感知仅提示音、点击唤起终端、按项目分组通知，并迁移旧 `config.json` / `icon.png`。不随 `install --all` 默认安装，需要显式执行 `install plugins --plugin auriga-notify`。 |
 | session-instructions-loader | Codex | Codex-only SessionStart 插件，注入上层目录的 `AGENTS.md` 和仓库配置的额外 instruction 文件。 |
 | deep-review | Claude Code / Codex | 多维度 PR review 编排器 —— 并行派发各维度 reviewer（spec-conformance、correctness、test-quality、docs-sync，以及条件触发的 robustness/UX/performance/structure/code-quality/skill-plugin-quality），汇总成 punch list。同包内打包了 `reviewer-creator` skill，用于在 `docs/rules/review/` 下生成项目级自定义 reviewer。承担 `CLAUDE.md` 中的正式评审职责。 |
 
 ### Hooks
 
-把 Claude Code hooks 安装到选定的作用域。每个 hook 都是 `.claude/hooks/<name>/` 下一个自包含目录，可以**不改代码**自定义。
-
-| Hook | 说明 |
-|---|---|
-| notify *(opt-in)* | 当 Claude 需要你关注时弹一条原生 macOS 通知。在通知小图标位显示品牌图，点击通知可把发起 Claude 的终端拉回前台。**焦点感知**：发起 Claude 的终端正处于前台时，仅放提示音不弹横幅（通过 `config.json` 的 `soundOnlyWhenFocused` 切换）。**按项目分组**：新通知会干净地替换通知中心里的旧条目，不会进程堆积，也不会跨项目互相覆盖。会自动通过 Homebrew 安装 `alerter`（`vjeantet/tap/alerter`）。改 `.claude/hooks/notify/config.json` 即可换提示音、替换 `.claude/hooks/notify/icon.png` 即可换图标。仅 macOS 运行时生效，其它平台静默 no-op。 |
-
-作用域选择：
-
-- **Project local**（推荐给跨平台团队）：文件落在 `./.claude/hooks/`，注册到 `./.claude/settings.local.json` —— 每个开发者各自安装，不进 git。
-- **Project**：同样的文件，注册到 `./.claude/settings.json` —— 整个团队共享。
-- **User**：文件落在 `~/.claude/hooks/`，注册到 `~/.claude/settings.json` —— 全局生效。
-
-重新跑安装器时会保留你修改过的 `config.json` 和 `icon.png`，覆盖运行时本身，并通过 marker 字段幂等去重，绝不会产生重复的 hook 条目。
+传统 hook 安装器仍保留作兼容入口，但本仓库当前不再通过
+`install hooks` 暴露自维护 hook。新的自维护 hook 应随插件分发。原来的
+`notify` hook 已迁移为 `auriga-notify` 插件。
 
 ## 环境要求
 
 - Node.js >= 18
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code)（Claude Code Plugins 和 Hooks 模块需要）
 - Codex CLI（仅 `install plugins --agent codex|both` 需要）
-- [Homebrew](https://brew.sh)（`notify` hook 用来安装 `alerter`，可选）
+- [Homebrew](https://brew.sh)（`auriga-notify` 插件使用 `alerter` 时推荐安装）
 
 ## 开发
 

package/dist/catalog.json

@@ -1,14 +1,10 @@
 {
-  "generatedAt": "2026-05-13T02:06:00.781Z",
+  "generatedAt": "2026-05-13T12:23:25.619Z",
   "workflowSkills": [
     {
       "name": "brainstorming",
       "description": "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."
     },
-    {
-      "name": "incremental-impl",
-      "description": "Plan a non-trivial code change end-to-end — size triage (XS–XL), slicing strategy, optional parallel subagent dispatch, per-slice Implement → Test → Verify → Commit discipline. Use for any multi-file change, refactor across files, executing a planned task from any planning source, cross-cutting modification (analytics sweep / i18n / library migration), or when about to write more than ~100 lines. 也用于增量实现 / 切片落地 / 推进已规划任务 / 跨切面改动。Skip only for trivial XS edits and pure documentation / configuration changes."
-    },
     {
       "name": "planning-with-files",
       "description": "Implements Manus-style file-based planning to organize and track progress on complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when asked to plan out, break down, or organize a multi-step project, research task, or any work requiring 5+ tool calls. Supports automatic session recovery after /clear."
@@ -17,18 +13,10 @@
       "name": "playwright-cli",
       "description": "Automate browser interactions, test web pages and work with Playwright tests."
     },
-    {
-      "name": "session-compound",
-      "description": "This skill should be used when the user asks to \"复盘 / 总结 / 沉淀 / wrap up this session\", \"整理一下这次会话\", or \"extract takeaways from this session\". It compounds a single Claude Code or Codex CLI session into a self-contained interactive HTML report (narrative timeline + token / cache / tool health + a playground panel with checkable candidate items for ecosystem-skill installs / AGENTS.md edits / new-skill gaps) so the user can review, tick, and copy back a prompt that lands each item in the right place."
-    },
     {
       "name": "systematic-debugging",
       "description": "Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes"
     },
-    {
-      "name": "test-designer",
-      "description": "Design failing tests for complex features using Independent Evaluation — dispatches a context-free agent that sees only the requirement spec and code paths (not the implementation approach), then returns executable failing tests. Use when starting TDD for a non-trivial feature, when the requirement is ambiguous enough that biased tests are a risk, or when the user asks for independent test design."
-    },
     {
       "name": "test-driven-development",
       "description": "Use when implementing any feature or bugfix, before writing implementation code"
@@ -113,6 +101,21 @@
         "codex"
       ]
     },
+    {
+      "name": "auriga-workflow-skills",
+      "description": "(Claude/Codex) Bundles the auriga-owned workflow execution skills: incremental-impl, test-designer, and session-compound.",
+      "agents": [
+        "claude",
+        "codex"
+      ]
+    },
+    {
+      "name": "auriga-notify",
+      "description": "(opt-in) Opt-in macOS native notification hook for Claude Code Notification events; migrates legacy notify config and icon on install.",
+      "agents": [
+        "claude"
+      ]
+    },
     {
       "name": "deep-review",
       "description": "(Claude/Codex) Multi-dimensional PR review orchestrator. Dispatches parallel reviewers (spec-conformance, correctness, test-quality, docs-sync, robustness, security, ux, performance, structure, code-quality, skill-plugin-quality) and synthesizes findings into an actionable punch list. Supports project-level custom reviewers via docs/rules/review/ and ships a reviewer-creator skill for scaffolding them.",
@@ -129,10 +132,5 @@
       ]
     }
   ],
-  "hooks": [
-    {
-      "name": "notify",
-      "description": "(opt-in) Native macOS notification when Claude needs your attention (auto-installs alerter via Homebrew)"
-    }
-  ]
+  "hooks": []
 }

package/dist/cli.js

@@ -316,10 +316,22 @@ function validateFilterAgainstCatalog(type, filter) {
     const singular = categorySingular(type);
     for (const name of filter) {
         if (!available.includes(name)) {
-            parseErr(`unknown ${singular} '${name}'; available: ${available.join(", ")}`);
+            const hint = migratedPluginHint(type, name);
+            const hintText = hint ? ` ${hint}` : "";
+            parseErr(`unknown ${singular} '${name}';${hintText} available: ${available.join(", ")}`);
         }
     }
 }
+function migratedPluginHint(type, name) {
+    if (type === "skills" &&
+        ["incremental-impl", "test-designer", "session-compound"].includes(name)) {
+        return "This skill moved to the auriga-workflow-skills plugin; install it with `install plugins --plugin auriga-workflow-skills`.";
+    }
+    if (type === "hooks" && name === "notify") {
+        return "The notify hook moved to the auriga-notify plugin; install it with `install plugins --plugin auriga-notify`.";
+    }
+    return undefined;
+}
 function categorySingular(type) {
     return type === "recommended" ? "recommended skill"
         : type === "skills" ? "skill"

package/dist/guide.js

@@ -20,7 +20,7 @@ export function renderGuide(opts) {
     return `${h(`# auriga-cli bootstrap SOP (v${opts.version})`)}
 
 This guide walks an Agent through installing the auriga harness
-(CLAUDE.md + skills + plugins + hooks) into the current repository.
+(CLAUDE.md + skills + plugins, plus any legacy hooks) into the current repository.
 
 Run each step in order. If any step fails with exit 1, stop and report.
 If exit 2, see stderr for per-category status and follow the "Retry"
@@ -62,8 +62,8 @@ Per-type detail (flags + only that category's catalog slice):
 
 ${h("## Step 3 — Install")}
 
-Preset — the full default-on set (workflow + skills + plugins + hooks;
-recommended skills are NOT included):
+Preset — the full default-on set (workflow + skills + default plugins;
+the legacy hooks category is currently empty; recommended skills are NOT included):
   ${cmd("npx -y auriga-cli install --all")}
 
 Targeted — single category, picking from the catalog surfaced in Step 2:
@@ -72,10 +72,10 @@ Targeted — single category, picking from the catalog surfaced in Step 2:
   ${cmd("npx -y auriga-cli install plugins --plugin skill-creator codex --scope user")}
   ${cmd("npx -y auriga-cli install plugins --agent codex --plugin session-instructions-loader")}
 
-Opt-in hooks (\`defaultOn: false\`) are NOT in the default \`install --all\`
-set because they have side effects (OS notifications, platform-gated
-deps). Inspect \`install hooks --help\` for the catalog and install by name:
-  ${cmd("npx -y auriga-cli install hooks --hook notify")}
+Opt-in plugins (\`defaultOn: false\`) are NOT in the default \`install --all\`
+set because they have side effects or platform-specific behavior. For example,
+the macOS notification plugin is explicit opt-in:
+  ${cmd("npx -y auriga-cli install plugins --plugin auriga-notify")}
 
 Opt-in recommended skills (cross-model delegation helpers —
 claude-code-agent, codex-agent):
@@ -94,7 +94,7 @@ Exit codes:
 ${h("## Step 4 — Reload session (REQUIRED when installed non-interactively)")}
 
 ${warn("⚠")} CLAUDE.md, .agents/skills/, .claude/plugins.json, Codex plugin
-config, and hook registrations are loaded at session startup. If you ran
+config, and hook/plugin registrations are loaded at session startup. If you ran
 \`npx -y auriga-cli install\` inside an existing Claude Code or Codex session
 (e.g., \`claude -p\` / \`claude -p --worktree\` / \`codex exec\`), the current session
 will NOT see the new harness.
@@ -112,7 +112,8 @@ Expected artifacts:
   - .agents/skills/<name>/    (one per installed skill)
   - .claude/plugins.json
   - ~/.codex/config.toml      (Codex plugin enablement, if Codex plugins selected)
-  - .claude/settings.json     (updated hook registrations, if hooks selected)
+  - .claude/settings.json     (updated hook/plugin registrations, if selected)
+  - .claude/auriga-notify/    (project notify config, if auriga-notify selected)
 
 ${h("## Troubleshooting")}
 

package/dist/help.js

@@ -125,7 +125,7 @@ USAGE
 
 FLAGS
   --plugin <names...>      space-separated; '*' = all
-                           omit → install every plugin available for the selected agent
+                           omit → install every plugin with defaultOn != false
   --agent <...>            target runtime: claude, codex, or both
                            default claude; codex enablement is user-level
   --scope <project|user>   default project

package/dist/hooks.js

@@ -687,7 +687,12 @@ export async function installHooks(packageRoot, opts) {
     const config = loadHooksConfig(packageRoot);
     const compatible = config.hooks.filter((h) => h.runtimePlatforms.includes(process.platform));
     if (compatible.length === 0) {
-        log.warn(`No hooks available for your platform (${process.platform}). Skipping.`);
+        if (config.hooks.length === 0) {
+            log.warn("No legacy hooks are defined. The notify hook moved to the opt-in auriga-notify plugin.");
+        }
+        else {
+            log.warn(`No hooks available for your platform (${process.platform}). Skipping.`);
+        }
         return;
     }
     // Non-interactive explicit `--hook <name>` has stronger intent than

package/dist/plugins.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { checkbox, select } from "@inquirer/prompts";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-import { codexManifestPath, validateCodexInstallConfig, validateCodexMarketplace, } from "./codex-plugin-config.js";
+import { codexLocalPluginPath, codexManifestPath, validateCodexInstallConfig, validateCodexMarketplace, } from "./codex-plugin-config.js";
 import { validateMarketplaceField } from "./marketplace.js";
 import { atomicWriteFile, exec, execAsync, fetchExtraContent, log, withEsc } from "./utils.js";
 // Plugin names and plugin-package names end up in `claude plugins ...`
@@ -15,6 +15,15 @@ import { atomicWriteFile, exec, execAsync, fetchExtraContent, log, withEsc } fro
 // `./marketplace.js` so Claude and Codex sides share one validator.
 const PLUGIN_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const PLUGIN_PACKAGE_RE = /^[A-Za-z0-9][A-Za-z0-9._@/-]{0,255}$/;
+const MIGRATED_WORKFLOW_SKILLS = [
+    "incremental-impl",
+    "test-designer",
+    "session-compound",
+];
+const NOTIFY_PLUGIN_NAME = "auriga-notify";
+const WORKFLOW_SKILLS_PLUGIN_NAME = "auriga-workflow-skills";
+const LEGACY_NOTIFY_MARKER = "auriga:notify";
+const CODEX_PLUGIN_VERSION_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 export function validatePluginsConfig(raw) {
     if (!raw || typeof raw !== "object") {
         throw new Error("plugins.json: root must be an object");
@@ -37,6 +46,9 @@ export function validatePluginsConfig(raw) {
         if (plugin.marketplace !== undefined) {
             validateMarketplaceField(`plugins.json: plugins[${i}]`, plugin.marketplace);
         }
+        if (plugin.defaultOn !== undefined && typeof plugin.defaultOn !== "boolean") {
+            throw new Error(`plugins.json: plugins[${i}].defaultOn must be a boolean`);
+        }
     });
 }
 function getInstalledPlugins() {
@@ -60,12 +72,14 @@ function getInstalledPlugins() {
     }
 }
 /**
- * Non-interactive selection resolver for plugins. Mirrors the skills
- * resolveSelected: `undefined` / `["*"]` = full set; explicit names =
- * filter. CLI parser validates names up-front.
+ * Non-interactive selection resolver for plugins.
+ * `undefined` = default-on set; `["*"]` = full set; explicit names =
+ * exact filter. CLI parser validates names up-front.
  */
 function resolvePluginSelection(all, selected) {
-    if (!selected || (selected.length === 1 && selected[0] === "*"))
+    if (!selected)
+        return all.filter((p) => p.defaultOn !== false);
+    if (selected.length === 1 && selected[0] === "*")
         return all;
     const byName = new Map(all.map((p) => [p.name, p]));
     const missing = selected.filter((name) => !byName.has(name));
@@ -121,6 +135,162 @@ function codexHome() {
 function shellQuote(value) {
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
+function installTargetCwd(opts) {
+    return path.resolve(opts.cwd ?? process.cwd());
+}
+function emitMigrationLog(opts, line) {
+    opts.onLog?.(line, "stdout");
+}
+function runtimeSkillRoot(runtime) {
+    return runtime === "claude" ? ".claude" : ".agents";
+}
+function legacySkillDir(opts, runtime, name) {
+    const cwd = installTargetCwd(opts);
+    const scope = opts.scope ?? "project";
+    const baseDir = scope === "user" ? os.homedir() : cwd;
+    return path.join(baseDir, runtimeSkillRoot(runtime), "skills", name);
+}
+function isWorkflowPluginDevSymlink(skillPath, cwd, name) {
+    const stat = fs.lstatSync(skillPath, { throwIfNoEntry: false });
+    if (!stat?.isSymbolicLink())
+        return false;
+    const target = fs.readlinkSync(skillPath);
+    const resolved = path.resolve(path.dirname(skillPath), target);
+    const expected = path.resolve(cwd, "plugins", "auriga-workflow-skills", "skills", name);
+    return resolved === expected;
+}
+function removeMigratedSkillFromLock(cwd, name, opts) {
+    const lockPath = path.join(cwd, "skills-lock.json");
+    if (!fs.existsSync(lockPath))
+        return;
+    const raw = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+    if (!raw.skills || typeof raw.skills !== "object" || !(name in raw.skills))
+        return;
+    const nextSkills = { ...raw.skills };
+    delete nextSkills[name];
+    atomicWriteFile(lockPath, JSON.stringify({ ...raw, skills: nextSkills }, null, 2) + "\n");
+    emitMigrationLog(opts, `removed ${name} from skills-lock.json`);
+}
+function cleanupMigratedWorkflowSkillInstalls(opts, runtimes) {
+    const cwd = installTargetCwd(opts);
+    const scope = opts.scope ?? "project";
+    for (const name of MIGRATED_WORKFLOW_SKILLS) {
+        for (const runtime of runtimes) {
+            const dir = legacySkillDir(opts, runtime, name);
+            const stat = fs.lstatSync(dir, { throwIfNoEntry: false });
+            if (!stat)
+                continue;
+            if (scope === "project" && isWorkflowPluginDevSymlink(dir, cwd, name)) {
+                emitMigrationLog(opts, `preserved ${runtimeSkillRoot(runtime)}/skills/${name} development symlink`);
+                continue;
+            }
+            fs.rmSync(dir, { recursive: true, force: true });
+            emitMigrationLog(opts, `removed ${runtimeSkillRoot(runtime)}/skills/${name}`);
+        }
+        if (scope === "project")
+            removeMigratedSkillFromLock(cwd, name, opts);
+    }
+}
+function copyIfPresentWithoutOverwrite(src, dest) {
+    if (!fs.existsSync(src) || fs.existsSync(dest))
+        return false;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    return true;
+}
+function removeMarkerFromSettings(settings, marker) {
+    const next = JSON.parse(JSON.stringify(settings ?? {}));
+    if (!next.hooks || typeof next.hooks !== "object" || Array.isArray(next.hooks)) {
+        return { settings: next, removed: 0 };
+    }
+    let removed = 0;
+    for (const event of Object.keys(next.hooks)) {
+        const groups = next.hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        const nextGroups = [];
+        for (const group of groups) {
+            if (!Array.isArray(group.hooks)) {
+                nextGroups.push(group);
+                continue;
+            }
+            const hooks = group.hooks.filter((action) => {
+                if (action?._marker === marker) {
+                    removed += 1;
+                    return false;
+                }
+                return true;
+            });
+            if (hooks.length > 0)
+                nextGroups.push({ ...group, hooks });
+        }
+        if (nextGroups.length > 0)
+            next.hooks[event] = nextGroups;
+        else
+            delete next.hooks[event];
+    }
+    return { settings: next, removed };
+}
+function cleanLegacyNotifySettings(settingsPaths, opts) {
+    let allReadable = true;
+    for (const settingsPath of settingsPaths) {
+        if (!fs.existsSync(settingsPath))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            emitMigrationLog(opts, `skipped unreadable legacy notify settings: ${settingsPath}`);
+            allReadable = false;
+            continue;
+        }
+        const result = removeMarkerFromSettings(parsed, LEGACY_NOTIFY_MARKER);
+        if (result.removed === 0)
+            continue;
+        atomicWriteFile(settingsPath, JSON.stringify(result.settings, null, 2) + "\n");
+        emitMigrationLog(opts, `removed ${result.removed} legacy notify settings entries from ${settingsPath}`);
+    }
+    return allReadable;
+}
+function migrateLegacyNotifyConfig(opts) {
+    const scope = opts.scope ?? "project";
+    const cwd = installTargetCwd(opts);
+    const home = os.homedir();
+    const legacyBase = scope === "user" ? home : cwd;
+    const legacyDir = path.join(legacyBase, ".claude", "hooks", "notify");
+    const destDir = scope === "user"
+        ? path.join(home, ".config", "auriga-cli", "notify")
+        : path.join(cwd, ".claude", "auriga-notify");
+    const copiedConfig = copyIfPresentWithoutOverwrite(path.join(legacyDir, "config.json"), path.join(destDir, "config.json"));
+    const copiedIcon = copyIfPresentWithoutOverwrite(path.join(legacyDir, "icon.png"), path.join(destDir, "icon.png"));
+    if (copiedConfig)
+        emitMigrationLog(opts, `migrated legacy notify config to ${path.join(destDir, "config.json")}`);
+    if (copiedIcon)
+        emitMigrationLog(opts, `migrated legacy notify icon to ${path.join(destDir, "icon.png")}`);
+    const settingsPaths = scope === "user"
+        ? [path.join(home, ".claude", "settings.json")]
+        : [
+            path.join(cwd, ".claude", "settings.json"),
+            path.join(cwd, ".claude", "settings.local.json"),
+        ];
+    const settingsCleaned = cleanLegacyNotifySettings(settingsPaths, opts);
+    if (settingsCleaned && fs.existsSync(legacyDir)) {
+        fs.rmSync(legacyDir, { recursive: true, force: true });
+        emitMigrationLog(opts, `removed legacy notify hook directory ${legacyDir}`);
+    }
+    else if (!settingsCleaned && fs.existsSync(legacyDir)) {
+        emitMigrationLog(opts, `kept legacy notify hook directory because settings cleanup was incomplete: ${legacyDir}`);
+    }
+}
+function runPostInstallMigration(pluginName, opts, runtimes) {
+    if (pluginName === WORKFLOW_SKILLS_PLUGIN_NAME) {
+        cleanupMigratedWorkflowSkillInstalls(opts, runtimes);
+    }
+    if (pluginName === NOTIFY_PLUGIN_NAME) {
+        migrateLegacyNotifyConfig(opts);
+    }
+}
 function codexMarketplaceAddCommand(packageRoot) {
     if (process.env.DEV === "1") {
         return `codex plugin marketplace add ${shellQuote(packageRoot)}`;
@@ -167,6 +337,16 @@ function pluginHasHooks(packageRoot, plugin) {
     const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
     return typeof manifest.hooks === "string" || Array.isArray(manifest.hooks);
 }
+function resolveSelectedCodexMarketplacePlugins(localMarketplace, localSelected) {
+    const localMpByName = new Map(localMarketplace.plugins.map((p) => [p.name, p]));
+    return localSelected.map((p) => {
+        const plugin = localMpByName.get(p.name);
+        if (!plugin) {
+            throw new Error(`Codex install.json: plugin ${p.name} is not present in marketplace.json`);
+        }
+        return plugin;
+    });
+}
 async function ensureCodexPluginManifests(packageRoot, plugins) {
     for (const plugin of plugins) {
         const manifestPath = codexManifestPath(plugin);
@@ -178,6 +358,38 @@ async function ensureCodexPluginManifests(packageRoot, plugins) {
         await fetchExtraContent(packageRoot, manifestPath);
     }
 }
+function readCodexPluginVersion(packageRoot, plugin) {
+    const manifestPath = codexManifestPath(plugin);
+    if (!manifestPath) {
+        throw new Error(`Codex marketplace.json: plugin ${plugin.name} must use a local source.path`);
+    }
+    const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, manifestPath), "utf-8"));
+    if (typeof manifest.version !== "string" || !CODEX_PLUGIN_VERSION_RE.test(manifest.version)) {
+        throw new Error(`Codex plugin ${plugin.name} manifest must include a safe string version`);
+    }
+    return manifest.version;
+}
+function materializeLocalCodexPluginCache(packageRoot, marketplaceName, plugins) {
+    const cacheRoot = path.join(codexHome(), "plugins", "cache");
+    for (const plugin of plugins) {
+        const sourcePath = codexLocalPluginPath(plugin);
+        if (!sourcePath) {
+            throw new Error(`Codex marketplace.json: plugin ${plugin.name} must use a local source.path`);
+        }
+        const version = readCodexPluginVersion(packageRoot, plugin);
+        const sourceDir = path.join(packageRoot, sourcePath);
+        const destDir = path.join(cacheRoot, marketplaceName, plugin.name, version);
+        const tmpDir = `${destDir}.tmp-${process.pid}-${Date.now()}`;
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        fs.mkdirSync(path.dirname(destDir), { recursive: true });
+        fs.cpSync(sourceDir, tmpDir, { recursive: true });
+        fs.rmSync(destDir, { recursive: true, force: true });
+        fs.renameSync(tmpDir, destDir);
+        if (!fs.existsSync(path.join(destDir, ".codex-plugin", "plugin.json"))) {
+            throw new Error(`Codex plugin ${plugin.name} cache materialization did not produce plugin.json`);
+        }
+    }
+}
 function ensureTomlBoolean(content, section, key, value) {
     const line = `${key} = ${value ? "true" : "false"}`;
     const header = `[${section}]`;
@@ -306,19 +518,10 @@ async function addCodexMarketplaceWithRetry(marketplaceName, addCommand, opts, m
 // manifest at install time. Acceptable while no external plugin ships
 // hooks; once one does, prefer fetching the manifest or adding an
 // explicit `requiresPluginHooks: true` field on the install.json entry.
-async function composeCodexPluginKeys(packageRoot, localMarketplace, localSelected, externalSelected) {
+async function composeCodexPluginKeys(packageRoot, localMarketplace, selectedMarketplacePlugins, externalSelected) {
     const pluginKeys = [];
     let needsPluginHooks = false;
     if (localMarketplace) {
-        const localMpByName = new Map(localMarketplace.plugins.map((p) => [p.name, p]));
-        const selectedMarketplacePlugins = localSelected.map((p) => {
-            const plugin = localMpByName.get(p.name);
-            if (!plugin) {
-                throw new Error(`Codex install.json: plugin ${p.name} is not present in marketplace.json`);
-            }
-            return plugin;
-        });
-        await ensureCodexPluginManifests(packageRoot, selectedMarketplacePlugins);
         for (const plugin of selectedMarketplacePlugins) {
             pluginKeys.push(`${plugin.name}@${localMarketplace.name}`);
             if (pluginHasHooks(packageRoot, plugin))
@@ -397,10 +600,18 @@ async function installCodexPlugins(packageRoot, opts) {
         await addCodexMarketplaceWithRetry(mp.name, codexExternalMarketplaceAddCommand(mp.source), opts, marketplaceExecOpts, failures);
     }
     if (failures.length === 0) {
-        const { pluginKeys, needsPluginHooks } = await composeCodexPluginKeys(packageRoot, localMarketplace, localSelected, externalSelected);
+        const selectedMarketplacePlugins = localMarketplace
+            ? resolveSelectedCodexMarketplacePlugins(localMarketplace, localSelected)
+            : [];
+        await ensureCodexPluginManifests(packageRoot, selectedMarketplacePlugins);
+        if (localMarketplace) {
+            materializeLocalCodexPluginCache(packageRoot, localMarketplace.name, selectedMarketplacePlugins);
+        }
+        const { pluginKeys, needsPluginHooks } = await composeCodexPluginKeys(packageRoot, localMarketplace, selectedMarketplacePlugins, externalSelected);
         enableCodexPluginConfig(path.join(codexHome(), "config.toml"), pluginKeys, needsPluginHooks);
         for (const plugin of [...localSelected, ...externalSelected]) {
             log.ok(`${plugin.name} enabled for Codex`);
+            runPostInstallMigration(plugin.name, opts, ["codex"]);
         }
     }
     if (failures.length > 0 && !opts.interactive) {
@@ -490,10 +701,11 @@ export async function installPlugins(packageRoot, opts) {
                     choices: config.plugins.map((p) => {
                         const scopes = installed.get(p.package);
                         const suffix = scopes ? ` (installed: ${scopes.join(", ")})` : "";
+                        const installedEverywhere = scopes?.includes("user") && scopes?.includes("project");
                         return {
                             name: `${p.name} — ${p.description}${suffix}`,
                             value: p,
-                            checked: !scopes || !(scopes.includes("user") && scopes.includes("project")),
+                            checked: p.defaultOn !== false && !installedEverywhere,
                         };
                     }),
                 }))
@@ -572,14 +784,16 @@ export async function installPlugins(packageRoot, opts) {
                 console.log(`\nInstalling ${plugin.name}...`);
                 try {
                     const cmd = `claude plugins install ${plugin.package} --scope ${scope}`;
+                    const cmdOpts = { cwd: installTargetCwd(opts) };
                     if (opts.onLog) {
                         opts.onLog(`▸ ${cmd}`, "stdout");
-                        await execAsync(cmd, { onLine: opts.onLog });
+                        await execAsync(cmd, { ...cmdOpts, onLine: opts.onLog });
                     }
                     else {
-                        exec(cmd, { inherit: true });
+                        exec(cmd, { ...cmdOpts, inherit: true });
                     }
                     log.ok(`${plugin.name} installed`);
+                    runPostInstallMigration(plugin.name, { ...opts, scope }, ["claude"]);
                 }
                 catch {
                     log.error(`Failed to install: ${plugin.name}`);

package/dist/skills.js

@@ -8,12 +8,9 @@ import { atomicWriteFile, exec, execAsync, log, withEsc } from "./utils.js";
 // installRecommendedSkills as an opt-in utility.
 export const WORKFLOW_SKILLS = [
     "brainstorming",
-    "incremental-impl",
     "planning-with-files",
     "playwright-cli",
-    "session-compound",
     "systematic-debugging",
-    "test-designer",
     "test-driven-development",
     "verification-before-completion",
 ];

package/dist/utils.d.ts

@@ -13,6 +13,7 @@ export interface PluginDef {
     package: string;
     description: string;
     marketplace?: MarketplaceRef;
+    defaultOn?: boolean;
 }
 export interface PluginsConfig {
     plugins: PluginDef[];

package/dist/utils.js

@@ -152,6 +152,49 @@ const CONTENT_FILES = [
     ".agents/plugins/marketplace.json",
     ".agents/plugins/install.json",
     ".claude/hooks/hooks.json",
+    "plugins/auriga-go/.claude-plugin/plugin.json",
+    "plugins/auriga-go/.codex-plugin/plugin.json",
+    "plugins/auriga-go/README.md",
+    "plugins/auriga-go/skills/auriga-go/SKILL.md",
+    "plugins/auriga-go/skills/goalify/SKILL.md",
+    "plugins/auriga-git-guards/.claude-plugin/plugin.json",
+    "plugins/auriga-git-guards/.codex-plugin/plugin.json",
+    "plugins/auriga-git-guards/README.md",
+    "plugins/auriga-git-guards/hooks/hooks.json",
+    "plugins/auriga-git-guards/scripts/commit-reminder.mjs",
+    "plugins/auriga-git-guards/scripts/pr-create-guard.mjs",
+    "plugins/auriga-git-guards/scripts/pr-ready-guard.mjs",
+    "plugins/auriga-git-guards/skills/git-workflow/SKILL.md",
+    "plugins/auriga-workflow-skills/.claude-plugin/plugin.json",
+    "plugins/auriga-workflow-skills/.codex-plugin/plugin.json",
+    "plugins/auriga-workflow-skills/README.md",
+    "plugins/auriga-workflow-skills/skills/incremental-impl/SKILL.md",
+    "plugins/auriga-workflow-skills/skills/session-compound/SKILL.md",
+    "plugins/auriga-workflow-skills/skills/session-compound/analyzers/claude-code.mjs",
+    "plugins/auriga-workflow-skills/skills/session-compound/analyzers/codex.mjs",
+    "plugins/auriga-workflow-skills/skills/session-compound/template.html",
+    "plugins/auriga-workflow-skills/skills/test-designer/SKILL.md",
+    "plugins/session-instructions-loader/.codex-plugin/plugin.json",
+    "plugins/session-instructions-loader/README.md",
+    "plugins/session-instructions-loader/hooks/hooks.json",
+    "plugins/session-instructions-loader/scripts/session-start.mjs",
+    "plugins/deep-review/.claude-plugin/plugin.json",
+    "plugins/deep-review/.codex-plugin/plugin.json",
+    "plugins/deep-review/README.md",
+    "plugins/deep-review/skills/deep-review/SKILL.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/code-quality.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/correctness.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/docs-sync.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/performance.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/robustness.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/security.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/skill-plugin-quality.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/spec-conformance.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/structure.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/test-quality.md",
+    "plugins/deep-review/skills/deep-review/references/reviewers/ux.md",
+    "plugins/deep-review/skills/reviewer-creator/SKILL.md",
+    "plugins/deep-review/skills/reviewer-creator/references/template.md",
 ];
 async function fetchFile(file) {
     const ref = resolveContentRef();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auriga-cli",
-  "version": "1.19.1",
+  "version": "1.20.1",
   "description": "Interactive CLI to install Claude Code harness modules (Workflow, Skills, Recommended Skills, Plugins, Hooks)",
   "license": "MIT",
   "repository": {