@plainconceptsplatform/workflows 0.3.0 → 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.js

@@ -156,7 +156,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

@@ -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,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.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.test.js

@@ -246,6 +246,25 @@ 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).not.toContain("readonly PROPOSE_CRON");
+        expect(classifier).not.toContain("readonly AUDIT_CRON");
+        const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
+        expect(matrix).toContain("excluded route 'propose'");
+        expect(matrix).toContain("excluded route 'refine'");
+    });
     it("strips propose from all three files when unselected", () => {
         const files = new Map([
             [".github/workflows/work-router.yml", ROUTER_YAML],
@@ -307,4 +326,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/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/package.json

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