@event4u/agent-config 6.0.0 → 7.0.0

package/dist/agent-src/skills/react-shadcn-ui/scripts/shadcn_add.ts

@@ -0,0 +1,388 @@
+#!/usr/bin/env tsx
+// Modified from upstream (Apache-2.0, "claudekit" via
+// an external reference ui-styling sub-skill
+// @ b7e3af80f6e331f6fb456667b82b12cade7c9d35, last checked 2026-06-07).
+// License copy: src/skills/design-intelligence/LICENSE.apache-2.0.txt
+// (deployed: <skills-root>/design-intelligence/LICENSE.apache-2.0.txt).
+// Modifications: adopted into the agent-config skill tree; header added
+// per Apache-2.0 §4b; see design-intelligence/ATTRIBUTION.md.
+/**
+ * shadcn/ui Component Installer
+ *
+ * Add shadcn/ui components to project with automatic dependency handling.
+ * Wraps shadcn CLI for programmatic component installation.
+ *
+ * TypeScript twin of `src/skills/react-shadcn-ui/scripts/shadcn_add.py`
+ * (ADR-200). The CLI contract is mirrored EXACTLY — positional components,
+ * `--all`, `--overwrite`, `--dry-run`, `--list`, `--project-root`, exit codes
+ * (0 / 1), the stdout/stderr split, byte-identical messages, AND the exact
+ * `npx shadcn@latest …` command shape. No behaviour changes — latent Python
+ * quirks replicated.
+ */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+
+export class ShadcnInstaller {
+    projectRoot: string;
+    dryRun: boolean;
+    componentsJson: string;
+
+    constructor(projectRoot: string | null = null, dryRun = false) {
+        this.projectRoot = projectRoot ?? process.cwd();
+        this.dryRun = dryRun;
+        this.componentsJson = path.join(this.projectRoot, 'components.json');
+    }
+
+    /** Check if shadcn is initialized — components.json exists. */
+    checkShadcnConfig(): boolean {
+        return fs.existsSync(this.componentsJson);
+    }
+
+    /** Get list of already installed components (unsorted, mirrors .py). */
+    getInstalledComponents(): string[] {
+        if (!this.checkShadcnConfig()) {
+            return [];
+        }
+        try {
+            const config = JSON.parse(fs.readFileSync(this.componentsJson, 'utf-8')) as unknown;
+            const aliasesRaw =
+                config && typeof config === 'object' && 'aliases' in config
+                    ? (config as { aliases?: unknown }).aliases
+                    : undefined;
+            const aliases =
+                aliasesRaw && typeof aliasesRaw === 'object'
+                    ? (aliasesRaw as { components?: unknown })
+                    : {};
+            const componentsAlias =
+                typeof aliases.components === 'string' ? aliases.components : 'components';
+            const componentsDir = path.join(this.projectRoot, componentsAlias.replace('@/', ''));
+            const uiDir = path.join(componentsDir, 'ui');
+
+            if (!fs.existsSync(uiDir)) {
+                return [];
+            }
+
+            return _globTsxStems(uiDir);
+        } catch {
+            // json.JSONDecodeError | KeyError | OSError → []
+            return [];
+        }
+    }
+
+    /** Add shadcn/ui components → [success, message]. */
+    addComponents(components: string[], overwrite = false): [boolean, string] {
+        if (components.length === 0) {
+            return [false, 'No components specified'];
+        }
+
+        if (!this.checkShadcnConfig()) {
+            return [false, "shadcn not initialized. Run 'npx shadcn@latest init' first"];
+        }
+
+        // Check which components already exist
+        const installed = this.getInstalledComponents();
+        const alreadyInstalled = components.filter((c) => installed.includes(c));
+
+        if (alreadyInstalled.length > 0 && !overwrite) {
+            return [
+                false,
+                `Components already installed: ${alreadyInstalled.join(', ')}. ` +
+                    'Use --overwrite to reinstall',
+            ];
+        }
+
+        // Build command
+        const cmd = ['npx', 'shadcn@latest', 'add', ...components];
+
+        if (overwrite) {
+            cmd.push('--overwrite');
+        }
+
+        if (this.dryRun) {
+            return [true, `Would run: ${cmd.join(' ')}`];
+        }
+
+        // Execute command
+        return this._runAdd(cmd, `Successfully added components: ${components.join(', ')}`);
+    }
+
+    /** Add all available shadcn/ui components → [success, message]. */
+    addAllComponents(overwrite = false): [boolean, string] {
+        if (!this.checkShadcnConfig()) {
+            return [false, "shadcn not initialized. Run 'npx shadcn@latest init' first"];
+        }
+
+        const cmd = ['npx', 'shadcn@latest', 'add', '--all'];
+
+        if (overwrite) {
+            cmd.push('--overwrite');
+        }
+
+        if (this.dryRun) {
+            return [true, `Would run: ${cmd.join(' ')}`];
+        }
+
+        return this._runAdd(cmd, 'Successfully added all components', true);
+    }
+
+    /**
+     * Mirror the subprocess.run(..., check=True) try/except for both add paths.
+     * `failAll` toggles the "Failed to add all components" vs "Failed to add
+     * components" prefix.
+     */
+    private _runAdd(cmd: string[], successBase: string, failAll = false): [boolean, string] {
+        const result = spawnSync(cmd[0] as string, cmd.slice(1), {
+            cwd: this.projectRoot,
+            encoding: 'utf-8',
+        });
+
+        // FileNotFoundError — the executable itself is missing.
+        if (result.error && (result.error as NodeJS.ErrnoException).code === 'ENOENT') {
+            return [false, 'npx not found. Ensure Node.js is installed'];
+        }
+
+        const stdout = result.stdout ?? '';
+        const stderr = result.stderr ?? '';
+        const status = result.status;
+
+        if (status === 0) {
+            let successMsg = successBase;
+            if (stdout) {
+                successMsg += `\n\nOutput:\n${stdout}`;
+            }
+            return [true, successMsg];
+        }
+
+        // subprocess.CalledProcessError — e.stderr or e.stdout or str(e).
+        const detail = stderr || stdout || _calledProcessError(cmd, status, result.signal);
+        const prefix = failAll ? 'Failed to add all components' : 'Failed to add components';
+        return [false, `${prefix}: ${detail}`];
+    }
+
+    /** List installed components → [success, message]. */
+    listInstalled(): [boolean, string] {
+        if (!this.checkShadcnConfig()) {
+            return [false, 'shadcn not initialized'];
+        }
+
+        const installed = this.getInstalledComponents();
+
+        if (installed.length === 0) {
+            return [true, 'No components installed'];
+        }
+
+        const sorted = [...installed].sort(_pyStrCmp);
+        return [true, 'Installed components:\n' + sorted.map((c) => `  - ${c}`).join('\n')];
+    }
+}
+
+/** Mirror Python default str comparison (UTF-16 code-unit ordering matches for BMP). */
+function _pyStrCmp(a: string, b: string): number {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * Mirror `[f.stem for f in ui_dir.glob("*.tsx") if f.is_file()]`. Path.glob
+ * returns only direct children whose name ends in `.tsx`; `f.stem` drops the
+ * final `.tsx` suffix; order is the directory listing (later `sorted()` in
+ * list_installed handles display order). Symlinks to files count as files.
+ */
+function _globTsxStems(uiDir: string): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(uiDir, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    const out: string[] = [];
+    for (const e of entries) {
+        if (!e.name.endsWith('.tsx')) {
+            continue;
+        }
+        let isFile = e.isFile();
+        if (e.isSymbolicLink()) {
+            try {
+                isFile = fs.statSync(path.join(uiDir, e.name)).isFile();
+            } catch {
+                isFile = false;
+            }
+        }
+        if (isFile) {
+            out.push(e.name.slice(0, -'.tsx'.length));
+        }
+    }
+    return out;
+}
+
+/** Mirror `str(subprocess.CalledProcessError)` for the rare empty-output case. */
+function _calledProcessError(cmd: string[], status: number | null, signal: string | null): string {
+    const cmdRepr = '[' + cmd.map((c) => `'${c}'`).join(', ') + ']';
+    if (signal) {
+        return `Command ${cmdRepr} died with ${signal}.`;
+    }
+    return `Command ${cmdRepr} returned non-zero exit status ${status}.`;
+}
+
+const PROG = 'shadcn_add.py';
+
+const HELP =
+    `usage: ${PROG} [-h] [--all] [--overwrite] [--dry-run] [--list]\n` +
+    '                     [--project-root PROJECT_ROOT]\n' +
+    '                     [components ...]\n' +
+    '\n' +
+    'Add shadcn/ui components to your project\n' +
+    '\n' +
+    'positional arguments:\n' +
+    '  components            Component names to add (e.g., button, card, dialog)\n' +
+    '\n' +
+    'optional arguments:\n' +
+    '  -h, --help            show this help message and exit\n' +
+    '  --all                 Add all available components\n' +
+    '  --overwrite           Overwrite existing components\n' +
+    '  --dry-run             Show what would be done without executing\n' +
+    '  --list                List installed components\n' +
+    '  --project-root PROJECT_ROOT\n' +
+    '                        Project root directory (default: current directory)\n' +
+    '\n' +
+    'Examples:\n' +
+    '  # Add single component\n' +
+    '  python shadcn_add.py button\n' +
+    '\n' +
+    '  # Add multiple components\n' +
+    '  python shadcn_add.py button card dialog\n' +
+    '\n' +
+    '  # Add all components\n' +
+    '  python shadcn_add.py --all\n' +
+    '\n' +
+    '  # Overwrite existing components\n' +
+    '  python shadcn_add.py button --overwrite\n' +
+    '\n' +
+    '  # Dry run (show what would be done)\n' +
+    '  python shadcn_add.py button card --dry-run\n' +
+    '\n' +
+    '  # List installed components\n' +
+    '  python shadcn_add.py --list\n' +
+    '        \n';
+
+const USAGE =
+    `usage: ${PROG} [-h] [--all] [--overwrite] [--dry-run] [--list]\n` +
+    '                     [--project-root PROJECT_ROOT]\n' +
+    '                     [components ...]\n';
+
+class ArgExit extends Error {
+    constructor(public code: number) {
+        super('argexit');
+    }
+}
+
+interface Args {
+    components: string[];
+    all: boolean;
+    overwrite: boolean;
+    dry_run: boolean;
+    list: boolean;
+    project_root: string | null;
+}
+
+function argError(message: string): never {
+    process.stderr.write(USAGE);
+    process.stderr.write(`${PROG}: error: ${message}\n`);
+    throw new ArgExit(2);
+}
+
+/** Parse argv mirroring the argparse spec (positional `components` nargs="*"). */
+function parseArgs(argv: string[]): Args {
+    const args: Args = {
+        components: [],
+        all: false,
+        overwrite: false,
+        dry_run: false,
+        list: false,
+        project_root: null,
+    };
+
+    let i = 0;
+    while (i < argv.length) {
+        let a = argv[i] as string;
+        let inlineValue: string | null = null;
+        const eq = a.indexOf('=');
+        if (a.startsWith('--') && eq !== -1) {
+            inlineValue = a.slice(eq + 1);
+            a = a.slice(0, eq);
+        }
+
+        if (a === '-h' || a === '--help') {
+            process.stdout.write(HELP);
+            throw new ArgExit(0);
+        } else if (a === '--all') {
+            args.all = true;
+        } else if (a === '--overwrite') {
+            args.overwrite = true;
+        } else if (a === '--dry-run') {
+            args.dry_run = true;
+        } else if (a === '--list') {
+            args.list = true;
+        } else if (a === '--project-root') {
+            const v = inlineValue ?? (argv[++i] as string | undefined);
+            if (v === undefined) {
+                argError('argument --project-root: expected one argument');
+            }
+            args.project_root = v;
+        } else if (a.startsWith('-') && a !== '-') {
+            argError(`unrecognized arguments: ${argv[i]}`);
+        } else {
+            args.components.push(argv[i] as string);
+        }
+        i += 1;
+    }
+    return args;
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    let args: Args;
+    try {
+        args = parseArgs(argv);
+    } catch (e) {
+        if (e instanceof ArgExit) {
+            return e.code;
+        }
+        throw e;
+    }
+
+    const installer = new ShadcnInstaller(args.project_root, args.dry_run);
+
+    // Handle list command
+    if (args.list) {
+        const [success, message] = installer.listInstalled();
+        process.stdout.write(`${message}\n`);
+        return success ? 0 : 1;
+    }
+
+    // Handle add all command
+    if (args.all) {
+        const [success, message] = installer.addAllComponents(args.overwrite);
+        process.stdout.write(`${message}\n`);
+        return success ? 0 : 1;
+    }
+
+    // Handle add specific components
+    if (args.components.length === 0) {
+        process.stdout.write(HELP);
+        return 1;
+    }
+
+    const [success, message] = installer.addComponents(args.components, args.overwrite);
+
+    process.stdout.write(`${message}\n`);
+    return success ? 0 : 1;
+}
+
+const _invokedDirectly =
+    process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (_invokedDirectly) {
+    process.exitCode = main();
+}

package/dist/agent-src/skills/readme-writing-package/SKILL.md

@@ -263,7 +263,7 @@ Pair the catalog with a separate "Global install" subsection (same flags
 plus `--global`) and an "Other commands" subsection. Reference example:
 [`README.md § Pick specific AIs`](../../../README.md#pick-specific-ais) in
 this repository. Inspiration:
-[`ui-ux-pro-max-skill § Installation`](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill#installation).
+[`an external reference suite § Installation`](https://github.com/an external reference suite#installation).
 
 Use the catalog when the package's primary install action varies by
 platform; use a matrix table (Tool / Rules / Skills / Commands) for

package/dist/agent-src/skills/reasoning-orchestrator/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: reasoning-orchestrator
+description: "Use for multi-step / ambiguous / end-to-end work — refactor a whole module, drive a vague ticket to a verified result, plan+build+verify a migration; coordinates the reasoning chain across skills."
+source: package
+domain: engineering
+status: active
+model_tier: medium
+tier: senior
+context_spine: [repo]
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+requires_skills:
+  - memory-consolidation
+  - adversarial-review
+  - subagent-orchestration
+  - complexity-first-planning
+---
+
+# reasoning-orchestrator
+
+The **primary coordination mechanism** of the Reasoning Discipline Protocol
+(roadmap L6). It is behavioral glue — like [`subagent-orchestration`](../subagent-orchestration/SKILL.md)
+and [`feature-planning`](../feature-planning/SKILL.md) — that sequences the
+discipline so it acts as one system instead of a buffet of optional steps. It
+**composes** the underlying skills/rules; it never re-implements them, and it
+adds **no new flow** (it is invoked within discovery/implementation, honoring
+`src/flows/README.md`).
+
+Engage per [`rdp-gate`](../../contexts/execution/rdp-gate.md): skip on trivial
+tasks; on a strong-reasoning host run **light / as suggestion** (it self-
+coordinates); on a standard host run the full chain.
+
+## When to use
+
+- A complex, ambiguous, or long-horizon task on a standard host.
+- Work where the reasoning steps are interdependent (a missed grounding or skipped
+  verification compounds downstream).
+
+Do NOT use for trivial / linear / fully-specified tasks (the gate filters these),
+and do not let it duplicate the work of the skills it coordinates.
+
+## When the agent should load this
+
+- A task is complex / ambiguous / long-horizon and the host is a standard model.
+- The reasoning steps are interdependent and a skipped link (grounding,
+  verification) would compound downstream.
+- Several discipline skills would otherwise fire piecemeal — load this to make
+  them act as one ordered chain instead of a buffet of optional steps.
+
+## Procedure — the chain it enforces
+
+Each link **delegates** to the artifact that owns it (no duplication):
+
+1. **ground** — close constraints/tools/info-gaps before designing
+   ([`think-before-action` § Environment grounding](../../rules/think-before-action.md)).
+2. **intent** — state the inferred goal + one recommendation, standard host only
+   ([`improve-before-implement` § Intent inference](../../rules/improve-before-implement.md)).
+3. **notes** — hypotheses/predictions/decisions/uncertainty to the notes file, not
+   the response ([`notes-first-reasoning`](../../rules/notes-first-reasoning.md)).
+4. **gather** — resolve the load-bearing unknown first
+   ([`complexity-first-planning`](../complexity-first-planning/SKILL.md)); dispatch
+   independent subtasks async ([`subagent-orchestration` § RDP](../subagent-orchestration/SKILL.md)).
+5. **audit** — check progress against real tool results
+   ([`verify-before-complete`](../../rules/verify-before-complete.md)).
+6. **verify** — fresh-context verifier on the structural-complexity gate
+   ([`adversarial-review` § RDP](../adversarial-review/SKILL.md)).
+
+## Fail-safe
+
+If the orchestrator does not fire (gate off, or the host skips it), the
+individual skills/rules still apply on their own triggers — the discipline
+degrades gracefully to the distributed extensions rather than disappearing. The
+orchestrator's value is **coherence** (the links happen in order, with handoffs),
+not exclusivity.
+
+## Output
+
+The task's actual deliverable — produced through the chain. Reasoning stays in the
+notes file; the response leads with the outcome + its evidence.
+
+## Do NOT
+
+- Re-implement grounding / verification / planning here — **delegate**.
+- Create a new flow or a standalone pack — this is a skill invoked within existing flows.
+- Run the full chain on a strong-reasoning host or a trivial task — the gate says light/off.
+
+## Gotchas
+
+- **Buffet collapse.** Without the orchestrator, the discipline skills fire
+  independently and the chain's *order* is lost (verification before grounding,
+  notes never written). The whole value is the ordered handoff — running the
+  links out of sequence is the failure this skill prevents.
+- **Duplication creep.** Inlining a delegated step's logic here (re-doing the
+  grounding instead of pointing at `think-before-action`) silently forks the
+  behavior; the two copies then drift. Always delegate, never re-implement.
+- **Wrong host, full chain.** Running every link on a strong-reasoning host wastes
+  tokens and reads as nagging — the gate says light/suggestion there. Forcing the
+  full chain regardless of host is a cost regression, not rigor.
+
+## Related Skills
+
+**WHEN to use this**
+
+- A complex / ambiguous / long-horizon task on a standard host where the reasoning
+  links are interdependent.
+- Several discipline skills would otherwise fire piecemeal and need ordering.
+
+**WHEN NOT to use this**
+
+- Trivial / linear / fully-specified tasks — the
+  [`rdp-gate`](../../contexts/execution/rdp-gate.md) filters these.
+- A single discipline step in isolation — invoke that skill/rule directly
+  ([`think-before-action`](../../rules/think-before-action.md),
+  [`verify-before-complete`](../../rules/verify-before-complete.md)) instead of the
+  whole chain.
+- Needing the rationale behind the protocol — read
+  [`frontier-reasoning-operating-profile`](../../../../docs/guidelines/agent-infra/frontier-reasoning-operating-profile.md).

package/dist/agent-src/skills/reasoning-orchestrator/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "reasoning-orchestrator",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers complex / ambiguous / long-horizon work on a standard host where the reasoning steps are interdependent; should-not covers trivial / linear tasks, strong-host self-coordination, and single-discipline neighbors.",
+  "queries": [
+    {"q": "refactor the entire billing module to be cleaner and safer", "trigger": true},
+    {"q": "build this feature end to end from a vague brief — figure out the steps", "trigger": true},
+    {"q": "investigate this flaky multi-service failure and fix it properly", "trigger": true},
+    {"q": "take this ambiguous ticket and drive it to a verified implementation", "trigger": true},
+    {"q": "plan and implement the migration with checks at each stage", "trigger": true},
+    {"q": "rename this variable", "trigger": false, "note": "trivial — gate off"},
+    {"q": "format this file", "trigger": false, "note": "trivial"},
+    {"q": "just write the regex for an email", "trigger": false, "note": "single linear step"},
+    {"q": "only run the test suite and report", "trigger": false, "note": "single-discipline (verify), no chain to coordinate"},
+    {"q": "add a one-line log statement here", "trigger": false, "note": "trivial"}
+  ]
+}

package/dist/agent-src/skills/receiving-code-review/SKILL.md

@@ -84,11 +84,12 @@ For each comment classified as blocking/important:
   for a reason
 * **Consult memory for prior context.** Via
   [`memory-access`](../../../docs/guidelines/agent-infra/memory-access.md),
-  call `retrieve(types=["historical-patterns", "architecture-decisions"],
+  call `retrieve(types=["historical-patterns"],
   keys=<files in the review>, limit=3)`. A registered historical pattern
-  may confirm the reviewer's concern (accept) or an architecture
-  decision may explain why the current shape is intentional (push back
-  with the cited `id`).
+  may confirm the reviewer's concern (accept). For architectural rationale
+  ("why is the current shape intentional?"), check the ADR index
+  [`docs/decisions/INDEX.md`](../../../docs/decisions/INDEX.md) — push back
+  with the cited ADR number.
 
 ### 4. Decide: accept, push back, or escalate
 
@@ -178,8 +179,7 @@ When reporting back to the user after handling review:
 ## When to hand over to another skill / command
 
 * Executing the fixes across many comments → [`fix-pr-comments`](../../commands/fix-pr-comments.md)
-  (handles both bot + developer), [`fix-pr-bot-comments`](../../commands/fix-pr-bot-comments.md),
-  [`fix-pr-developer-comments`](../../commands/fix-pr-developer-comments.md)
+  (handles both bot + human reviewers in one pass)
 * Running the full verification gate before pushing replies →
   [`verify-before-complete`](../verify-before-complete/SKILL.md)
 * Writing the commit message that references the review →

package/dist/agent-src/skills/refine-prompt/SKILL.md

@@ -183,7 +183,7 @@ Before emitting the envelope, run these three scans. Each is a fast pass; failur
 2. **Placeholder / TODO scan** — the rendered envelope contains no `<placeholder>`, `TODO`, `FIXME`, `tbd`, `???`, `XXX` strings. The literal angle-bracket placeholders in the template (`<one sentence …>`, `<bullet>`) must be replaced with concrete text before emission.
 3. **Type / shape consistency** — every named file, module, route, or command in the AC matches the project's existing conventions. If the prompt names `auth.service.ts` but the codebase uses `AuthService.php`, surface the mismatch in *Assumptions* rather than adopting the prompt's spelling.
 
-Source: adapted from `obra/superpowers` `writing-plans/SKILL.md` § Self-Review (v5.1.0).
+Source: adapted from an external reference `writing-plans/SKILL.md` § Self-Review (v5.1.0).
 
 ## Band-action mapping
 

package/dist/agent-src/skills/refine-ticket/SKILL.md

@@ -272,7 +272,7 @@ Run these three scans on the rendered output before the close-prompt. Each is a
 
 Self-review is mechanical (gaps, leftovers, naming drift); persona voices and orchestration outputs handle reasoning critique. Both run; neither replaces the other.
 
-Source: adapted from `obra/superpowers` `writing-plans/SKILL.md` § Self-Review (v5.1.0).
+Source: adapted from an external reference `writing-plans/SKILL.md` § Self-Review (v5.1.0).
 
 ## Close-prompt (mandatory final step)
 

package/dist/agent-src/skills/refine-ticket/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "refine-ticket",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings and the four input paths (key, branch, paste, URL). Should-not-trigger covers the four near-miss neighbors (plan / estimate / duplicate / threat-model / bug-investigate) whose vocabulary overlaps with ticket refinement.",
   "queries": [
     {"q": "refine this ticket before I plan it", "trigger": true},

package/dist/agent-src/skills/repomix-packer/SKILL.md

@@ -136,6 +136,6 @@ Cite the snapshot path so the consumer skill can read it.
 ## Provenance
 
 - Upstream tool: https://github.com/yamadashy/repomix (MIT).
-- Adopted from: `Microck/ordinary-claude-skills@8f5c83174f7aa683b4ddc7433150471983b93131:skills_all/repomix/SKILL.md` (MIT, © 2025 Microck) — wrapper-style adoption, no upstream code vendored.
+- Adopted from: an external reference (MIT, © 2025 an external reference) — wrapper-style adoption, no upstream code vendored.
 - Provenance registry: `agents/settings/contexts/skills-provenance.yml` (entry: `repomix`).
 - Iron-Law floor: `non-destructive-by-default`, `missing-tool-handling`, `tool-safety`.

package/dist/agent-src/skills/roadmap-management/SKILL.md

@@ -212,13 +212,16 @@ When picking up a roadmap in a new session:
 
 ### Completing, archiving & skipping a roadmap
 
-Every roadmap ends in exactly one of three states:
+Every roadmap ends in exactly one of four states:
 
 | State | Folder | Trigger |
 |---|---|---|
-| **Active** | `agents/roadmaps/` | Work in progress or planned |
+| **Active** | `agents/roadmaps/` | Work in progress or planned **and workable now** |
 | **Archived** | `agents/roadmaps/archive/` | Work was done (fully or partially) and no more work is planned |
 | **Skipped** | `agents/roadmaps/skipped/` | Decision against pursuit — superseded, scope rejected, wrong direction. Typically **0 items `[x]`** |
+| **Later** | `agents/roadmaps/later/` | Open work remains but is **blocked-for-later** — gated on an external trigger or a decision, **will resume** when unblocked. Set frontmatter `status: later` + a `Blocked until` / `Trigger` resume line. Excluded from the dashboard and `/roadmap:process-*` (parked, not abandoned). |
+
+**Active vs. Later — the test:** can the agent make progress on this roadmap *now*, autonomously? If every open item is gated on something outside this roadmap (a real consumer repo, a benchmark re-open, host-model access, a kernel soak, a pruning track, a human decision), it is **not** active — move it to `later/` with its resume condition. A blocked roadmap left in the active tree silently lies to the dashboard and to `/roadmap:process-*`, which will keep trying to execute it. The `lint_roadmap_later_disposition` guard enforces the placement↔`status: later` contract.
 
 After the last step of a roadmap is done, check completion status:
 
@@ -248,6 +251,7 @@ After the last step of a roadmap is done, check completion status:
 
    - Archive: `✅  Roadmap archived → agents/roadmaps/archive/{filename}`
    - Skip:    `⏭️  Roadmap skipped → agents/roadmaps/skipped/{filename}`
+   - Later:   `🕒  Roadmap parked for later → agents/roadmaps/later/{filename}`
 
    `[-]` cancelled items remain searchable in archived file — they were
    explicit drops. `[~]` deferred items, by contrast, may not silently
@@ -268,6 +272,7 @@ After the last step of a roadmap is done, check completion status:
    > 2. Keep active — I want to finish the open items
    > 3. Mark open items as deferred [~] and archive (triggers Iron Law 3 flow)
    > 4. Skip — move to skipped/ (no meaningful work done, not pursuing)
+   > 5. Later — park in later/ (open work is blocked on an external trigger / decision but will resume)
    ```
 
    Option 4 only appropriate when `count_x == 0` or completed items were
@@ -276,6 +281,14 @@ After the last step of a roadmap is done, check completion status:
    NOT archive immediately — converts open → deferred, re-enters the
    `count_deferred > 0` branch, which runs step 4b.
 
+   **Option 5 (Later) — right when open items are real but cannot proceed
+   now** (gated on an external trigger or a decision). Set frontmatter
+   `status: later`, ensure a `Blocked until` / `Trigger` resume line, `git mv`
+   to `agents/roadmaps/later/`, migrate inbound refs to the new path, regen.
+   Open `[ ]` items stay open (not cancelled/deferred) — parked whole, ready to
+   resume when the trigger fires. **Roadmaps with open tasks deferred for later
+   are always moved to `later/`**, never left to rot in the active tree.
+
 4b. **Deferred items present (`count_deferred ≥ 1`, `count_open == 0`)** — Iron Law 3 flow.
    Archive **blocked** until user resolves deferrals. Surface plan and ask:
 
@@ -401,7 +414,7 @@ no meaningful work was invested and the scope itself was rejected.
 
 A generated dashboard aggregates progress across every open roadmap. It sits at
 `agents/roadmaps-progress.md` (outside `roadmaps/` to keep the folder clean) and
-is rewritten by `.augment/scripts/update_roadmap_progress.py`.
+is rewritten by `.augment/scripts/update_roadmap_progress.ts`.
 
 **Always regenerate in the SAME response** after any of the following
 (enforced by [`roadmap-progress-sync`](../../rules/roadmap-progress-sync.md)):