@plainconceptsplatform/workflows 1.4.0 → 1.5.0

package/dist/catalog-installation.d.ts

@@ -30,6 +30,8 @@ export interface CatalogInstallResult {
     readonly baselines: readonly BaselineStatus[];
     readonly upToDate: boolean;
     readonly dryRun: boolean;
+    /** Problems the update cannot fix on its own, for a person to act on. */
+    readonly warnings: readonly string[];
 }
 export interface CatalogInstallOptions {
     /** Also overwrite files whose ownership header was removed, and changed templates. */

package/dist/catalog-installation.js

@@ -7,7 +7,7 @@ import { promisify } from "node:util";
 import { parse as parseYaml } from "yaml";
 import { catalogTemplates, mandatoryFiles, retiredWorkflowFiles, routeNames, templateNames, workflowRoutes } from "./workflow-catalog.js";
 import { processRoutes, excludedWorkerFiles } from "./route-processing.js";
-import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv } from "./stack-defaults.js";
+import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv, shippedVerifyDefaults } from "./stack-defaults.js";
 import { mergeRouter, mergeWorker } from "./worker-env.js";
 import { fetchBaseline, hasOwnershipHeader, installedVersion, packageVersion, stampVersion } from "./package-baseline.js";
 const execFileAsync = promisify(execFile);
@@ -133,6 +133,7 @@ export async function installCatalog(repositoryPath, options = {}) {
         baselines,
         upToDate: updates.length === 0 && removals.length === 0,
         dryRun: options.dryRun ?? false,
+        warnings: await verifyScriptWarnings(repositoryPath, updates, existing),
     };
     if (options.dryRun)
         return result;
