@plainconceptsplatform/workflows 0.3.0 → 0.4.0

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.js

@@ -133,10 +133,13 @@ export function isTemplateName(value) {
 }
 export async function ensurePreCommitHook(repositoryPath) {
     const hookPath = join(repositoryPath, ".husky", "pre-commit");
-    if (!await exists(hookPath))
+    const compileLine = "node scripts/compile-agent-workflows.mjs";
+    if (!await exists(hookPath)) {
+        await mkdir(dirname(hookPath), { recursive: true });
+        await writeFile(hookPath, `${compileLine}\n`, "utf8");
         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 === ""
@@ -156,7 +159,9 @@ function catalogTemplateMeta(template) {
         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) {

package/dist/catalog-installation.test.js

@@ -2,7 +2,7 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { catalogSourcePath, installCatalog, installMandatoryFiles, installTemplate } from "./catalog-installation.js";
+import { catalogSourcePath, ensurePreCommitHook, installCatalog, installMandatoryFiles, installTemplate } from "./catalog-installation.js";
 const temporaryDirectories = [];
 afterEach(async () => {
     await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
@@ -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",
@@ -215,6 +243,19 @@ describe("catalog installation", () => {
         const compileEntries = result.installed.filter((path) => path === "scripts/compile-agent-workflows.mjs");
         expect(compileEntries).toHaveLength(1);
     });
+    it("creates a Husky pre-commit hook when the consumer has none", async () => {
+        const repositoryPath = await createDirectory({});
+        await ensurePreCommitHook(repositoryPath);
+        await expect(readFile(join(repositoryPath, ".husky", "pre-commit"), "utf8"))
+            .resolves.toBe("node scripts/compile-agent-workflows.mjs\n");
+    });
+    it("keeps existing pre-commit commands and appends the compiler once", async () => {
+        const repositoryPath = await createDirectory({ ".husky/pre-commit": "pnpm lint\n" });
+        await ensurePreCommitHook(repositoryPath);
+        await ensurePreCommitHook(repositoryPath);
+        await expect(readFile(join(repositoryPath, ".husky", "pre-commit"), "utf8"))
+            .resolves.toBe("pnpm lint\nnode scripts/compile-agent-workflows.mjs\n");
+    });
     it("installs the opencode.ci.json template to the repository root", async () => {
         const sourcePath = await createDirectory({
             "templates/opencode/opencode.ci.json": "{ \"model\": \"plainconcepts/glm-5-2\" }\n",
@@ -226,6 +267,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,19 +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 parsed = parseAddOptions(options);
+        if (parsed.kind === "invalid")
+            return fail(parsed.message);
         const inspection = await inspectRepository(repositoryPath);
-        const result = template === undefined
-            ? await installCatalog(repositoryPath, { force, inspection })
-            : await installTemplate(repositoryPath, template, { force, inspection });
-        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 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}`);
@@ -98,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.js

@@ -46,11 +46,33 @@ export function parseVisibility(value) {
     return value === "public" || value === "private" ? value : undefined;
 }
 async function findSolutionFiles(repositoryPath) {
-    const entries = await readdir(repositoryPath, { recursive: true, withFileTypes: true });
-    return entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(".slnx"))
-        .map((entry) => entry.parentPath === undefined ? entry.name : join(entry.parentPath, entry.name))
-        .sort();
+    const results = [];
+    await scanForSlnx(repositoryPath, "", results, 0);
+    return results.sort();
+}
+const MAX_DEPTH = 5;
+const SKIP_DIRS = new Set(["node_modules", ".git", ".next", "dist", "out", "build", ".turbo", ".cache"]);
+async function scanForSlnx(root, relativePath, results, depth) {
+    if (depth >= MAX_DEPTH)
+        return;
+    const currentPath = join(root, relativePath);
+    let entries;
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            await scanForSlnx(root, join(relativePath, entry.name), results, depth + 1);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".slnx")) {
+            results.push(relativePath === "" ? entry.name : join(relativePath, entry.name));
+        }
+    }
 }
 async function pathExists(path) {
     try {

package/dist/repository-inspection.test.js

@@ -24,7 +24,7 @@ describe("repository inspection", () => {
             stackHints: {
                 packageJson: true,
                 pnpmLockfile: true,
-                solutionFiles: [join(repositoryPath, "apps", "api", "Numa.slnx")],
+                solutionFiles: [join("apps", "api", "Numa.slnx")],
                 openSpec: true,
             },
         });
@@ -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.js

@@ -72,17 +72,46 @@ export function processRoutes(files, selectedRoutes) {
         if (routerKey !== undefined) {
             result.set(routerKey, stripRouteFromRouter(result.get(routerKey), route));
         }
-        const classifierKey = findFileKey(result, "classify-route.sh");
-        if (classifierKey !== undefined) {
-            result.set(classifierKey, stripRouteFromClassifier(result.get(classifierKey), route));
-        }
         const matrixKey = findFileKey(result, "verify-route-matrix.sh");
         if (matrixKey !== undefined) {
             result.set(matrixKey, addRouteExclusion(result.get(matrixKey), route));
         }
     }
+    const matrixKey = findFileKey(result, "verify-route-matrix.sh");
+    if (matrixKey !== undefined) {
+        result.set(matrixKey, createRouteMatrix(selectedRoutes));
+    }
     return result;
 }
+function createRouteMatrix(selectedRoutes) {
+    const selected = selectedRoutes.join(" ");
+    const excluded = routeNames.filter((route) => !selectedRoutes.includes(route)).join(" ");
+    return `#!/usr/bin/env bash
+set -euo pipefail
+
+HERE="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+ROUTER_YML="\${HERE}/../../workflows/work-router.yml"
+CLASSIFIER="\${HERE}/../classify-route/classify-route.sh"
+
+bash -n "$CLASSIFIER"
+
+for route in ${selected}; do
+  grep -q "route == '$route'" "$ROUTER_YML" || {
+    echo "FAIL: selected route '$route' has no router job" >&2
+    exit 1
+  }
+done
+
+for route in ${excluded}; do
+  if grep -q "route == '$route'" "$ROUTER_YML"; then
+    echo "FAIL: excluded route '$route' remains in router" >&2
+    exit 1
+  fi
+done
+
+echo "Route matrix: selected routes valid"
+`;
+}
 export function excludedWorkerFiles(selectedRoutes) {
     return new Set(workflowRoutes
         .filter((route) => !selectedRoutes.includes(route.name))

package/dist/route-processing.test.js

@@ -246,6 +246,24 @@ describe("processRoutes", () => {
         const result = processRoutes(files, [...routeNames]);
         expect(result).toBe(files);
     });
+    it("strips every worker route when no routes are selected", () => {
+        const files = new Map([
+            [".github/workflows/work-router.yml", ROUTER_YAML],
+            [".github/actions/classify-route/classify-route.sh", CLASSIFIER_SH],
+            [".github/actions/verify-route-matrix/verify-route-matrix.sh", MATRIX_SH],
+        ]);
+        const result = processRoutes(files, []);
+        const router = result.get(".github/workflows/work-router.yml");
+        expect(router).not.toContain("call-propose");
+        expect(router).not.toContain("call-audit");
+        expect(router).not.toContain("- propose");
+        expect(router).not.toContain("- refine");
+        const classifier = result.get(".github/actions/classify-route/classify-route.sh");
+        expect(classifier).toBe(CLASSIFIER_SH);
+        const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
+        expect(matrix).toContain("Route matrix: selected routes valid");
+        expect(matrix).toContain("for route in refine implement direct apply-review merge-gate audit propose");
+    });
     it("strips propose from all three files when unselected", () => {
         const files = new Map([
             [".github/workflows/work-router.yml", ROUTER_YAML],
@@ -259,10 +277,10 @@ describe("processRoutes", () => {
         expect(router).not.toContain('cron: "29 7 * * *"');
         expect(router).not.toMatch(/^\s+- propose$/m);
         const classifier = result.get(".github/actions/classify-route/classify-route.sh");
-        expect(classifier).not.toContain("readonly PROPOSE_CRON");
-        expect(classifier).not.toContain('"$PROPOSE_CRON")');
+        expect(classifier).toBe(CLASSIFIER_SH);
         const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
-        expect(matrix).toContain("excluded route 'propose'");
+        expect(matrix).toContain("for route in refine implement direct apply-review merge-gate audit");
+        expect(matrix).toContain("for route in propose");
     });
     it("strips audit from all three files when unselected", () => {
         const files = new Map([
@@ -276,8 +294,7 @@ describe("processRoutes", () => {
         expect(router).not.toContain("call-audit");
         expect(router).not.toContain('cron: "17 1 * * 1"');
         const classifier = result.get("classify-route.sh");
-        expect(classifier).not.toContain("readonly AUDIT_CRON");
-        expect(classifier).not.toContain('"$AUDIT_CRON")');
+        expect(classifier).toBe(CLASSIFIER_SH);
     });
     it("processes multiple excluded routes at once", () => {
         const files = new Map([
@@ -307,4 +324,15 @@ describe("excludedWorkerFiles", () => {
         const excluded = excludedWorkerFiles([...routeNames]);
         expect(excluded.size).toBe(0);
     });
+    it("returns all worker files when no routes are selected", () => {
+        const excluded = excludedWorkerFiles([]);
+        expect(excluded.size).toBe(7);
+        expect(excluded.has("agent-refine.md")).toBe(true);
+        expect(excluded.has("agent-implement.md")).toBe(true);
+        expect(excluded.has("agent-direct.md")).toBe(true);
+        expect(excluded.has("agent-apply-review.md")).toBe(true);
+        expect(excluded.has("agent-merge-gate.md")).toBe(true);
+        expect(excluded.has("agent-audit.md")).toBe(true);
+        expect(excluded.has("agent-propose.md")).toBe(true);
+    });
 });

package/dist/stack-defaults.js

@@ -20,8 +20,6 @@ export function generateStackDefaults(inspection) {
 }
 export function injectStackEnv(content, defaults) {
     let result = content;
-    if (defaults.verifyCommands === "pnpm verify")
-        return result;
     if (result.includes("VERIFY_COMMANDS:")) {
         result = result.replace(/  VERIFY_COMMANDS: ".*"/, `  VERIFY_COMMANDS: "${defaults.verifyCommands}"`);
     }
@@ -33,6 +31,7 @@ export function injectStackEnv(content, defaults) {
 export function generateOpencodeCi(baseContent, inspection) {
     let result = baseContent;
     if (inspection.stackHints.solutionFiles.length > 0) {
+        const solutionPath = inspection.stackHints.solutionFiles[0];
         const nugetSteps = `  - name: Cache NuGet packages
     uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
     with:
@@ -40,8 +39,8 @@ export function generateOpencodeCi(baseContent, inspection) {
       key: nuget-\${{ runner.os }}-\${{ hashFiles('**/*.slnx', '**/Directory.Packages.props') }}
       restore-keys: nuget-\${{ runner.os }}-
 
-  - name: Restore .NET dependencies
-    run: dotnet restore
+   - name: Restore .NET dependencies
+    run: dotnet restore ${solutionPath}
 `;
         result = insertBeforeMarker(result, nugetSteps, "  - name: Install workspace dependencies");
     }
@@ -49,7 +48,7 @@ export function generateOpencodeCi(baseContent, inspection) {
         const openspecStep = `  - name: Install OpenSpec CLI
     run: |
       set -euo pipefail
-      npm install -g @openspec/cli@latest
+      npm install -g "@fission-ai/openspec@1.8.0"
       openspec --version
 `;
         result = insertBeforeMarker(result, openspecStep, "  - name: Install workspace dependencies");

package/dist/stack-defaults.test.js

@@ -76,7 +76,7 @@ description: test
         const result = injectStackEnv(content, defaults);
         expect(result).toContain('VERIFY_COMMANDS: "dotnet restore && dotnet build -c Release --no-restore && dotnet test"');
     });
-    it("does not inject when verifyCommands is pnpm verify (the default)", () => {
+    it("injects pnpm verification when no .slnx is present", () => {
         const content = `---
 env:
   REPO_RULES: "some rules"
@@ -85,7 +85,7 @@ env:
             pnpmLockfile: true,
         }));
         const result = injectStackEnv(content, defaults);
-        expect(result).not.toContain("VERIFY_COMMANDS");
+        expect(result).toContain('VERIFY_COMMANDS: "pnpm verify"');
     });
 });
 const OPENCODE_CI_MD = `---
@@ -113,20 +113,20 @@ pre-agent-steps:
       jq -e . "$FRAGMENT" > /dev/null
 ---`;
 describe("generateOpencodeCi", () => {
-    it("adds NuGet cache and dotnet restore steps when .slnx is found", () => {
+    it("adds NuGet cache and restores detected solution when .slnx is found", () => {
         const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
-            solutionFiles: ["app.slnx"],
+            solutionFiles: ["apps/api/Numa.slnx"],
         }));
         expect(result).toContain("Cache NuGet packages");
         expect(result).toContain("Restore .NET dependencies");
-        expect(result).toContain("dotnet restore");
+        expect(result).toContain("dotnet restore apps/api/Numa.slnx");
     });
-    it("adds OpenSpec CLI install step when openspec/ directory exists", () => {
+    it("adds the pinned OpenSpec CLI install step when openspec/ directory exists", () => {
         const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({
             openSpec: true,
         }));
         expect(result).toContain("Install OpenSpec CLI");
-        expect(result).toContain("@openspec/cli");
+        expect(result).toContain("@fission-ai/openspec@1.8.0");
     });
     it("adds both NuGet and OpenSpec steps when both are detected", () => {
         const result = generateOpencodeCi(OPENCODE_CI_MD, makeInspection({

package/loops/scripts/compile-agent-workflows.mjs

@@ -1,6 +1,7 @@
 // Managed by @plainconceptsplatform/workflows. Source: loops/scripts/compile-agent-workflows.mjs. Update with `workflows update --force`; consumer edits may be overwritten.
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 
 const workflowDirectory = existsSync("loops/workflows") ? "loops/workflows" : ".github/workflows";
 
@@ -21,9 +22,22 @@ const compile = spawnSync(resolveGhPath(), ["aw", "compile", "--strict", "--dir"
   shell: false,
 });
 
-if (compile.error?.code === "ENOENT" || compile.status === null) {
+if (compile.error?.code === "ENOENT" || compile.status === null) {
   process.stderr.write("Could not run `gh aw compile`. Install githubnext/gh-aw first.\n");
   process.exit(1);
-}
-
-process.exit(compile.status ?? 1);
+}
+
+if (compile.status !== 0) process.exit(compile.status ?? 1);
+
+for (const file of readdirSync(workflowDirectory)) {
+  if (!file.endsWith(".lock.yml")) continue;
+
+  const path = join(workflowDirectory, file);
+  const content = readFileSync(path, "utf8");
+  const patched = content
+    .replaceAll("opencode run --print-logs --log-level DEBUG", "opencode run --log-level ERROR")
+    .replaceAll("opencode run --print-logs --log-level ERROR", "opencode run --log-level ERROR")
+    .replaceAll("--log-level DEBUG", "--log-level ERROR");
+
+  if (patched !== content) writeFileSync(path, patched);
+}

package/loops/templates/ci/app-ci-dotnet-next.yml

@@ -1,11 +1,15 @@
 # Managed by @plainconceptsplatform/workflows. Source: loops/templates/ci/app-ci-dotnet-next.yml. Update with `workflows update --force`; consumer edits may be overwritten.
-name: "App: CI (.NET + Next.js)"
+name: "App: CI"
 
 on:
   pull_request:
   schedule:
     - cron: "0 6 * * 1"
   workflow_dispatch:
+  workflow_call:
+    secrets:
+      NPM_REGISTRY_TOKEN:
+        required: false
 
 env:
   DOTNET_VERSION: "10.0.x"

package/loops/templates/opencode/opencode.ci.json

@@ -13,7 +13,8 @@
   "permission": {
     "read": "allow",
     "external_directory": {
-      "/tmp/**": "allow"
+      "/tmp/**": "allow",
+      "/home/runner/work/_temp/gh-aw/**": "allow"
     }
   },
   "lsp": {

package/loops/workflows/shared/platform-defaults.md

@@ -8,6 +8,8 @@ network:
     - forge.plainconcepts.com
     - node
     - github
+    - dotnet
+    - fonts
 
 safe-outputs:
   threat-detection: false

package/loops/workflows/work-router.yml

@@ -39,7 +39,7 @@ on:
   pull_request_target:
     types: [opened, synchronize, reopened]
   workflow_run:
-    workflows: ["App: CI"]
+    workflows: ["App: CI", "CI"]
     types: [completed]
     branches:
       - "fix/*"
@@ -142,7 +142,10 @@ jobs:
               ;;
           esac
 
-          if [ "$ACTOR" = "github-actions[bot]" ]; then
+          # Platform bot owns Safe Outputs. Its label changes must be able to
+          # start the follow-on worker, even though GitHub does not report it
+          # as a repository collaborator.
+          if [ "$ACTOR" = "github-actions[bot]" ] || [ "$ACTOR" = "platform-devbox[bot]" ]; then
             echo "trusted=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",