@plainconceptsplatform/workflows 0.2.1 → 0.3.2

package/dist/route-processing.js

@@ -0,0 +1,121 @@
+import { routeNames, workflowRoutes } from "./workflow-catalog.js";
+const routeCrons = {
+    audit: "17 1 * * 1",
+    propose: "29 7 * * *",
+};
+export function stripRouteFromRouter(yaml, route) {
+    let result = yaml;
+    const cron = routeCrons[route];
+    if (cron !== undefined) {
+        result = result.replace(new RegExp(`^    - cron: "${escapeRegex(cron)}"\\n`, "gm"), "");
+    }
+    result = removeJobBlock(result, `call-${route}`);
+    result = result.replace(new RegExp(`^          - ${escapeRegex(route)}\\n`, "gm"), "");
+    return result;
+}
+export function stripRouteFromClassifier(shell, route) {
+    const constName = route.replace(/-/g, "_").toUpperCase() + "_CRON";
+    let result = shell;
+    result = result.replace(new RegExp(`^readonly ${constName}="[^"]*"\\n`, "gm"), "");
+    const cron = routeCrons[route];
+    if (cron !== undefined) {
+        result = result.replace(new RegExp(`\\s*"\\$${constName}"\\) route="${escapeRegex(route)}" ;;\\n`, "g"), "");
+    }
+    result = result.replace(new RegExp(` \\| ${escapeRegex(route)}\\)`, "g"), ")");
+    result = result.replace(new RegExp(`^(\\s+)${escapeRegex(route)} \\| `, "gm"), "$1");
+    if (!result.includes(`| ${route}`) && !result.includes(`${route} |`)) {
+        result = removeAloneDispatchCase(result, route);
+    }
+    return result;
+}
+function removeAloneDispatchCase(shell, route) {
+    const lines = shell.split("\n");
+    const pattern = new RegExp(`^(\\s+)${escapeRegex(route)}\\)\\s*$`);
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const match = lines[i].match(pattern);
+        if (match) {
+            const indent = match[1];
+            i++;
+            while (i < lines.length) {
+                if (new RegExp(`^${escapeRegex(indent)};;\\s*$`).test(lines[i])) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+        }
+        else {
+            result.push(lines[i]);
+            i++;
+        }
+    }
+    return result.join("\n");
+}
+export function addRouteExclusion(matrix, route) {
+    if (matrix.includes(`excluded route '${route}'`))
+        return matrix;
+    let result = matrix;
+    result = result.replace(new RegExp(` ${escapeRegex(route)} `, "g"), " ");
+    const exclusionBlock = `\necho "── Excluded routes ──────────────────────────────────────────────────────"\nif ! grep -q "route == '${route}'" "$ROUTER_YML"; then\n  PASS=$((PASS + 1))\n  echo "  ${route} correctly excluded from work-router.yml"\nelse\n  FAIL=$((FAIL + 1))\n  echo "FAIL: excluded route '${route}' is still in work-router.yml" >&2\nfi\n`;
+    result = result.replace(/(\necho\nif \[ "\$FAIL" -eq 0 \])/, `${exclusionBlock}$1`);
+    return result;
+}
+export function processRoutes(files, selectedRoutes) {
+    const excludedRoutes = routeNames.filter((r) => !selectedRoutes.includes(r));
+    if (excludedRoutes.length === 0)
+        return files;
+    const result = new Map(files);
+    for (const route of excludedRoutes) {
+        const routerKey = findFileKey(result, "work-router.yml");
+        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));
+        }
+    }
+    return result;
+}
+export function excludedWorkerFiles(selectedRoutes) {
+    return new Set(workflowRoutes
+        .filter((route) => !selectedRoutes.includes(route.name))
+        .map((route) => route.worker));
+}
+function removeJobBlock(yaml, jobName) {
+    const lines = yaml.split("\n");
+    const startPattern = new RegExp(`^  ${escapeRegex(jobName)}:`);
+    const result = [];
+    let skipping = false;
+    for (const line of lines) {
+        if (skipping) {
+            if (/^  \S/.test(line) || /^[^\s]/.test(line)) {
+                skipping = false;
+                result.push(line);
+            }
+        }
+        else if (startPattern.test(line)) {
+            skipping = true;
+        }
+        else {
+            result.push(line);
+        }
+    }
+    return result.join("\n");
+}
+function findFileKey(files, endsWith) {
+    for (const key of files.keys()) {
+        if (key.endsWith(endsWith))
+            return key;
+    }
+    return undefined;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/route-processing.test.d.ts

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

package/dist/route-processing.test.js

@@ -0,0 +1,340 @@
+import { describe, expect, it } from "vitest";
+import { addRouteExclusion, excludedWorkerFiles, processRoutes, stripRouteFromClassifier, stripRouteFromRouter, } from "./route-processing.js";
+import { routeNames } from "./workflow-catalog.js";
+const ROUTER_YAML = `# header
+name: "All Work Router"
+
+on:
+  schedule:
+    - cron: "17 1 * * 1"
+    - cron: "43 3 * * *"
+    - cron: "0 6 * * *"
+    - cron: "0 */2 * * *"
+    - cron: "29 7 * * *"
+
+  workflow_dispatch:
+    inputs:
+      operation:
+        description: "Operation to run"
+        required: true
+        type: choice
+        options:
+          - refine
+          - implement
+          - direct
+          - apply-review
+          - merge-gate
+          - audit
+          - propose
+          - audit-close
+          - cleanup-artifacts
+          - stale-recovery
+          - validate
+
+jobs:
+  call-refine:
+    needs: [classify, authorize]
+    if: needs.classify.outputs.route == 'refine' && needs.authorize.outputs.trusted == 'true'
+    uses: ./.github/workflows/agent-refine.lock.yml
+    secrets:
+      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+
+  call-implement:
+    needs: [classify, authorize]
+    if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true'
+    uses: ./.github/workflows/agent-implement.lock.yml
+    secrets:
+      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+
+  call-audit:
+    needs: classify
+    if: needs.classify.outputs.route == 'audit'
+    uses: ./.github/workflows/agent-audit.lock.yml
+    secrets:
+      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+
+  call-propose:
+    needs: classify
+    if: needs.classify.outputs.route == 'propose'
+    uses: ./.github/workflows/agent-propose.lock.yml
+    secrets:
+      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+
+  audit-close:
+    needs: classify
+    if: needs.classify.outputs.route == 'audit-close'
+    runs-on: ubuntu-latest
+`;
+const CLASSIFIER_SH = `#!/usr/bin/env bash
+set -euo pipefail
+
+readonly AUDIT_CRON="17 1 * * 1"
+readonly AUDIT_CLOSE_CRON="43 3 * * *"
+readonly CLEANUP_ARTIFACTS_CRON="0 6 * * *"
+readonly STALE_RECOVERY_CRON="0 */2 * * *"
+readonly PROPOSE_CRON="29 7 * * *"
+
+classify_route() {
+  local route="none" error=""
+
+  case "\${EVENT:-}" in
+    schedule)
+      trigger_kind="scheduled"
+      case "\${SCHEDULE:-}" in
+        "\$AUDIT_CRON") route="audit" ;;
+        "\$AUDIT_CLOSE_CRON") route="audit-close" ;;
+        "\$CLEANUP_ARTIFACTS_CRON") route="cleanup-artifacts" ;;
+        "\$STALE_RECOVERY_CRON") route="stale-recovery" ;;
+        "\$PROPOSE_CRON") route="propose" ;;
+        *) error="no route for cron '\${SCHEDULE:-}'" ;;
+      esac
+      ;;
+
+    workflow_dispatch)
+      trigger_kind="manual"
+      case "\${OPERATION:-}" in
+        refine | implement | direct)
+          route="\${OPERATION}"
+          ;;
+        apply-review)
+          route="apply-review"
+          ;;
+        merge-gate)
+          route="merge-gate"
+          ;;
+        audit | propose)
+          route="\${OPERATION}"
+          trigger_kind="\${INPUT_TRIGGER_KIND:-manual}"
+          ;;
+        audit-close | cleanup-artifacts | stale-recovery | validate)
+          route="\${OPERATION}"
+          ;;
+        *)
+          error="unknown operation '\${OPERATION:-}'"
+          ;;
+      esac
+      ;;
+  esac
+
+  cat <<EOF
+route=\${route}
+error=\${error}
+EOF
+}
+
+if [ "\${BASH_SOURCE[0]}" = "\$0" ]; then
+  classify_route
+fi
+`;
+const MATRIX_SH = `#!/usr/bin/env bash
+set -euo pipefail
+
+echo "── Router wiring ─────────────────────────────────────────────────────────"
+for route in refine implement direct apply-review merge-gate audit propose bot-approve \\
+  audit-close cleanup-artifacts stale-recovery validate; do
+  if grep -q "route == '\${route}'" "\$ROUTER_YML"; then
+    PASS=\$((PASS + 1))
+  else
+    FAIL=\$((FAIL + 1))
+    echo "FAIL: work-router.yml has no job for route '\${route}'" >&2
+  fi
+done
+
+while read -r operation; do
+  if grep -q "route == '\${operation}'" "\$ROUTER_YML"; then
+    PASS=\$((PASS + 1))
+  else
+    FAIL=\$((FAIL + 1))
+    echo "FAIL: dispatch operation '\${operation}' has no job in work-router.yml" >&2
+  fi
+done < <(sed -n '/^      operation:/,/^      issue-number:/p' "\$ROUTER_YML" | sed -n 's/^          - //p')
+
+echo
+if [ "\$FAIL" -eq 0 ]; then
+  echo "Route matrix: \${PASS} passed"
+else
+  echo "Route matrix: \${PASS} passed, \${FAIL} FAILED" >&2
+fi
+
+exit \$((FAIL > 0))
+`;
+describe("stripRouteFromRouter", () => {
+    it("removes the propose cron entry", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
+        expect(result).not.toContain('cron: "29 7 * * *"');
+        expect(result).toContain('cron: "17 1 * * 1"');
+    });
+    it("removes the call-propose job block", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
+        expect(result).not.toContain("call-propose");
+        expect(result).toContain("call-refine");
+        expect(result).toContain("call-audit");
+    });
+    it("removes propose from the dispatch options", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "propose");
+        expect(result).not.toMatch(/^\s+- propose$/m);
+        expect(result).toMatch(/^\s+- refine$/m);
+        expect(result).toMatch(/^\s+- audit$/m);
+    });
+    it("removes the audit cron entry", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
+        expect(result).not.toContain('cron: "17 1 * * 1"');
+        expect(result).toContain('cron: "29 7 * * *"');
+    });
+    it("removes the call-audit job block", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
+        expect(result).not.toContain("call-audit");
+        expect(result).toContain("call-refine");
+    });
+    it("preserves the audit-close job when removing audit", () => {
+        const result = stripRouteFromRouter(ROUTER_YAML, "audit");
+        expect(result).toContain("audit-close");
+    });
+    it("does not modify the yaml when stripping a route that has no cron", () => {
+        const yamlWithoutCron = ROUTER_YAML.replace(/    - cron: "17 1 \* \* 1"\n/, "");
+        const result = stripRouteFromRouter(yamlWithoutCron, "audit");
+        expect(result).not.toContain("call-audit");
+    });
+});
+describe("stripRouteFromClassifier", () => {
+    it("removes the PROPOSE_CRON constant", () => {
+        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
+        expect(result).not.toContain('readonly PROPOSE_CRON');
+        expect(result).toContain('readonly AUDIT_CRON');
+    });
+    it("removes the propose schedule case", () => {
+        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
+        expect(result).not.toContain('"$PROPOSE_CRON") route="propose"');
+        expect(result).toContain('"$AUDIT_CRON") route="audit"');
+    });
+    it("removes the AUDIT_CRON constant", () => {
+        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
+        expect(result).not.toContain('readonly AUDIT_CRON');
+        expect(result).toContain('readonly PROPOSE_CRON');
+    });
+    it("removes the audit schedule case", () => {
+        const result = stripRouteFromClassifier(CLASSIFIER_SH, "audit");
+        expect(result).not.toContain('"$AUDIT_CRON") route="audit"');
+        expect(result).toContain('"$PROPOSE_CRON") route="propose"');
+    });
+    it("removes propose from the dispatch case union", () => {
+        const result = stripRouteFromClassifier(CLASSIFIER_SH, "propose");
+        expect(result).not.toContain("audit | propose)");
+        expect(result).toContain("audit)");
+    });
+});
+describe("addRouteExclusion", () => {
+    it("adds an exclusion assertion for the route", () => {
+        const result = addRouteExclusion(MATRIX_SH, "propose");
+        expect(result).toContain("excluded route 'propose'");
+        expect(result).toContain("propose correctly excluded from work-router.yml");
+    });
+    it("does not add the exclusion twice", () => {
+        const once = addRouteExclusion(MATRIX_SH, "propose");
+        const twice = addRouteExclusion(once, "propose");
+        const matchCount = (twice.match(/excluded route 'propose'/g) ?? []).length;
+        expect(matchCount).toBe(1);
+    });
+});
+describe("processRoutes", () => {
+    it("returns the same map when all routes are selected", () => {
+        const files = new Map([
+            ["work-router.yml", ROUTER_YAML],
+            ["classify-route.sh", CLASSIFIER_SH],
+            ["verify-route-matrix.sh", MATRIX_SH],
+        ]);
+        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],
+            [".github/actions/classify-route/classify-route.sh", CLASSIFIER_SH],
+            [".github/actions/verify-route-matrix/verify-route-matrix.sh", MATRIX_SH],
+        ]);
+        const selectedRoutes = routeNames.filter((r) => r !== "propose");
+        const result = processRoutes(files, selectedRoutes);
+        const router = result.get(".github/workflows/work-router.yml");
+        expect(router).not.toContain("call-propose");
+        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")');
+        const matrix = result.get(".github/actions/verify-route-matrix/verify-route-matrix.sh");
+        expect(matrix).toContain("excluded route 'propose'");
+    });
+    it("strips audit from all three files when unselected", () => {
+        const files = new Map([
+            ["work-router.yml", ROUTER_YAML],
+            ["classify-route.sh", CLASSIFIER_SH],
+            ["verify-route-matrix.sh", MATRIX_SH],
+        ]);
+        const selectedRoutes = routeNames.filter((r) => r !== "audit");
+        const result = processRoutes(files, selectedRoutes);
+        const router = result.get("work-router.yml");
+        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")');
+    });
+    it("processes multiple excluded routes at once", () => {
+        const files = new Map([
+            ["work-router.yml", ROUTER_YAML],
+            ["classify-route.sh", CLASSIFIER_SH],
+            ["verify-route-matrix.sh", MATRIX_SH],
+        ]);
+        const selectedRoutes = ["refine", "implement"];
+        const result = processRoutes(files, selectedRoutes);
+        const router = result.get("work-router.yml");
+        expect(router).toContain("call-refine");
+        expect(router).toContain("call-implement");
+        expect(router).not.toContain("call-audit");
+        expect(router).not.toContain("call-propose");
+    });
+});
+describe("excludedWorkerFiles", () => {
+    it("returns worker files for unselected routes", () => {
+        const selectedRoutes = ["refine", "implement"];
+        const excluded = excludedWorkerFiles(selectedRoutes);
+        expect(excluded.has("agent-refine.md")).toBe(false);
+        expect(excluded.has("agent-implement.md")).toBe(false);
+        expect(excluded.has("agent-audit.md")).toBe(true);
+        expect(excluded.has("agent-propose.md")).toBe(true);
+    });
+    it("returns an empty set when all routes are selected", () => {
+        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.d.ts

@@ -0,0 +1,11 @@
+import type { RepositoryInspection } from "./repository-inspection.js";
+export interface StackDefaults {
+    readonly verifyCommands: string;
+    readonly repoRulesBase: string;
+    readonly hasDotnet: boolean;
+    readonly hasNodeOnly: boolean;
+}
+export declare function generateStackDefaults(inspection: RepositoryInspection): StackDefaults;
+export declare function injectStackEnv(content: string, defaults: StackDefaults): string;
+export declare function generateOpencodeCi(baseContent: string, inspection: RepositoryInspection): string;
+export declare function generateOpencodeConfig(baseContent: string, inspection: RepositoryInspection): string;

package/dist/stack-defaults.js

@@ -0,0 +1,105 @@
+export function generateStackDefaults(inspection) {
+    const hasDotnet = inspection.stackHints.solutionFiles.length > 0;
+    const hasNode = inspection.stackHints.pnpmLockfile;
+    const hasNodeOnly = hasNode && !hasDotnet;
+    let verifyCommands;
+    let repoRulesBase;
+    if (hasDotnet && hasNode) {
+        verifyCommands = ".NET: dotnet restore && dotnet build -c Release && dotnet test | Web: pnpm lint && pnpm test && pnpm build";
+        repoRulesBase = "Full-stack .NET + React/Next.js repository. Follow Clean Architecture layering: API → Application → Domain. Infrastructure implements Application ports. Do not reference EF Core or ASP.NET from Application. Frontend communicates exclusively via HTTP endpoints. Run both .NET and frontend verification.";
+    }
+    else if (hasDotnet) {
+        verifyCommands = "dotnet restore && dotnet build -c Release --no-restore && dotnet test";
+        repoRulesBase = ".NET repository using Clean Architecture. Follow layering: API → Application → Domain. Infrastructure implements Application ports. Do not reference EF Core or ASP.NET from Application.";
+    }
+    else {
+        verifyCommands = "pnpm verify";
+        repoRulesBase = "Node.js repository. Follow existing project conventions and import boundaries.";
+    }
+    return { verifyCommands, repoRulesBase, hasDotnet, hasNodeOnly };
+}
+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}"`);
+    }
+    else if (/^env:\n/m.test(result)) {
+        result = result.replace(/^env:\n/m, `env:\n  VERIFY_COMMANDS: "${defaults.verifyCommands}"\n`);
+    }
+    return result;
+}
+export function generateOpencodeCi(baseContent, inspection) {
+    let result = baseContent;
+    if (inspection.stackHints.solutionFiles.length > 0) {
+        const nugetSteps = `  - name: Cache NuGet packages
+    uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+    with:
+      path: ~/.nuget/packages
+      key: nuget-\${{ runner.os }}-\${{ hashFiles('**/*.slnx', '**/Directory.Packages.props') }}
+      restore-keys: nuget-\${{ runner.os }}-
+
+  - name: Restore .NET dependencies
+    run: dotnet restore
+`;
+        result = insertBeforeMarker(result, nugetSteps, "  - name: Install workspace dependencies");
+    }
+    if (inspection.stackHints.openSpec) {
+        const openspecStep = `  - name: Install OpenSpec CLI
+    run: |
+      set -euo pipefail
+      npm install -g @openspec/cli@latest
+      openspec --version
+`;
+        result = insertBeforeMarker(result, openspecStep, "  - name: Install workspace dependencies");
+    }
+    if (inspection.stackHints.packageJson && !result.includes("--legacy-peer-deps")) {
+        result = result.replace(`      if ! npm install --prefix .opencode; then\n        echo "No plugin deps, skipping."\n        exit 0\n      fi`, `      if ! npm install --prefix .opencode; then\n        echo "::warning::Strict npm install failed on a peer conflict. Retrying with --legacy-peer-deps; check .opencode/package.json."\n        npm install --prefix .opencode --legacy-peer-deps\n      fi`);
+    }
+    return result;
+}
+function insertBeforeMarker(content, steps, marker) {
+    if (content.includes(marker)) {
+        return content.replace(marker, steps + marker);
+    }
+    return content + "\n" + steps;
+}
+export function generateOpencodeConfig(baseContent, inspection) {
+    try {
+        const config = JSON.parse(baseContent);
+        const hasDotnet = inspection.stackHints.solutionFiles.length > 0;
+        if (!hasDotnet && config.lsp !== undefined) {
+            delete config.lsp;
+        }
+        else if (hasDotnet && config.lsp === undefined) {
+            config.lsp = {
+                csharp: { disabled: true },
+                fsharp: { disabled: true },
+                razor: { disabled: true },
+            };
+        }
+        const agent = config.agent;
+        if (agent !== undefined) {
+            const agentEntry = agent["ci-workflow-agent"];
+            if (agentEntry !== undefined) {
+                let prompt = agentEntry.prompt ?? "";
+                if (hasDotnet) {
+                    if (!prompt.includes(".NET guardrails")) {
+                        prompt += "\n\n# .NET guardrails\nFollow Clean Architecture layering: API → Application → Domain. Infrastructure implements Application ports. Application must not reference EF Core or ASP.NET. Use Central Package Management (Directory.Packages.props). Build in Release mode for CI.";
+                    }
+                }
+                else {
+                    if (!prompt.includes("Node/React rules")) {
+                        prompt += "\n\n# Node/React rules\nFollow Feature-Sliced Design import boundaries. Use pnpm, never npm or yarn. All user-facing text must be i18n messages. TypeScript strict mode.";
+                    }
+                }
+                agentEntry.prompt = prompt;
+            }
+        }
+        return JSON.stringify(config, null, 2) + "\n";
+    }
+    catch {
+        return baseContent;
+    }
+}

package/dist/stack-defaults.test.d.ts

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