@plainconceptsplatform/workflows 0.4.34 → 0.5.1

package/dist/catalog-listing.test.js

@@ -1,150 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { formatCatalog, listCatalog, searchCatalog } from "./catalog-listing.js";
-import { workflowRoutes, catalogTemplates } from "./workflow-catalog.js";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
-});
-describe("catalog listing", () => {
-    it("returns all routes and templates", async () => {
-        const repositoryPath = await createRepository({});
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        expect(entries).toHaveLength(workflowRoutes.length + catalogTemplates.length);
-        const routeNames = entries.filter((entry) => entry.kind === "route").map((entry) => entry.name);
-        const templateNames = entries.filter((entry) => entry.kind === "template").map((entry) => entry.name);
-        expect(routeNames).toEqual(["refine", "implement", "direct", "triage", "apply-review", "merge-gate", "audit", "propose"]);
-        expect(templateNames).toEqual(["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "bug-report", "feature-request", "github-release", "opencode.ci.json", "visual-evidence"]);
-    });
-    it("reports all entries as not installed in an empty repository", async () => {
-        const repositoryPath = await createRepository({});
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        expect(entries.every((entry) => entry.installed === false)).toBe(true);
-    });
-    it("marks a route as installed when its worker file exists", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-        });
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        const refineEntry = entries.find((entry) => entry.name === "refine");
-        expect(refineEntry).toBeDefined();
-        expect(refineEntry.installed).toBe(true);
-    });
-    it("marks a template as installed when its template file exists", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agentics-checks.yml": "name: Agentics checks",
-        });
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        const checksEntry = entries.find((entry) => entry.name === "agentics-checks");
-        expect(checksEntry).toBeDefined();
-        expect(checksEntry.installed).toBe(true);
-    });
-    it("marks an issue template as installed when its file exists in .github/ISSUE_TEMPLATE/", async () => {
-        const repositoryPath = await createRepository({
-            ".github/ISSUE_TEMPLATE/bug_report.yml": "name: Bug report",
-            ".github/ISSUE_TEMPLATE/feature_request.yml": "name: Feature request",
-        });
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        const bugEntry = entries.find((entry) => entry.name === "bug-report");
-        const featureEntry = entries.find((entry) => entry.name === "feature-request");
-        expect(bugEntry).toBeDefined();
-        expect(bugEntry.installed).toBe(true);
-        expect(featureEntry).toBeDefined();
-        expect(featureEntry.installed).toBe(true);
-    });
-    it("marks the opencode.ci.json template as installed when the file exists at repository root", async () => {
-        const repositoryPath = await createRepository({
-            "opencode.ci.json": "{ \"model\": \"plainconcepts/glm-5-2\" }",
-        });
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        const opencodeEntry = entries.find((entry) => entry.name === "opencode.ci.json");
-        expect(opencodeEntry).toBeDefined();
-        expect(opencodeEntry.installed).toBe(true);
-    });
-    it("reports mixed installed and uninstalled entries", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agent-audit.md": "# Audit",
-            ".github/workflows/app-ci-dotnet-next.yml": "name: CI",
-            "opencode.ci.json": "{ \"model\": \"plainconcepts/glm-5-2\" }",
-        });
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        expect(entries.filter((entry) => entry.installed).map((entry) => entry.name))
-            .toEqual(expect.arrayContaining(["refine", "audit", "app-ci-dotnet-next", "opencode.ci.json"]));
-        expect(entries.filter((entry) => !entry.installed)).toHaveLength(workflowRoutes.length + catalogTemplates.length - 4);
-    });
-});
-describe("searchCatalog", () => {
-    const sampleEntries = [
-        { kind: "route", name: "refine", description: "Refines an issue into a user story.", file: "agent-refine.md", installed: false },
-        { kind: "route", name: "audit", description: "Read-only repository audit.", file: "agent-audit.md", installed: true },
-        { kind: "template", name: "app-ci-dotnet-next", description: "App CI pipeline for .NET + Next.js.", file: "app-ci-dotnet-next.yml", installed: false },
-    ];
-    it("filters by name match", () => {
-        const results = searchCatalog(sampleEntries, "audit");
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe("audit");
-    });
-    it("filters by description match", () => {
-        const results = searchCatalog(sampleEntries, "user story");
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe("refine");
-    });
-    it("is case-insensitive", () => {
-        const results = searchCatalog(sampleEntries, "AUDIT");
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe("audit");
-    });
-    it("returns empty array for no matches", () => {
-        const results = searchCatalog(sampleEntries, "nonexistent");
-        expect(results).toHaveLength(0);
-    });
-    it("returns empty array for empty query after trim", () => {
-        expect(searchCatalog(sampleEntries, "  ")).toHaveLength(0);
-    });
-    it("returns both routes and templates when the query matches both kinds", () => {
-        const entries = [
-            { kind: "route", name: "direct", description: "Executes a CI instruction.", file: "agent-direct.md", installed: false },
-            { kind: "template", name: "app-ci-dotnet-next", description: "App CI pipeline.", file: "app-ci-dotnet-next.yml", installed: true },
-        ];
-        const results = searchCatalog(entries, "CI");
-        expect(results).toHaveLength(2);
-    });
-});
-describe("formatCatalog", () => {
-    it("groups routes under Workflows and templates under Templates", () => {
-        const entries = [
-            { kind: "route", name: "refine", description: "Refines a story.", file: "agent-refine.md", installed: true },
-            { kind: "template", name: "app-ci-dotnet-next", description: "CI for .NET.", file: "app-ci-dotnet-next.yml", installed: false },
-        ];
-        const output = formatCatalog(entries);
-        expect(output).toContain("Workflows:");
-        expect(output).toContain("Templates:");
-        expect(output).toContain("[x] refine");
-        expect(output).toContain("[ ] app-ci-dotnet-next");
-    });
-    it("prints a no-match message for an empty result", () => {
-        expect(formatCatalog([])).toBe("No workflows matched the search query.");
-    });
-    it("prints only a Workflows section when no templates match", () => {
-        const entries = [
-            { kind: "route", name: "refine", description: "Refines.", file: "agent-refine.md", installed: false },
-        ];
-        const output = formatCatalog(entries);
-        expect(output).toContain("Workflows:");
-        expect(output).not.toContain("Templates:");
-    });
-});
-async function createRepository(files) {
-    const repositoryPath = await mkdtemp(join(tmpdir(), "workflows-"));
-    temporaryDirectories.push(repositoryPath);
-    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
-        const path = join(repositoryPath, relativePath);
-        const { mkdir } = await import("node:fs/promises");
-        await mkdir(join(path, ".."), { recursive: true });
-        await writeFile(path, content, "utf8");
-    }));
-    return repositoryPath;
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export declare function run(arguments_: readonly string[], repositoryPath?: string): Promise<number>;

