@plainconceptsplatform/workflows 0.2.1 → 0.3.2

package/README.md

@@ -10,7 +10,7 @@ The primary entrypoint is the interactive TUI. Run it with no arguments:
 npx @plainconceptsplatform/workflows
 ```
 
-The TUI lists all routes and templates with install status. Arrow keys navigate, space toggles, Enter installs. Selecting any route installs the full managed catalog plus mandatory `opencode.ci.json` and `scripts/compile-agent-workflows.mjs`. Selecting only templates still installs those mandatory files.
+The TUI lists all routes and templates with install status. Arrow keys navigate, space toggles, Enter installs. Selecting routes installs only those route workers plus mandatory files (opencode.ci.json, compile script, shared imports, actions, router, classifier, route matrix). Selecting only templates installs just those templates.
 
 ## Install
 
@@ -35,7 +35,18 @@ pnpm exec workflows add
 
 `init` inspects the repository and reports its stack and visibility. It does not create or manage repository configuration or a manifest.
 
-`add` installs package-owned files including the mandatory `opencode.ci.json` and `scripts/compile-agent-workflows.mjs`. It stops when a managed file differs. Use `pnpm exec workflows update --force` only when you intend to replace managed workflow files.
+`add` installs mandatory files (opencode.ci.json, compile script, shared imports, actions, router, classifier, route matrix) when called with no route arguments. Pass route names as positional arguments to install specific route workers alongside the mandatory files:
+
+```bash
+workflows add                        # mandatory files only, no worker .md files
+workflows add implement refine direct  # those route workers plus mandatory files
+workflows add --template agentics-checks  # named template only (no mandatory files)
+workflows add refine --template agentics-checks --force  # routes + template + mandatory, overwriting conflicts
+```
+
+Route names: refine, implement, direct, apply-review, merge-gate, audit, propose. Unknown arguments produce an error.
+
+Use `workflows update --force` to force-overwrite managed files that differ from the package source.
 
 Install optional standalone templates with `add --template`. Available templates are `agentics-checks`, `agentics-maintenance`, `app-ci-dotnet-next`, and `app-ci-node-monorepo`. CI templates are stack-specific copies, not a combined template. Edit their top-level `env:` values for repository paths, package names, and commands.
 

package/dist/catalog-installation.d.ts

@@ -1,4 +1,5 @@
-import { type TemplateName } from "./workflow-catalog.js";
+import { type RouteName, type TemplateName } from "./workflow-catalog.js";
+import type { RepositoryInspection } from "./repository-inspection.js";
 export interface CatalogInstallResult {
     readonly installed: readonly string[];
     readonly conflicts: readonly string[];
@@ -6,6 +7,8 @@ export interface CatalogInstallResult {
 export interface CatalogInstallOptions {
     readonly force?: boolean;
     readonly sourcePath?: string;
+    readonly selectedRoutes?: readonly RouteName[];
+    readonly inspection?: RepositoryInspection;
 }
 interface CatalogFile {
     readonly source: string;
@@ -18,4 +21,7 @@ export declare function installCatalog(repositoryPath: string, options?: Catalog
 export declare function installTemplate(repositoryPath: string, template: TemplateName, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
 export declare function installMandatoryFiles(repositoryPath: string, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
 export declare function isTemplateName(value: string): value is TemplateName;
+export declare function ensurePreCommitHook(repositoryPath: string): Promise<void>;
+export declare function runCompileIfAvailable(repositoryPath: string): Promise<void>;
+export declare function exists(path: string): Promise<boolean>;
 export {};

package/dist/catalog-installation.js

@@ -1,8 +1,13 @@
-import { access, copyFile, mkdir, readFile, readdir } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { access, copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { catalogTemplates, mandatoryFiles, templateNames } from "./workflow-catalog.js";
+import { promisify } from "node:util";
+import { catalogTemplates, mandatoryFiles, routeNames, templateNames } from "./workflow-catalog.js";
+import { processRoutes, excludedWorkerFiles } from "./route-processing.js";
+import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv } from "./stack-defaults.js";
+const execFileAsync = promisify(execFile);
 const sourceMappings = [
     ["actions", ".github/actions"],
     ["workflows", ".github/workflows"],
@@ -20,23 +25,68 @@ export function catalogSourcePath(modulePath = fileURLToPath(import.meta.url)) {
 }
 export async function installCatalog(repositoryPath, options = {}) {
     const sourcePath = options.sourcePath ?? catalogSourcePath();
-    const files = [...await catalogFiles(sourcePath), ...mandatoryFileSpecs(sourcePath)];
-    const deduplicated = files.filter((file, index) => files.findIndex((f) => f.target === file.target) === index).sort((left, right) => left.target.localeCompare(right.target));
-    const managedFiles = deduplicated.filter((file) => file.managed);
+    const selectedRoutes = options.selectedRoutes ?? routeNames;
+    const allFiles = [...await catalogFiles(sourcePath), ...mandatoryFileSpecs(sourcePath)];
+    const deduplicated = allFiles.filter((file, index) => allFiles.findIndex((f) => f.target === file.target) === index).sort((left, right) => left.target.localeCompare(right.target));
+    const excluded = excludedWorkerFiles(selectedRoutes);
+    const filtered = deduplicated.filter((file) => {
+        const fileName = file.target.split("/").pop() ?? "";
+        return !excluded.has(fileName);
+    });
+    const managedFiles = filtered.filter((file) => file.managed);
     const conflicts = (await Promise.all(managedFiles.map(async (file) => {
         const destination = join(repositoryPath, file.target);
         return await exists(destination) && !(await filesMatch(file.source, destination)) ? file.target : undefined;
     }))).filter((file) => file !== undefined);
     if (conflicts.length > 0 && !options.force)
         return { installed: [], conflicts };
-    await Promise.all(deduplicated.map(async (file) => {
-        const destination = join(repositoryPath, file.target);
-        if (!file.managed && await exists(destination))
+    const fileContents = new Map();
+    for (const file of filtered) {
+        fileContents.set(file.target, await readFile(file.source, "utf8"));
+    }
+    let processedContents = processRoutes(fileContents, selectedRoutes);
+    if (options.inspection !== undefined) {
+        const defaults = generateStackDefaults(options.inspection);
+        processedContents = injectStackIntoWorkers(processedContents, defaults);
+        processedContents = transformOpencodeFiles(processedContents, options.inspection);
+    }
+    await Promise.all([...processedContents.entries()].map(async ([target, content]) => {
+        const destination = join(repositoryPath, target);
+        const originalFile = filtered.find((f) => f.target === target);
+        if (originalFile !== undefined && !originalFile.managed && await exists(destination))
             return;
         await mkdir(dirname(destination), { recursive: true });
-        await copyFile(file.source, destination);
+        await writeFile(destination, content, "utf8");
     }));
-    return { installed: deduplicated.map((file) => file.target), conflicts };
+    await ensurePreCommitHook(repositoryPath);
+    try {
+        await runCompileIfAvailable(repositoryPath);
+    }
+    catch {
+        // compile failure is non-fatal
+    }
+    return { installed: [...processedContents.keys()].sort(), conflicts };
+}
+function injectStackIntoWorkers(files, defaults) {
+    const result = new Map(files);
+    for (const [key, content] of result) {
+        if (key.startsWith(".github/workflows/agent-") && key.endsWith(".md")) {
+            result.set(key, injectStackEnv(content, defaults));
+        }
+    }
+    return result;
+}
+function transformOpencodeFiles(files, inspection) {
+    const result = new Map(files);
+    for (const [key, content] of result) {
+        if (key.endsWith("opencode-ci.md")) {
+            result.set(key, generateOpencodeCi(content, inspection));
+        }
+        else if (key === "opencode.ci.json") {
+            result.set(key, generateOpencodeConfig(content, inspection));
+        }
+    }
+    return result;
 }
 export async function installTemplate(repositoryPath, template, options = {}) {
     const sourcePath = options.sourcePath ?? catalogSourcePath();
@@ -49,6 +99,17 @@ export async function installTemplate(repositoryPath, template, options = {}) {
         return { installed: [], conflicts };
     await mkdir(dirname(destination), { recursive: true });
     await copyFile(source, destination);
+    if (options.inspection !== undefined && template === "opencode.ci.json") {
+        const baseContent = await readFile(source, "utf8");
+        const transformed = generateOpencodeConfig(baseContent, options.inspection);
+        await writeFile(destination, transformed, "utf8");
+    }
+    try {
+        await runCompileIfAvailable(repositoryPath);
+    }
+    catch {
+        // compile failure is non-fatal
+    }
     return { installed: [target], conflicts };
 }
 export async function installMandatoryFiles(repositoryPath, options = {}) {
@@ -70,13 +131,34 @@ export async function installMandatoryFiles(repositoryPath, options = {}) {
 export function isTemplateName(value) {
     return templateNames.includes(value);
 }
+export async function ensurePreCommitHook(repositoryPath) {
+    const hookPath = join(repositoryPath, ".husky", "pre-commit");
+    if (!await exists(hookPath))
+        return;
+    const content = await readFile(hookPath, "utf8");
+    const compileLine = "node scripts/compile-agent-workflows.mjs";
+    if (content.includes("compile-agent-workflows"))
+        return;
+    const newContent = content.endsWith("\n") || content === ""
+        ? `${content}${compileLine}\n`
+        : `${content}\n${compileLine}\n`;
+    await writeFile(hookPath, newContent, "utf8");
+}
+export async function runCompileIfAvailable(repositoryPath) {
+    const script = join(repositoryPath, "scripts", "compile-agent-workflows.mjs");
+    if (await exists(script)) {
+        await execFileAsync("node", [script, "--force"], { cwd: repositoryPath });
+    }
+}
 function catalogTemplateMeta(template) {
     const entry = catalogTemplates.find((item) => item.name === template);
     if (entry === undefined)
         throw new Error(`Unknown template: ${template}`);
     const directory = template.startsWith("opencode") ? "opencode" : template.startsWith("app-ci-") ? "ci" : "agentics";
     const isWorkflow = entry.file.endsWith(".yml");
-    const target = isWorkflow ? `.github/workflows/${entry.file}` : entry.file;
+    const target = template === "app-ci-dotnet-next"
+        ? ".github/workflows/app-ci.yml"
+        : isWorkflow ? `.github/workflows/${entry.file}` : entry.file;
     return { directory, file: entry.file, target };
 }
 async function catalogFiles(sourcePath) {
@@ -113,7 +195,7 @@ async function filesMatch(source, destination) {
         return false;
     }
 }
-async function exists(path) {
+export async function exists(path) {
     try {
         await access(path, constants.F_OK);
         return true;

package/dist/catalog-installation.test.js

@@ -15,6 +15,34 @@ describe("catalog installation", () => {
         });
         expect(catalogSourcePath(join(packageDirectory, "dist", "catalog-installation.js"))).toBe(join(packageDirectory, "loops"));
     });
+    it("installCatalog with empty selectedRoutes installs mandatory and infrastructure files but no worker .md files", async () => {
+        const sourcePath = await createDirectory({
+            "actions/check/action.yml": "name: Check\n",
+            "workflows/agent-refine.md": "# Refine\n",
+            "workflows/agent-implement.md": "# Implement\n",
+            "workflows/agent-direct.md": "# Direct\n",
+            "workflows/agent-audit.md": "# Audit\n",
+            "workflows/agent-propose.md": "# Propose\n",
+            "workflows/agent-apply-review.md": "# Apply Review\n",
+            "workflows/agent-merge-gate.md": "# Merge Gate\n",
+            "workflows/shared/defaults.md": "defaults\n",
+            "workflows/work-router.yml": "name: Router\n",
+            "scripts/compile-agent-workflows.mjs": "compile\n",
+            "templates/opencode/opencode.ci.json": "{ \"model\": \"plainconcepts/glm-5-2\" }\n",
+        });
+        const repositoryPath = await createDirectory({});
+        const result = await installCatalog(repositoryPath, { sourcePath, selectedRoutes: [] });
+        expect(result.installed).toContain("opencode.ci.json");
+        expect(result.installed).toContain("scripts/compile-agent-workflows.mjs");
+        expect(result.installed).toContain(".github/actions/check/action.yml");
+        expect(result.installed.some((f) => f.endsWith("shared/defaults.md"))).toBe(true);
+        expect(result.installed.some((f) => f.endsWith("work-router.yml"))).toBe(true);
+        // No worker .md files
+        expect(result.installed).not.toContain(".github/workflows/agent-refine.md");
+        expect(result.installed).not.toContain(".github/workflows/agent-implement.md");
+        expect(result.installed).not.toContain(".github/workflows/agent-audit.md");
+        expect(result.installed).not.toContain(".github/workflows/agent-propose.md");
+    });
     it("installs package-owned loops files including mandatory opencode.ci.json and compile script", async () => {
         const sourcePath = await createDirectory({
             "actions/check/action.yml": "name: Check\n",
@@ -226,6 +254,17 @@ describe("catalog installation", () => {
         });
         await expect(readFile(join(repositoryPath, "opencode.ci.json"), "utf8")).resolves.toBe("{ \"model\": \"plainconcepts/glm-5-2\" }\n");
     });
+    it("installs the .NET and Next.js CI template as app-ci.yml", async () => {
+        const sourcePath = await createDirectory({
+            "templates/ci/app-ci-dotnet-next.yml": "name: App: CI\n",
+        });
+        const repositoryPath = await createDirectory({});
+        await expect(installTemplate(repositoryPath, "app-ci-dotnet-next", { sourcePath })).resolves.toEqual({
+            installed: [".github/workflows/app-ci.yml"],
+            conflicts: [],
+        });
+        await expect(readFile(join(repositoryPath, ".github/workflows/app-ci.yml"), "utf8")).resolves.toBe("name: App: CI\n");
+    });
     it("requires force to replace the opencode.ci.json template", async () => {
         const sourcePath = await createDirectory({
             "templates/opencode/opencode.ci.json": "{ \"model\": \"plainconcepts/glm-5-2\" }\n",

package/dist/index.js

@@ -2,6 +2,7 @@
 import { inspectRepository, parseVisibility, resolveVisibility } from "./repository-inspection.js";
 import { installCatalog, installTemplate, isTemplateName } from "./catalog-installation.js";
 import { formatCatalog, listCatalog, searchCatalog } from "./catalog-listing.js";
+import { routeNames } from "./workflow-catalog.js";
 import { runInteractive } from "./tui.js";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,15 +20,25 @@ Usage: workflows <command> [options]
 Commands:
   (default)                                   Launch the interactive TUI for selecting and installing items.
   init                                        Inspect the repository and report its stack and visibility.
-  add                                         Install package-owned workflow files into .github/.
-  update                                      Alias for add. Use --force to overwrite managed files.
+  add [routes] [--template <name>] [--force]  Install route workers, a template, or mandatory files.
+  update                                      Alias for add.
   status                                      Print repository inspection as JSON.
   list                                        List all available workflows and templates with install status.
   search <query>                              Filter workflows and templates by name or description.
 
+Route names (positional arguments to add):
+  refine, implement, direct, apply-review, merge-gate, audit, propose
+
+  add                                         Mandatory files only (opencode.ci.json, compile script,
+                                              shared imports, actions, router, classifier, route matrix).
+  add implement refine direct                Installs those route workers plus mandatory files.
+  add --template agentics-checks             Installs the named template only (no mandatory files).
+  add refine --template agentics-checks      Installs routes + mandatory + the named template.
+  add refine implement --force               Forces re-install of routes plus mandatory, overwriting.
+
 Options:
   --visibility public|private                 Override repository visibility (init only).
-  --template <name>                           Install a standalone template instead of the catalog.
+  --template <name>                           Install a standalone template alongside or instead of routes.
                                               Templates: agentics-checks, agentics-maintenance,
                                               app-ci-dotnet-next, app-ci-node-monorepo,
                                               opencode.ci.json.
@@ -74,18 +85,35 @@ export async function run(arguments_, repositoryPath = process.cwd()) {
         return 0;
     }
     if (command === "add" || command === "update") {
-        const template = readTemplateOption(options);
-        if (template === "invalid")
-            return fail(`${command} accepts only --force or --template agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|opencode.ci.json.`);
-        const force = options.includes("--force");
-        const result = template === undefined
-            ? await installCatalog(repositoryPath, { force })
-            : await installTemplate(repositoryPath, template, { force });
-        if (result.conflicts.length > 0 && !force) {
-            console.error(`Catalog conflicts found. Re-run with --force to overwrite package-managed files:\n${result.conflicts.join("\n")}`);
+        const parsed = parseAddOptions(options);
+        if (parsed.kind === "invalid")
+            return fail(parsed.message);
+        const inspection = await inspectRepository(repositoryPath);
+        const routes = parsed.routes;
+        const template = parsed.template;
+        const force = parsed.force;
+        const allConflicts = [];
+        const allInstalled = [];
+        if (routes.length > 0) {
+            const result = await installCatalog(repositoryPath, { force, selectedRoutes: routes, inspection });
+            allConflicts.push(...result.conflicts);
+            allInstalled.push(...result.installed);
+        }
+        else if (template === undefined) {
+            const result = await installCatalog(repositoryPath, { force, selectedRoutes: [], inspection });
+            allConflicts.push(...result.conflicts);
+            allInstalled.push(...result.installed);
+        }
+        if (template !== undefined) {
+            const result = await installTemplate(repositoryPath, template, { force, inspection });
+            allConflicts.push(...result.conflicts);
+            allInstalled.push(...result.installed);
+        }
+        if (allConflicts.length > 0 && !force) {
+            console.error(`Catalog conflicts found. Re-run with --force to overwrite package-managed files:\n${allConflicts.join("\n")}`);
             return 1;
         }
-        console.log(JSON.stringify({ command, ...result }, null, 2));
+        console.log(JSON.stringify({ command, installed: allInstalled.sort(), conflicts: allConflicts }, null, 2));
         return 0;
     }
     return fail(`Unknown command: ${command}`);
@@ -97,18 +125,50 @@ function readVisibilityOption(options) {
         return "invalid";
     return parseVisibility(options[1]) ?? "invalid";
 }
-function readTemplateOption(options) {
-    const templateIndex = options.indexOf("--template");
-    if (templateIndex === -1)
-        return options.every((option) => option === "--force") ? undefined : "invalid";
-    if (templateIndex + 1 >= options.length || options.filter((option) => option === "--template").length !== 1)
-        return "invalid";
-    if (options.some((option, index) => option !== "--force" && index !== templateIndex && index !== templateIndex + 1))
-        return "invalid";
-    return templateNameFromOptions(options[templateIndex + 1]);
+const TEMPLATE_NAMES = "agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|opencode.ci.json";
+function parseAddOptions(options) {
+    const routes = [];
+    let template;
+    let templateSeen = false;
+    let force = false;
+    let i = 0;
+    while (i < options.length) {
+        const token = options[i];
+        if (token === "--force") {
+            force = true;
+            i++;
+            continue;
+        }
+        if (token === "--template") {
+            if (templateSeen)
+                return invalid("--template can only be specified once.");
+            templateSeen = true;
+            if (i + 1 >= options.length)
+                return invalid("--template requires a name.");
+            const name = options[i + 1];
+            if (!isTemplateName(name))
+                return invalid(`--template must be one of: ${TEMPLATE_NAMES}.`);
+            template = name;
+            i += 2;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            return invalid(`Unknown option: ${token}`);
+        }
+        if (routeNames.includes(token)) {
+            const route = token;
+            if (routes.includes(route))
+                return invalid(`Duplicate route: ${route}.`);
+            routes.push(route);
+            i++;
+            continue;
+        }
+        return invalid(`Unknown route: ${token}. Valid routes: ${routeNames.join(", ")}.`);
+    }
+    return { kind: "ok", routes, template, force };
 }
-function templateNameFromOptions(value) {
-    return value !== undefined && isTemplateName(value) ? value : "invalid";
+function invalid(message) {
+    return { kind: "invalid", message };
 }
 function fail(message) {
     console.error(message);

package/dist/index.test.js

@@ -3,10 +3,17 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { run } from "./index.js";
+import * as catalogInstallation from "./catalog-installation.js";
 const temporaryDirectories = [];
 afterEach(async () => {
     await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
+    vi.restoreAllMocks();
 });
+function mockInstallers() {
+    const installCatalog = vi.spyOn(catalogInstallation, "installCatalog").mockResolvedValue({ installed: [], conflicts: [] });
+    const installTemplate = vi.spyOn(catalogInstallation, "installTemplate").mockResolvedValue({ installed: [], conflicts: [] });
+    return { installCatalog, installTemplate };
+}
 describe("workflows CLI", () => {
     it("prints template names in help", async () => {
         const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
@@ -16,10 +23,30 @@ describe("workflows CLI", () => {
         expect(log).toHaveBeenCalledWith(expect.stringContaining("opencode.ci.json"));
         log.mockRestore();
     });
-    it("rejects an unsupported template", async () => {
+    it("prints route names as positional arguments in help", async () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["--help"])).resolves.toBe(0);
+        const output = log.mock.calls[0][0];
+        expect(output).toContain("refine, implement, direct, apply-review, merge-gate, audit, propose");
+        expect(output).toContain("add [routes]");
+        log.mockRestore();
+    });
+    it("rejects an unsupported template name", async () => {
         const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
         await expect(run(["add", "--template", "unknown"])).resolves.toBe(1);
-        expect(error).toHaveBeenCalledWith("add accepts only --force or --template agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|opencode.ci.json.");
+        expect(error).toHaveBeenCalledWith("--template must be one of: agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|opencode.ci.json.");
+        error.mockRestore();
+    });
+    it("rejects an unknown route passed to add", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add", "frobnicate"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("Unknown route: frobnicate. Valid routes: refine, implement, direct, apply-review, merge-gate, audit, propose.");
+        error.mockRestore();
+    });
+    it("rejects a duplicate route", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add", "refine", "refine"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("Duplicate route: refine.");
         error.mockRestore();
     });
     it("lists all workflows and templates with install status [ ] when none installed", async () => {
@@ -98,6 +125,99 @@ describe("workflows CLI", () => {
         expect(error).toHaveBeenCalledWith("search requires exactly one query argument.");
         error.mockRestore();
     });
+    it("add with no routes and no template calls installCatalog with empty selectedRoutes", async () => {
+        const { installCatalog, installTemplate } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledOnce();
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ selectedRoutes: [] }));
+        expect(installTemplate).not.toHaveBeenCalled();
+        log.mockRestore();
+    });
+    it("add with explicit routes passes those routes to installCatalog", async () => {
+        const { installCatalog, installTemplate } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "implement", "refine", "direct"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledOnce();
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ selectedRoutes: ["implement", "refine", "direct"] }));
+        expect(installTemplate).not.toHaveBeenCalled();
+        log.mockRestore();
+    });
+    it("add --force passes force flag to installCatalog", async () => {
+        const { installCatalog } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "--force"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ force: true, selectedRoutes: [] }));
+        log.mockRestore();
+    });
+    it("add with routes and --force passes both", async () => {
+        const { installCatalog } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "refine", "implement", "--force"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ force: true, selectedRoutes: ["refine", "implement"] }));
+        log.mockRestore();
+    });
+    it("add with routes and template calls both installCatalog and installTemplate", async () => {
+        const { installCatalog, installTemplate } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "refine", "--template", "agentics-checks"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledOnce();
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ selectedRoutes: ["refine"] }));
+        expect(installTemplate).toHaveBeenCalledOnce();
+        expect(installTemplate).toHaveBeenCalledWith(expect.any(String), "agentics-checks", expect.any(Object));
+        log.mockRestore();
+    });
+    it("add with template only calls installTemplate but not installCatalog", async () => {
+        const { installCatalog, installTemplate } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "--template", "agentics-checks"])).resolves.toBe(0);
+        expect(installCatalog).not.toHaveBeenCalled();
+        expect(installTemplate).toHaveBeenCalledOnce();
+        expect(installTemplate).toHaveBeenCalledWith(expect.any(String), "agentics-checks", expect.any(Object));
+        log.mockRestore();
+    });
+    it("add with routes and template and force passes all options", async () => {
+        const { installCatalog, installTemplate } = mockInstallers();
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "refine", "implement", "--template", "agentics-checks", "--force"])).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ force: true, selectedRoutes: ["refine", "implement"] }));
+        expect(installTemplate).toHaveBeenCalledWith(expect.any(String), "agentics-checks", expect.objectContaining({ force: true }));
+        log.mockRestore();
+    });
+    it("add with conflict and no force exits 1", async () => {
+        const { installCatalog } = mockInstallers();
+        installCatalog.mockResolvedValue({ installed: [], conflicts: ["opencode.ci.json"] });
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith(expect.stringContaining("Catalog conflicts found"));
+        error.mockRestore();
+    });
+    it("add with conflict and --force still succeeds", async () => {
+        const { installCatalog } = mockInstallers();
+        installCatalog.mockResolvedValue({ installed: ["opencode.ci.json"], conflicts: ["opencode.ci.json"] });
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "--force"])).resolves.toBe(0);
+        expect(log).toHaveBeenCalled();
+        log.mockRestore();
+    });
+    it("add with --template but missing name produces an error", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add", "--template"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("--template requires a name.");
+        error.mockRestore();
+    });
+    it("add with multiple --template flags produces an error", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add", "--template", "agentics-checks", "--template", "agentics-maintenance"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("--template can only be specified once.");
+        error.mockRestore();
+    });
+    it("add with unknown flag produces an error", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["add", "--unknown"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("Unknown option: --unknown");
+        error.mockRestore();
+    });
 });
 async function createRepository(files) {
     const repositoryPath = await mkdtemp(join(tmpdir(), "workflows-"));

package/dist/repository-inspection.test.js

@@ -54,7 +54,7 @@ describe("CLI commands", () => {
         const repositoryPath = await createRepository({});
         const error = captureConsole("error");
         await expect(run(["update", "--invalid"], repositoryPath)).resolves.toBe(1);
-        expect(error.calls).toEqual(["update accepts only --force or --template agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|opencode.ci.json."]);
+        expect(error.calls).toEqual(["Unknown option: --invalid"]);
         error.restore();
     });
 });

package/dist/route-processing.d.ts

@@ -0,0 +1,6 @@
+import { type RouteName } from "./workflow-catalog.js";
+export declare function stripRouteFromRouter(yaml: string, route: RouteName): string;
+export declare function stripRouteFromClassifier(shell: string, route: RouteName): string;
+export declare function addRouteExclusion(matrix: string, route: RouteName): string;
+export declare function processRoutes(files: Map<string, string>, selectedRoutes: readonly RouteName[]): Map<string, string>;
+export declare function excludedWorkerFiles(selectedRoutes: readonly RouteName[]): Set<string>;