@@ -158,12 +159,22 @@ export async function installCatalog(repositoryPath, options = {}) {
 // the empty string as the consumer's deliberate choice. All four consuming repositories were in
 // that state, so every merge-gate repair pushed a fix with the verification block interpolating
 // to nothing. An empty value is the absence of a choice, so an update fills it.
+//
+// So is a value the package wrote itself. The implement worker shipped a dotnet-only line, and
+// every full-stack consumer kept it as if someone had chosen it, so the bot never built the web
+// app before opening a pull request. A consumer holding a shipped default gets the current one:
+// its own value is blanked here, which the env merge then reads as no choice.
 function applyStackDefaults(files, inspection, existing) {
     const defaults = generateStackDefaults(inspection);
     const result = new Map(files);
     for (const [target, content] of result) {
-        if (isWorker(target) && (!existing.has(target) || hasEmptyVerifyCommands(existing.get(target)))) {
+        const current = existing.get(target);
+        if (isWorker(target) && (current === undefined || hasEmptyVerifyCommands(current))) {
+            result.set(target, injectStackEnv(content, defaults));
+        }
+        else if (isWorker(target) && hasShippedVerifyCommands(current, defaults.verifyCommands)) {
             result.set(target, injectStackEnv(content, defaults));
+            existing.set(target, current.replace(VERIFY_LINE, '  VERIFY_COMMANDS: ""'));
         }
         else if (target.endsWith("opencode-ci.md")) {
             result.set(target, generateOpencodeCi(content, inspection));
@@ -174,11 +185,42 @@ function applyStackDefaults(files, inspection, existing) {
     }
     return result;
 }
+const VERIFY_LINE = /^ {2}VERIFY_COMMANDS: *(.*?) *$/m;
 // A worker whose VERIFY_COMMANDS is present but empty. Anything else, including a value the
 // consumer wrote, is left alone.
 function hasEmptyVerifyCommands(current) {
     return typeof current === "string" && /^ {2}VERIFY_COMMANDS: *(""|'')? *$/m.test(current);
 }
+function verifyCommandsOf(content) {
+    const raw = VERIFY_LINE.exec(content)?.[1];
+    return raw?.replace(/^(["'])(.*)\1$/, "$2");
+}
+function hasShippedVerifyCommands(current, replacement) {
+    if (current === undefined)
+        return false;
+    const value = verifyCommandsOf(current);
+    return value !== undefined && value !== replacement && shippedVerifyDefaults.has(value);
+}
+// `pnpm verify` is only a command if the repository defines it. The update still writes it, since
+// it is the right default, and says what is missing instead of leaving the bot to find out.
+async function verifyScriptWarnings(repositoryPath, updates, existing) {
+    const written = new Map(existing);
+    for (const update of updates)
+        written.set(update.target, update.content);
+    const workers = [...written].filter(([target, content]) => isWorker(target) && /\bpnpm verify\b/.test(verifyCommandsOf(content) ?? ""));
+    if (workers.length === 0)
+        return [];
+    let scripts = {};
+    try {
+        scripts = JSON.parse(await readFile(join(repositoryPath, "package.json"), "utf8")).scripts ?? {};
+    }
+    catch {
+        scripts = {};
+    }
+    if (typeof scripts.verify === "string")
+        return [];
+    return [`VERIFY_COMMANDS runs \`pnpm verify\` in ${workers.map(([target]) => target).sort().join(", ")}, but package.json has no "verify" script. Add one that runs what CI blocks on.`];
+}
 // Directories that belong wholly to the package. A file here that carries our ownership header
 // and is no longer in the package was deleted upstream, and without this it would sit in every
 // consumer forever: that is how `stale-recovery` and `update-changelog` outlived the code that

package/dist/index.js

@@ -139,6 +139,8 @@ export async function run(arguments_, repositoryPath = process.cwd()) {
             console.error(`Template conflicts found. Re-run with --force to overwrite consumer-owned copies:\n${allConflicts.join("\n")}`);
             return 1;
         }
+        for (const warning of catalog?.warnings ?? [])
+            console.error(`warning: ${warning}`);
         console.log(JSON.stringify({
             command,
             dryRun,
@@ -177,6 +179,7 @@ function summarize(result) {
         baselines: result.baselines,
         changes: result.changes.filter((change) => change.status !== "unchanged"),
         unchanged: result.changes.filter((change) => change.status === "unchanged").length,
+        ...(result.warnings.length > 0 ? { warnings: result.warnings } : {}),
     };
 }
 // A fixed baseline for every recorded version, instead of asking npm. Rolling out a version that

package/dist/stack-defaults.d.ts

@@ -6,6 +6,7 @@ export interface StackDefaults {
     readonly hasNodeOnly: boolean;
 }
 export declare function generateStackDefaults(inspection: RepositoryInspection): StackDefaults;
+export declare const shippedVerifyDefaults: ReadonlySet<string>;
 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

@@ -4,8 +4,12 @@ export function generateStackDefaults(inspection) {
     const hasNodeOnly = hasNode && !hasDotnet;
     let verifyCommands;
     let repoRulesBase;
+    // A full-stack repository verifies with its own `pnpm verify`, which runs what its CI blocks on.
+    // The command this replaced was prose the agent had to interpret, and the implement worker never
+    // got it at all: it kept the package's dotnet-only line, so bot pull requests shipped with the
+    // web build broken (Pliny-Bot #639).
     if (hasDotnet && hasNode) {
-        verifyCommands = ".NET: dotnet restore && dotnet build -c Release && dotnet test | Web: pnpm lint && pnpm test && pnpm build";
+        verifyCommands = "pnpm verify";
         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) {
@@ -18,6 +22,14 @@ export function generateStackDefaults(inspection) {
     }
     return { verifyCommands, repoRulesBase, hasDotnet, hasNodeOnly };
 }
+// Every VERIFY_COMMANDS value the package itself has ever written. A consumer holding one of these
+// never chose it, so an update may replace it with the current default for the stack.
+export const shippedVerifyDefaults = new Set([
+    ".NET: dotnet restore && dotnet build -c Release && dotnet test | Web: pnpm lint && pnpm test && pnpm build",
+    "dotnet restore && dotnet build -c Release --no-restore && dotnet test",
+    "dotnet restore && dotnet build -c Release --no-restore && dotnet test -c Release --no-build",
+    "pnpm verify",
+]);
 // Only a worker that prints a verification block declares VERIFY_COMMANDS. Adding the key to
 // the others made byte-identical workers read as changed on every update, so a worker without
 // the key is left without it.

package/loops/actions/validate-merge-gate-output/action.yml

@@ -38,6 +38,9 @@ outputs:
   outcome:
     description: "Disposition: auto-merge, human-review, owner-review, blocked, remediated, or invalid."
     value: ${{ steps.validate.outputs.outcome }}
+  pushed:
+    description: Whether the agent proposed a push to the pull request branch, applied or not.
+    value: ${{ steps.validate.outputs.pushed }}
 runs:
   using: composite
   steps:
@@ -61,6 +64,8 @@ runs:
           "$BLAST_LEVEL" "$PROTECTED_HIT" "$OWNER_HIT" "$CONFIDENCE_THRESHOLD" "$CODE_RULES")"
         echo "outcome=$outcome" >> "$GITHUB_OUTPUT"
         echo "valid=$([ "$outcome" != 'invalid' ] && echo true || echo false)" >> "$GITHUB_OUTPUT"
+        pushed=$(jq -r '[.items[]? | select(.type == "push_to_pull_request_branch")] | length > 0' "$OUTPUT_FILE" 2>/dev/null || echo false)
+        echo "pushed=$pushed" >> "$GITHUB_OUTPUT"
 
         if [ "$outcome" = 'invalid' ]; then
           echo "::warning::Agent output has no usable merge-gate report. It will not be applied."

package/loops/actions/validate-merge-gate-output/validate-merge-gate-output.sh

@@ -85,11 +85,17 @@ jq -r \
     # Exactly one comment may carry a verdict. Taking the first of several let a second comment
     # reporting a verified critical finding be discarded, and let a comment with no verdict at
     # all supply the report for a verdict written in another.
-    | [$comments[] | select(.body | test("\\*\\*Verdict:\\*\\*\\s*(assessed|remediated)"; "i"))] as $verdicts
+    #
+    # The line is matched by its shape, not its exact markdown. A model that wrote
+    # `**Verdict: remediated**` for `**Verdict:** remediated` had its pushed repair discarded
+    # twice on the same head (Pliny-Bot #639). The word has to open a line, so prose that
+    # mentions a verdict does not count.
+    | "(^|\\n)[^\\w\\n]*Verdict[^\\w\\n]{0,6}(?<v>assessed|remediated)\\b" as $verdict_line
+    | [$comments[] | select(.body | test($verdict_line; "i"))] as $verdicts
     | if ($verdicts | length) != 1 then "invalid" else
 
       ($verdicts[0].body) as $body
-      | ($body | capture("\\*\\*Verdict:\\*\\*\\s*(?<v>assessed|remediated)"; "i").v | ascii_downcase) as $verdict
+      | ($body | capture($verdict_line; "i").v | ascii_downcase) as $verdict
       | ([$items[] | select(.type == "push_to_pull_request_branch")] | length) as $pushes
 
       # The LAST fenced json block in that comment, because the prompt puts the report last and

package/loops/actions/verify-route-matrix/verify-route-matrix.sh

@@ -1613,6 +1613,13 @@ if [ -f "$GATE_VALIDATOR" ] && worker_installed merge-gate; then
                                                  human-review "$(gate_items "$(gate_comment assessed)")" success low false false ''
   gate_case "remediating check-diff is accepted" remediated   "$(gate_items "$(gate_comment remediated),${gate_push}")" success low false false fail
 
+  # The verdict line is read by its shape. Pliny-Bot #639 wrote the bold around the whole line,
+  # and the repair it pushed was discarded twice.
+  gate_bold_line='{"type":"add_comment","item_number":7,"body":"## Remediation Report\n\n**Verdict: remediated**\n"}'
+  gate_prose='{"type":"add_comment","item_number":7,"body":"The verdict is remediated, see the push."}'
+  gate_case "a verdict line bolded whole is read" remediated  "$(gate_items "${gate_bold_line},${gate_push}")" failure low
+  gate_case "a verdict in prose is not a verdict" invalid     "$(gate_items "${gate_prose},${gate_push}")" failure low
+
   # The agent's report decides the rest. This is the rule the whole redesign rests on: an
   # unverified finding is a warning whatever severity it claims, so a model cannot fail the gate
   # by asserting something it did not demonstrate, and cannot pass it by understating one it did.

package/loops/workflows/agent-implement.md

@@ -1,7 +1,7 @@
 ---
 # Managed by @plainconceptsplatform/workflows. Source: loops/workflows/agent-implement.md. Update with `workflows update --force`; consumer edits may be overwritten.
 env:
-  VERIFY_COMMANDS: "dotnet restore && dotnet build -c Release --no-restore && dotnet test -c Release --no-build"
+  VERIFY_COMMANDS: ""
   REPO_RULES: "Implement only the selected issue. Follow repository documentation and existing conventions. Do not weaken tests, lower coverage thresholds, or bypass checks."
   # Split out of REPO_RULES because one field asked to carry architecture, testing, coverage and
   # conventions together, and measured on 2026-09-07 three of the four consuming repositories had
@@ -741,6 +741,11 @@ timeout-minutes: 180
      change and makes you clean the files you touched; fix every line it lists. The merge gate
      runs it again and does not merge while it fails.
 
+     Anything you change to satisfy `check-diff` is a change: run the verification commands
+     again afterwards, and open the pull request only from a tree where both pass. Do not delete
+     a test that covers a branch you added to fit the budget; the complexity gate in CI measures
+     that coverage.
+
 5. Do not touch `changelog.json`. The workflow records the change itself once the work is on
    the default branch. Every implement used to edit that one file, so two runs whose branches
    were cut before the other merged conflicted on it and failed to open a pull request with the

package/loops/workflows/agent-merge-gate.md

@@ -455,6 +455,7 @@ jobs:
     outputs:
       valid: ${{ steps.validate.outputs.valid }}
       outcome: ${{ steps.validate.outputs.outcome }}
+      pushed: ${{ steps.validate.outputs.pushed }}
     steps:
       - name: Checkout workflow actions
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -783,6 +784,26 @@ jobs:
 
             **Verdict:** human-review
             [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+      # The issue is where the belt reads verdicts, but the pull request is where people look. A
+      # parked pull request with nothing on it reads as abandoned, and a repair the agent pushed
+      # that the gate refused to apply sits in the run artifact where nobody finds it.
+      - name: Tell the pull request it needs a person
+        if: steps.budget.outputs.park == 'true'
+        uses: ./.github/actions/create-issue-comment
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          issue-number: ${{ needs.subject.outputs.pr }}
+          body: |
+            The merge gate stopped on this pull request and handed it to a person (#${{ needs.subject.outputs.issue }}).
+            ${{ needs.validate_output.outputs.pushed == 'true' && 'The agent pushed a repair that was not applied because its report could not be read. The patch and bundle are in the `agent` artifact of the run below.' || '' }}
+            [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+      - name: Label the pull request for review
+        if: steps.budget.outputs.park == 'true'
+        uses: ./.github/actions/add-issue-labels
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          issue-number: ${{ needs.subject.outputs.pr }}
+          labels: ${{ env.REVIEW_LABEL }}
       # `stalled` means a park the machine caused, and the janitor retries those. An unusable
       # report is a park the machine caused and retrying reproduces it, so it gets `review`
       # alone: the janitor's own rule is retry a failure, report a decision.
@@ -979,6 +1000,13 @@ timeout-minutes: 120
    until it exits 0, then verify, push and report `remediated` as in step 6. An `assessed`
    verdict while it fails blocks the pull request.
 
+   When CI failed as well, repair CI first and `check-diff` second, and verify again after the
+   `check-diff` repair. The two pull in opposite directions: a complexity or coverage gate wants
+   more code and tests, `check-diff` wants fewer lines. Trimming to fit `check-diff` is how a
+   pull request that once passed broke the formatter, Semgrep and the complexity gate on its
+   last commit (Pliny-Bot #633). Never delete a test that covers a branch the change added; if
+   both cannot hold, keep CI green and say so in `reason`.
+
    - **success** → step 4, then step 5 (review the change).
    - **failure** → step 4, then step 6 (CI remediation).
    - **action_required, cancelled, timed_out, or anything else** → CI did not produce a usable

package/loops/workflows/work-router.yml

@@ -457,6 +457,21 @@ jobs:
           if [ "$existing" -gt 0 ]; then
             echo "has-open-pr=true" >> "$GITHUB_OUTPUT"
             echo "::notice::Issue #$ISSUE_NUMBER already has an open bot PR. Skipping implement to prevent duplicates."
+            exit 0
+          fi
+
+          # A person working on the issue rarely writes a closing keyword: Pliny-Bot #633 said
+          # "Implements #627", and an hour later the bot opened #639 for the same issue. Any open
+          # pull request by a person that names the issue in its title, body or branch holds it.
+          human=$(gh pr list --repo "$REPO" --state open --json number,author,title,body,headRefName \
+            --jq "[.[]
+              | select((.author.login | startswith(\"app/\") or endswith(\"[bot]\")) | not)
+              | select(((.title + \"\n\" + (.body // \"\")) | test(\"#${ISSUE_NUMBER}([^0-9]|$)\"))
+                  or (.headRefName | test(\"(issue|gh)[-_/]?${ISSUE_NUMBER}([^0-9]|$)\"; \"i\")))
+              | .number] | first // empty")
+          if [ -n "$human" ]; then
+            echo "has-open-pr=true" >> "$GITHUB_OUTPUT"
+            echo "::notice::Open PR #$human by a person names #$ISSUE_NUMBER. Skipping implement so the two do not collide."
           else
             echo "has-open-pr=false" >> "$GITHUB_OUTPUT"
           fi

package/package.json

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