package/dist/index.js

@@ -1,218 +0,0 @@
-#!/usr/bin/env node
-import { inspectRepository, parseVisibility, resolveVisibility } from "./repository-inspection.js";
-import { installCatalog, installedRoutes, installTemplate, isTemplateName, removeRouteFiles } from "./catalog-installation.js";
-import { formatCatalog, listCatalog, searchCatalog } from "./catalog-listing.js";
-import { routeNames, templateNames } from "./workflow-catalog.js";
-import { runInteractive } from "./tui.js";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-const HELP_TEXT = `Workflows CLI — install and manage Plain Concepts Platform agentic workflows.
-
-Run with no arguments to launch the interactive TUI, the primary way to select and install
-workflows and templates:
-
-  npx @plainconceptsplatform/workflows
-
-Advanced (non-interactive) commands:
-
-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 [routes] [--template <name>] [--force]  Install route workers, a template, or mandatory files.
-  remove <routes> [--force]                   Uninstall route workers and regenerate the router without them.
-  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, triage, 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.
-  remove propose                             Uninstalls the propose worker and drops it from the router.
-
-add and remove keep the router consistent with what is installed: add unions the requested
-routes with the routes already present, and remove drops the requested routes from that set.
-Both regenerate the router, classifier, and route matrix from the resulting set. Changing the
-route set rewrites the package-owned router, so pass --force to overwrite it.
-
-Options:
-  --visibility public|private                 Override repository visibility (init only).
-  --template <name>                           Install a standalone template alongside or instead of routes.
-                                              Templates: agentics-checks, agentics-maintenance,
-                                              app-ci-dotnet-next, app-ci-node-monorepo,
-                                              bug-report, feature-request, github-release,
-                                              opencode.ci.json.
-  --force                                     Overwrite managed files that differ from the package source.
-  -h, --help                                  Show this help text.
-
-Installed workflows are marked [x] when the corresponding .github/workflows/agent-*.md
-file exists relative to the current directory.`;
-export async function run(arguments_, repositoryPath = process.cwd()) {
-    const [command, ...options] = arguments_;
-    if (command === "--help" || command === "-h") {
-        console.log(HELP_TEXT);
-        return 0;
-    }
-    if (command === undefined) {
-        const force = options.includes("--force");
-        return runInteractive(repositoryPath, { force });
-    }
-    if (command === "list") {
-        const entries = await listCatalog({ installedPath: repositoryPath });
-        console.log(formatCatalog(entries));
-        return 0;
-    }
-    if (command === "search") {
-        if (options.length === 0 || options.length > 1)
-            return fail("search requires exactly one query argument.");
-        const allEntries = await listCatalog({ installedPath: repositoryPath });
-        const results = searchCatalog(allEntries, options[0]);
-        console.log(formatCatalog(results));
-        return 0;
-    }
-    if (command === "init") {
-        const visibility = readVisibilityOption(options);
-        if (visibility === "invalid")
-            return fail("--visibility must be public or private.");
-        const inspection = await inspectRepository(repositoryPath);
-        const resolvedVisibility = await resolveVisibility(repositoryPath, visibility);
-        console.log(JSON.stringify({ command, inspection, visibility: resolvedVisibility }, null, 2));
-        return 0;
-    }
-    if (command === "status") {
-        const inspection = await inspectRepository(repositoryPath);
-        console.log(JSON.stringify({ command, inspection }, null, 2));
-        return 0;
-    }
-    if (command === "add" || command === "update") {
-        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 selectedRoutes = unionRoutes(routes, await installedRoutes(repositoryPath));
-            const result = await installCatalog(repositoryPath, { force, selectedRoutes, 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, installed: allInstalled.sort(), conflicts: allConflicts }, null, 2));
-        return 0;
-    }
-    if (command === "remove") {
-        const parsed = parseAddOptions(options);
-        if (parsed.kind === "invalid")
-            return fail(parsed.message);
-        if (parsed.template !== undefined)
-            return fail("remove does not accept --template.");
-        if (parsed.routes.length === 0)
-            return fail("remove requires at least one route.");
-        const inspection = await inspectRepository(repositoryPath);
-        const installed = await installedRoutes(repositoryPath);
-        const desiredRoutes = installed.filter((route) => !parsed.routes.includes(route));
-        const result = await installCatalog(repositoryPath, { force: parsed.force, selectedRoutes: desiredRoutes, inspection });
-        if (result.conflicts.length > 0 && !parsed.force) {
-            console.error(`Catalog conflicts found. Re-run with --force to overwrite package-managed files:\n${result.conflicts.join("\n")}`);
-            return 1;
-        }
-        const removed = await removeRouteFiles(repositoryPath, parsed.routes);
-        console.log(JSON.stringify({ command, installed: [...result.installed].sort(), removed, conflicts: result.conflicts }, null, 2));
-        return 0;
-    }
-    return fail(`Unknown command: ${command}`);
-}
-function unionRoutes(requested, installed) {
-    const result = [...requested];
-    for (const route of installed) {
-        if (!result.includes(route))
-            result.push(route);
-    }
-    return result;
-}
-function readVisibilityOption(options) {
-    if (options.length === 0)
-        return undefined;
-    if (options.length !== 2 || options[0] !== "--visibility")
-        return "invalid";
-    return parseVisibility(options[1]) ?? "invalid";
-}
-const TEMPLATE_NAMES = templateNames.join("|");
-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 invalid(message) {
-    return { kind: "invalid", message };
-}
-function fail(message) {
-    console.error(message);
-    return 1;
-}
-if (process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-    void run(process.argv.slice(2)).then((exitCode) => {
-        process.exitCode = exitCode;
-    });
-}

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.js

@@ -1,273 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-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);
-        await expect(run(["--help"])).resolves.toBe(0);
-        expect(log).toHaveBeenCalledWith(expect.stringContaining("agentics-checks"));
-        expect(log).toHaveBeenCalledWith(expect.stringContaining("app-ci-dotnet-next"));
-        expect(log).toHaveBeenCalledWith(expect.stringContaining("opencode.ci.json"));
-        log.mockRestore();
-    });
-    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, triage, 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("--template must be one of: agentics-checks|agentics-maintenance|app-ci-dotnet-next|app-ci-node-monorepo|bug-report|feature-request|github-release|opencode.ci.json|visual-evidence.");
-        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, triage, 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 () => {
-        const repositoryPath = await createRepository({});
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["list"], repositoryPath)).resolves.toBe(0);
-        expect(log).toHaveBeenCalledTimes(1);
-        const output = log.mock.calls[0][0];
-        expect(output).toContain("Workflows:");
-        expect(output).toContain("Templates:");
-        expect(output).toContain("refine");
-        expect(output).toContain("implement");
-        expect(output).toContain("agentics-checks");
-        expect(output).toContain("app-ci-dotnet-next");
-        expect(output).toContain("github-release");
-        // None installed: all [ ]
-        const installedCount = (output.match(/\[x\]/g) ?? []).length;
-        expect(installedCount).toBe(0);
-        // 8 routes + 9 templates = 17 entries
-        const uninstalledCount = (output.match(/\[ \]/g) ?? []).length;
-        expect(uninstalledCount).toBe(17);
-        log.mockRestore();
-    });
-    it("marks installed workflows with [x]", async () => {
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agentics-checks.yml": "name: Agentics checks",
-        });
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["list"], repositoryPath)).resolves.toBe(0);
-        const output = log.mock.calls[0][0];
-        const installed = output.match(/(\[x\])/g) ?? [];
-        expect(installed.length).toBe(2);
-        // refine and agentics-checks should be [x]
-        const refineLines = output.split("\n").filter((line) => line.includes("refine") || line.includes("agentics-checks"));
-        expect(refineLines.filter((line) => line.includes("[x]"))).toHaveLength(2);
-        log.mockRestore();
-    });
-    it("search filters by name", async () => {
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["search", "audit"])).resolves.toBe(0);
-        const output = log.mock.calls[0][0];
-        expect(output).toContain("audit");
-        expect(output).not.toContain("Templates:");
-        // Only the audit route should be returned — no other route name should appear.
-        const visibleRoutes = ["refine", "implement", "direct", "triage", "apply-review", "merge-gate", "propose"];
-        for (const route of visibleRoutes) {
-            expect(output).not.toContain(`${route} —`);
-        }
-        log.mockRestore();
-    });
-    it("search filters by description keyword", async () => {
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["search", "CI"])).resolves.toBe(0);
-        const output = log.mock.calls[0][0];
-        expect(output).toContain("dotnet-next");
-        expect(output).toContain("node-monorepo");
-        expect(output).not.toContain("refine —");
-        log.mockRestore();
-    });
-    it("search with no matches prints a no-match message", async () => {
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["search", "nonexistent"])).resolves.toBe(0);
-        const output = log.mock.calls[0][0];
-        expect(output).toBe("No workflows matched the search query.");
-        log.mockRestore();
-    });
-    it("search with no query fails", async () => {
-        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        await expect(run(["search"])).resolves.toBe(1);
-        expect(error).toHaveBeenCalledWith("search requires exactly one query argument.");
-        error.mockRestore();
-    });
-    it("search with too many arguments fails", async () => {
-        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        await expect(run(["search", "a", "b"])).resolves.toBe(1);
-        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();
-    });
-    it("add unions requested routes with already-installed routes", async () => {
-        const { installCatalog } = mockInstallers();
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agent-implement.md": "# Implement",
-        });
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["add", "direct"], repositoryPath)).resolves.toBe(0);
-        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ selectedRoutes: ["direct", "refine", "implement"] }));
-        log.mockRestore();
-    });
-    it("remove requires at least one route", async () => {
-        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        await expect(run(["remove"])).resolves.toBe(1);
-        expect(error).toHaveBeenCalledWith("remove requires at least one route.");
-        error.mockRestore();
-    });
-    it("remove rejects the --template flag", async () => {
-        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        await expect(run(["remove", "--template", "agentics-checks"])).resolves.toBe(1);
-        expect(error).toHaveBeenCalledWith("remove does not accept --template.");
-        error.mockRestore();
-    });
-    it("remove regenerates the router for the remaining routes and deletes the worker", async () => {
-        const { installCatalog } = mockInstallers();
-        const repositoryPath = await createRepository({
-            ".github/workflows/agent-refine.md": "# Refine",
-            ".github/workflows/agent-refine.lock.yml": "generated",
-            ".github/workflows/agent-implement.md": "# Implement",
-        });
-        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
-        await expect(run(["remove", "refine", "--force"], repositoryPath)).resolves.toBe(0);
-        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ force: true, selectedRoutes: ["implement"] }));
-        const { access } = await import("node:fs/promises");
-        const { constants } = await import("node:fs");
-        await expect(access(join(repositoryPath, ".github/workflows/agent-refine.md"), constants.F_OK)).rejects.toThrow();
-        await expect(access(join(repositoryPath, ".github/workflows/agent-refine.lock.yml"), constants.F_OK)).rejects.toThrow();
-        await expect(access(join(repositoryPath, ".github/workflows/agent-implement.md"), constants.F_OK)).resolves.toBeUndefined();
-        log.mockRestore();
-    });
-});
-async function createRepository(files) {
-    const repositoryPath = await mkdtemp(join(tmpdir(), "workflows-"));
-    temporaryDirectories.push(repositoryPath);
-    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
-        const path = join(repositoryPath, relativePath);
-        const { mkdir } = await import("node:fs/promises");
-        await mkdir(join(path, ".."), { recursive: true });
-        await writeFile(path, content, "utf8");
-    }));
-    return repositoryPath;
-}