@plainconceptsplatform/workflows 0.5.1 → 0.6.1

package/dist/tui.test.d.ts

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

package/dist/tui.test.js

@@ -0,0 +1,249 @@
+import { describe, expect, it } from "vitest";
+import { applyFilter, cancelSelection, clearFilter, createSelectionState, filterItems, fuzzyMatch, getItemsToInstall, moveCursorDown, moveCursorUp, submitSelection, toggleSelection, } from "./tui.js";
+function makeEntry(name, kind, installed = false) {
+    return {
+        kind,
+        name,
+        description: `${name} description`,
+        file: `${name}.md`,
+        installed,
+    };
+}
+function makeEntries(installed = []) {
+    const routes = ["refine", "implement", "triage", "apply-review", "merge-gate", "audit"];
+    const templates = ["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "opencode.ci.json"];
+    return [
+        ...routes.map((name) => makeEntry(name, "route", installed.includes(name))),
+        ...templates.map((name) => makeEntry(name, "template", installed.includes(name))),
+    ];
+}
+// Counts derive from the fixture, so adding or removing a route above cannot silently
+// desynchronise five assertions again.
+const FIXTURE_COUNT = makeEntries().length;
+describe("createSelectionState", () => {
+    it("returns all items as visible initially", () => {
+        const entries = makeEntries();
+        const state = createSelectionState(entries);
+        expect(state.allItems).toHaveLength(FIXTURE_COUNT);
+        expect(state.visibleItems).toHaveLength(FIXTURE_COUNT);
+    });
+    it("pre-selects installed items", () => {
+        const entries = makeEntries(["refine", "agentics-checks"]);
+        const state = createSelectionState(entries);
+        expect(state.selected.has("refine")).toBe(true);
+        expect(state.selected.has("agentics-checks")).toBe(true);
+        expect(state.selected.has("implement")).toBe(false);
+    });
+    it("starts with no filter and cursor at 0", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.filter).toBe("");
+        expect(state.cursor).toBe(0);
+        expect(state.status).toBe("selecting");
+    });
+    it("pre-selects nothing when nothing is installed", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.selected.size).toBe(0);
+    });
+});
+describe("fuzzyMatch", () => {
+    it("returns true for empty query", () => {
+        expect(fuzzyMatch("anything", "")).toBe(true);
+    });
+    it("matches exact string", () => {
+        expect(fuzzyMatch("refine", "refine")).toBe(true);
+    });
+    it("matches subsequence characters", () => {
+        expect(fuzzyMatch("refine", "rfe")).toBe(true);
+    });
+    it("matches non-contiguous characters", () => {
+        expect(fuzzyMatch("app-ci-dotnet-next", "acdn")).toBe(true);
+    });
+    it("is case-insensitive", () => {
+        expect(fuzzyMatch("Refine", "REFINE")).toBe(true);
+        expect(fuzzyMatch("REFINE", "refine")).toBe(true);
+    });
+    it("returns false when characters are not in order", () => {
+        expect(fuzzyMatch("refine", "efinr")).toBe(false);
+    });
+    it("returns false when query has characters not in text", () => {
+        expect(fuzzyMatch("refine", "xyz")).toBe(false);
+    });
+    it("matches against full name + description with combined filter", () => {
+        const text = "agentics-checks Agentics checks: verifies generated agent lockfiles";
+        expect(fuzzyMatch(text, "acch")).toBe(true);
+    });
+});
+describe("filterItems", () => {
+    const entries = makeEntries();
+    it("returns all items when filter is empty", () => {
+        expect(filterItems(entries, "")).toHaveLength(FIXTURE_COUNT);
+    });
+    it("filters by name", () => {
+        const result = filterItems(entries, "refine");
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("refine");
+    });
+    it("filters by description", () => {
+        const result = filterItems(entries, "description");
+        expect(result).toHaveLength(FIXTURE_COUNT);
+    });
+    it("filters by fuzzy subsequence over name and description", () => {
+        const result = filterItems(entries, "acdn");
+        const names = result.map((e) => e.name);
+        expect(names).toContain("app-ci-dotnet-next");
+    });
+    it("returns empty when nothing matches", () => {
+        expect(filterItems(entries, "zzzzz")).toHaveLength(0);
+    });
+});
+describe("applyFilter", () => {
+    it("updates the filter and visibleItems", () => {
+        const state = createSelectionState(makeEntries());
+        const next = applyFilter(state, "refine");
+        expect(next.filter).toBe("refine");
+        expect(next.visibleItems.length).toBe(1);
+        expect(next.visibleItems[0].name).toBe("refine");
+    });
+    it("clamps cursor when result shrinks", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 10 };
+        state = applyFilter(state, "ci");
+        expect(state.cursor).toBeLessThanOrEqual(Math.max(0, state.visibleItems.length - 1));
+        expect(state.cursor).toBeLessThan(state.visibleItems.length);
+    });
+    it("sets cursor to 0 when no results match", () => {
+        const state = applyFilter(createSelectionState(makeEntries()), "zzz");
+        expect(state.visibleItems).toHaveLength(0);
+        expect(state.cursor).toBe(0);
+    });
+    it("preserves selected set when filtering", () => {
+        const entries = makeEntries(["refine"]);
+        const state = applyFilter(createSelectionState(entries), "ref");
+        expect(state.selected.has("refine")).toBe(true);
+    });
+});
+describe("clearFilter", () => {
+    it("resets filter to empty and restores all items", () => {
+        let state = applyFilter(createSelectionState(makeEntries()), "ref");
+        state = clearFilter(state);
+        expect(state.filter).toBe("");
+        expect(state.visibleItems).toHaveLength(FIXTURE_COUNT);
+    });
+});
+describe("moveCursorUp / moveCursorDown", () => {
+    it("moves cursor down by one", () => {
+        const state = createSelectionState(makeEntries());
+        const next = moveCursorDown(state);
+        expect(next.cursor).toBe(1);
+    });
+    it("wraps cursor to top from bottom", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: entries.length - 1 };
+        state = moveCursorDown(state);
+        expect(state.cursor).toBe(0);
+    });
+    it("moves cursor up by one", () => {
+        const entries = makeEntries();
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 3 };
+        state = moveCursorUp(state);
+        expect(state.cursor).toBe(2);
+    });
+    it("wraps cursor to bottom from top", () => {
+        const state = moveCursorUp(createSelectionState(makeEntries()));
+        expect(state.cursor).toBe(FIXTURE_COUNT - 1);
+    });
+    it("does not move when list is empty", () => {
+        const entries = [];
+        const state = createSelectionState(entries);
+        expect(moveCursorUp(state).cursor).toBe(0);
+        expect(moveCursorDown(state).cursor).toBe(0);
+    });
+    it("navigates within filtered results", () => {
+        let state = createSelectionState(makeEntries());
+        state = applyFilter(state, "ci");
+        state = moveCursorDown(state);
+        expect(state.cursor).toBe(1);
+        expect(state.cursor).toBeLessThan(state.visibleItems.length);
+    });
+});
+describe("toggleSelection", () => {
+    it("selects an unselected item at cursor", () => {
+        const state = createSelectionState(makeEntries());
+        expect(state.selected.has("refine")).toBe(false);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(true);
+    });
+    it("deselects a selected item at cursor", () => {
+        const entries = makeEntries(["refine"]);
+        const state = createSelectionState(entries);
+        expect(state.selected.has("refine")).toBe(true);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(false);
+    });
+    it("toggles the item at cursor position within filtered list", () => {
+        let state = createSelectionState(makeEntries());
+        state = applyFilter(state, "ci");
+        state = moveCursorDown(state);
+        const entryAtCursor = state.visibleItems[state.cursor];
+        const next = toggleSelection(state);
+        expect(next.selected.has(entryAtCursor.name)).toBe(true);
+    });
+    it("does nothing when list is empty", () => {
+        const state = createSelectionState([]);
+        const next = toggleSelection(state);
+        expect(next.selected.size).toBe(0);
+    });
+    it("does not change other selections", () => {
+        const entries = makeEntries(["refine", "audit"]);
+        const state = createSelectionState(entries);
+        const next = toggleSelection(state);
+        expect(next.selected.has("refine")).toBe(false);
+        expect(next.selected.has("audit")).toBe(true);
+    });
+});
+describe("submitSelection / cancelSelection", () => {
+    it("sets status to submitting", () => {
+        const state = submitSelection(createSelectionState(makeEntries()));
+        expect(state.status).toBe("submitting");
+    });
+    it("sets status to cancelled", () => {
+        const state = cancelSelection(createSelectionState(makeEntries()));
+        expect(state.status).toBe("cancelled");
+    });
+});
+describe("getItemsToInstall", () => {
+    it("returns empty when nothing is selected", () => {
+        const state = createSelectionState(makeEntries());
+        expect(getItemsToInstall(state)).toHaveLength(0);
+    });
+    it("returns only selected items that are not already installed", () => {
+        const entries = makeEntries(["refine"]);
+        let state = createSelectionState(entries);
+        state = { ...state, cursor: 1 };
+        state = toggleSelection(state);
+        const items = getItemsToInstall(state);
+        const names = items.map((e) => e.name);
+        expect(names).toContain("implement");
+        expect(names).not.toContain("refine");
+    });
+    it("returns already-installed items when force is true", () => {
+        const entries = makeEntries(["refine"]);
+        let state = createSelectionState(entries);
+        const items = getItemsToInstall(state, true);
+        const names = items.map((e) => e.name);
+        expect(names).toContain("refine");
+    });
+    it("includes both routes and templates", () => {
+        let state = createSelectionState(makeEntries());
+        state = toggleSelection(state);
+        state = { ...state, cursor: 8 };
+        state = toggleSelection(state);
+        const items = getItemsToInstall(state);
+        const kinds = items.map((e) => e.kind);
+        expect(kinds).toContain("route");
+        expect(kinds).toContain("template");
+    });
+});

package/dist/workflow-catalog.d.ts

@@ -0,0 +1,25 @@
+export declare const routeNames: readonly ["refine", "implement", "triage", "apply-review", "merge-gate", "audit"];
+export type RouteName = (typeof routeNames)[number];
+export interface WorkflowRoute {
+    readonly name: RouteName;
+    readonly worker: string;
+    readonly description: string;
+    readonly defaultEnabled: boolean;
+}
+export declare const workflowRoutes: readonly WorkflowRoute[];
+export declare const packageOwnedTargets: readonly [".github/actions", ".github/workflows/agent-*.md", ".github/workflows/shared/platform-defaults.md", ".github/workflows/shared/opencode-ci.md", ".github/workflows/work-router.yml", "scripts/compile-agent-workflows.mjs", "opencode.ci.json"];
+export interface MandatoryFile {
+    readonly source: string;
+    readonly target: string;
+}
+export declare const mandatoryFiles: readonly MandatoryFile[];
+export declare const generatedConsumerTargets: readonly [".github/workflows/agent-*.lock.yml", ".github/aw/actions-lock.json"];
+export declare const templateNames: readonly ["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "bug-report", "feature-request", "github-release", "opencode.ci.json", "visual-evidence"];
+export type TemplateName = (typeof templateNames)[number];
+export interface CatalogTemplate {
+    readonly name: TemplateName;
+    readonly file: string;
+    readonly description: string;
+    readonly target?: string;
+}
+export declare const catalogTemplates: readonly CatalogTemplate[];

package/dist/workflow-catalog.js

@@ -0,0 +1,55 @@
+export const routeNames = [
+    "refine",
+    "implement",
+    "triage",
+    "apply-review",
+    "merge-gate",
+    "audit",
+];
+export const workflowRoutes = [
+    { name: "refine", worker: "agent-refine.md", description: "Refines an issue into a user story, on a first pass or after the author has answered the bot's questions.", defaultEnabled: true },
+    { name: "implement", worker: "agent-implement.md", description: "Implements an issue and opens a pull request. Stops there: the merge decision belongs to the merge gate.", defaultEnabled: true },
+    { name: "triage", worker: "agent-triage.md", description: "Triages issues opened by outside collaborators: runs 10 checks (template, security, size, danger, duplicates, clarity, reproducibility, acceptance, cross-cutting). Loops up to 3 rounds. Passes to refine or blocks.", defaultEnabled: true },
+    { name: "apply-review", worker: "agent-apply-review.md", description: "Applies reviewer feedback to an open pull request the bot authored, then pushes the fixes to the same branch.", defaultEnabled: true },
+    { name: "merge-gate", worker: "agent-merge-gate.md", description: "Decides what happens to a bot-authored pull request once CI has reported: merge, hand to a human, or fix CI.", defaultEnabled: true },
+    { name: "audit", worker: "agent-audit.md", description: "Read-only repository audit. Finds 5-7 problems, scores each 1-10, and files a single issue that Refine then sizes and splits.", defaultEnabled: true },
+];
+export const packageOwnedTargets = [
+    ".github/actions",
+    ".github/workflows/agent-*.md",
+    ".github/workflows/shared/platform-defaults.md",
+    ".github/workflows/shared/opencode-ci.md",
+    ".github/workflows/work-router.yml",
+    "scripts/compile-agent-workflows.mjs",
+    "opencode.ci.json",
+];
+export const mandatoryFiles = [
+    { source: "templates/opencode/opencode.ci.json", target: "opencode.ci.json" },
+    { source: "scripts/compile-agent-workflows.mjs", target: "scripts/compile-agent-workflows.mjs" },
+];
+export const generatedConsumerTargets = [
+    ".github/workflows/agent-*.lock.yml",
+    ".github/aw/actions-lock.json",
+];
+export const templateNames = [
+    "agentics-checks",
+    "agentics-maintenance",
+    "app-ci-dotnet-next",
+    "app-ci-node-monorepo",
+    "bug-report",
+    "feature-request",
+    "github-release",
+    "opencode.ci.json",
+    "visual-evidence",
+];
+export const catalogTemplates = [
+    { name: "agentics-checks", file: "agentics-checks.yml", description: "Agentics checks: verifies generated agent lockfiles, actionlint, and compile on PRs touching workflow files." },
+    { name: "agentics-maintenance", file: "agentics-maintenance.yml", description: "Agentic maintenance: scheduled daily maintenance workflow for keeping workflows and actions up to date." },
+    { name: "app-ci-dotnet-next", file: "app-ci-dotnet-next.yml", description: "App CI pipeline for a .NET + Next.js monorepo: build, test, and lint on PRs and schedule." },
+    { name: "app-ci-node-monorepo", file: "app-ci-node-monorepo.yml", description: "App CI pipeline for a Node monorepo: build, test, and lint on PRs and schedule." },
+    { name: "bug-report", file: "bug_report.yml", description: "Bug report issue template: what happened, repro steps, expected behavior, acceptance criteria, environment, logs.", target: ".github/ISSUE_TEMPLATE/bug_report.yml" },
+    { name: "feature-request", file: "feature_request.yml", description: "Feature request issue template scoped to small, well-scoped improvements (Small/Medium only; large work belongs in a planning issue).", target: ".github/ISSUE_TEMPLATE/feature_request.yml" },
+    { name: "github-release", file: "github-release.yml", description: "Publishes or updates a GitHub Release with generated notes whenever a v* tag is pushed." },
+    { name: "opencode.ci.json", file: "opencode.ci.json", description: "Standalone OpenCode CI config: plainconcepts provider, GLM model registration, ci-workflow-agent, and LSP defaults for consumer repositories." },
+    { name: "visual-evidence", file: "visual-evidence.yml", description: "Visual evidence: captures screenshots of UI changes on bot-authored PRs by reading the capturePlan left by the agent in evidence.json and executing it on a runner with Docker and Chrome access." },
+];

package/dist/workflow-catalog.test.d.ts

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

package/dist/workflow-catalog.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { catalogTemplates, generatedConsumerTargets, packageOwnedTargets, routeNames, templateNames, workflowRoutes, } from "./workflow-catalog.js";
+describe("workflow catalog", () => {
+    it("assigns one worker to each route", () => {
+        expect(workflowRoutes.map((route) => route.name)).toEqual(routeNames);
+        expect(new Set(workflowRoutes.map((route) => route.worker)).size).toBe(workflowRoutes.length);
+    });
+    it("gives every route a non-empty description", () => {
+        for (const route of workflowRoutes) {
+            expect(route.description.length).toBeGreaterThan(0);
+        }
+    });
+    it("keeps generated files outside package ownership", () => {
+        const packageTargets = new Set(packageOwnedTargets);
+        for (const target of generatedConsumerTargets) {
+            expect(packageTargets.has(target)).toBe(false);
+        }
+    });
+    it("lists supported optional templates", () => {
+        expect(templateNames).toEqual(["agentics-checks", "agentics-maintenance", "app-ci-dotnet-next", "app-ci-node-monorepo", "bug-report", "feature-request", "github-release", "opencode.ci.json", "visual-evidence"]);
+    });
+    it("gives every catalog template a non-empty description and file", () => {
+        expect(catalogTemplates.map((template) => template.name)).toEqual([...templateNames]);
+        expect(new Set(catalogTemplates.map((template) => template.file)).size).toBe(catalogTemplates.length);
+        for (const template of catalogTemplates) {
+            expect(template.description.length).toBeGreaterThan(0);
+        }
+    });
+});

package/loops/actions/add-issue-labels/action.yml

@@ -9,7 +9,7 @@ inputs:
     description: Issue or pull request number.
     required: true
   labels:
-    description: Newline-delimited labels to add.
+    description: Labels to add, one per line. A comma-separated list is accepted as well.
     required: true
 runs:
   using: composite
@@ -22,7 +22,7 @@ runs:
       with:
         github-token: ${{ inputs.token }}
         script: |
-          const labels = process.env.LABELS.split(/\r?\n/).filter(Boolean);
+          const labels = process.env.LABELS.split(/\r?\n|,/).map((label) => label.trim()).filter(Boolean);
           await github.rest.issues.addLabels({
             ...context.repo,
             issue_number: Number(process.env.ISSUE_NUMBER),

package/loops/actions/apply-agent-bundle/apply-bundle.sh

@@ -40,7 +40,20 @@ git fetch --no-tags "$BUNDLE_FILE" "$BUNDLE_REF"
 [ "$(git cat-file -t "$BUNDLE_TIP")" = commit ] || fail "Git bundle ref must point directly to a commit"
 [ "$(git rev-parse FETCH_HEAD)" = "$BUNDLE_TIP" ] || fail "Fetched bundle commit did not match listed bundle ref"
 
-git merge-base --is-ancestor "$TARGET_TIP" "$BUNDLE_TIP" || fail "Git bundle cannot fast-forward $TARGET_BRANCH"
+# Fast-forward only, deliberately: a push that is not one would discard somebody's commits.
+#
+# "Cannot fast-forward" said nothing about why, and there are two reasons: the agent
+# rewrote history (a rebase, an amend, a reset), or somebody pushed to the branch while it
+# was working. Both mean the same thing to git, that the branch carries commits the bundle
+# does not, so the applier cannot tell them apart and does not try. It prints the commits
+# that are missing instead: their authors and dates answer the question immediately.
+if ! git merge-base --is-ancestor "$TARGET_TIP" "$BUNDLE_TIP"; then
+  echo "::error::Nothing was applied. $TARGET_BRANCH is at $TARGET_TIP and the bundle is at $BUNDLE_TIP, which does not contain it, so pushing would drop the commits below. Either the agent rewrote history, which this push refuses, or the branch moved while it was working, in which case nothing is lost and the gate only needs running again on the current head."
+  echo "On $TARGET_BRANCH but missing from the bundle:"
+  git --no-pager log --format="  %h %ad %an  %s" --date=short "$BUNDLE_TIP..$TARGET_TIP" |
+    head -20 || true
+  exit 1
+fi
 git switch --detach "$TARGET_TIP"
 git merge --ff-only "$BUNDLE_TIP"
 git push origin "HEAD:refs/heads/$TARGET_BRANCH"

package/loops/actions/classify-route/action.yml

@@ -24,6 +24,12 @@ outputs:
   ci-run-id:
     description: Workflow run ID of that CI run.
     value: ${{ steps.classify.outputs.ci-run-id }}
+  merge-gate-attempts:
+    description: Failed merge-gate attempts already made against this CI verdict.
+    value: ${{ steps.classify.outputs.merge-gate-attempts }}
+  implement-attempts:
+    description: Implement runs already made for this issue that died before producing an answer.
+    value: ${{ steps.classify.outputs.implement-attempts }}
   refine-mode:
     description: first or rerefine.
     value: ${{ steps.classify.outputs.refine-mode }}
@@ -60,6 +66,7 @@ runs:
         INPUT_MODE: ${{ github.event.inputs.mode }}
         INPUT_CI_CONCLUSION: ${{ github.event.inputs.ci-conclusion }}
         INPUT_CI_RUN_ID: ${{ github.event.inputs.ci-run-id }}
+        INPUT_ATTEMPTS_SO_FAR: ${{ github.event.inputs.attempts_so_far }}
         INPUT_TRIGGER_KIND: ${{ github.event.inputs.trigger-kind }}
       run: |
         set -euo pipefail

package/loops/actions/classify-route/classify-route.sh

@@ -23,7 +23,7 @@ is_issue_number() {
 
 classify_route() {
   local route="none" error=""
-  local issue_number="" pr_number="" ci_conclusion="" ci_run_id=""
+  local issue_number="" pr_number="" ci_conclusion="" ci_run_id="" merge_gate_attempts="0" implement_attempts="0"
   local refine_mode="" triage_mode="" trigger_kind=""
 
   case "${EVENT:-}" in
@@ -100,8 +100,14 @@ classify_route() {
 
     issue_comment)
       if [ "${COMMENT_ON_PR:-false}" = "true" ]; then
-        route="apply-review"
-        pr_number="${EVENT_ISSUE_NUMBER:-}"
+        if [ "${COMMENT_SENDER_TYPE:-}" = "Bot" ]; then
+          # Every App-token comment on a pull request is an issue_comment event, and the
+          # workers comment on pull requests they own. None of that is reviewer feedback.
+          error="comment authored by a bot"
+        else
+          route="apply-review"
+          pr_number="${EVENT_ISSUE_NUMBER:-}"
+        fi
       elif [ "${ISSUE_STATE:-}" = "closed" ]; then
         # A closing comment on a refine-labelled issue used to start a full re-refine, which
         # held a runner for 35 minutes and filed split children under an already-shut parent.
@@ -144,8 +150,10 @@ classify_route() {
 
     workflow_run)
       # Only a FAILED CI run on an attached pull request auto-dispatches the gate. A green
-      # run reaches merge through app-ci's dispatch-merge-gate and the reconcile belt, so
-      # routing success here would double-fire the gate for every passing pull request.
+      # run reaches the gate through the consumer CI's dispatch-merge-gate job and the
+      # reconcile belt, so routing success here would double-fire the gate for every passing
+      # pull request. GitHub delivers workflow_run only for CI runs whose actor is a human;
+      # a bot pull request's CI never arrives here at all, and the same two paths cover it.
       if [ "${RUN_CONCLUSION:-}" != "failure" ]; then
         error="CI concluded '${RUN_CONCLUSION:-}'; the gate auto-triggers only on failure"
       elif is_issue_number "${RUN_PR_NUMBER:-}"; then
@@ -178,6 +186,10 @@ classify_route() {
             issue_number="${INPUT_ISSUE_NUMBER}"
             if [ "$OPERATION" = "refine" ]; then
               refine_mode="${INPUT_MODE:-first}"
+            else
+              # The implement worker re-dispatches itself when a run dies before doing any work,
+              # and carries the count so the budget is bounded.
+              implement_attempts="${INPUT_ATTEMPTS_SO_FAR:-0}"
             fi
           else
             error="operation '${OPERATION}' needs a positive issue-number, got '${INPUT_ISSUE_NUMBER:-}'"
@@ -206,6 +218,7 @@ classify_route() {
             pr_number="${INPUT_PR_NUMBER}"
             ci_conclusion="${INPUT_CI_CONCLUSION:-}"
             ci_run_id="${INPUT_CI_RUN_ID:-}"
+            merge_gate_attempts="${INPUT_ATTEMPTS_SO_FAR:-0}"
           else
             error="operation 'merge-gate' needs a positive pr-number, got '${INPUT_PR_NUMBER:-}'"
           fi
@@ -237,6 +250,8 @@ issue-number=${issue_number}
 pr-number=${pr_number}
 ci-conclusion=${ci_conclusion}
 ci-run-id=${ci_run_id}
+merge-gate-attempts=${merge_gate_attempts}
+implement-attempts=${implement_attempts}
 refine-mode=${refine_mode}
 triage-mode=${triage_mode}
 trigger-kind=${trigger_kind}

package/loops/actions/cleanup-artifacts/action.yml

@@ -36,17 +36,32 @@ runs:
           const failed = [];
 
           for (const artifact of expired) {
-            try {
-              await github.rest.actions.deleteArtifact({
-                ...context.repo,
-                artifact_id: artifact.id,
-              });
+            // GitHub answers a delete with a 5xx now and then. Three tries, because the
+            // alternative is a red daily run over one artifact that tomorrow's run would
+            // have removed anyway.
+            let lastError;
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+              try {
+                await github.rest.actions.deleteArtifact({
+                  ...context.repo,
+                  artifact_id: artifact.id,
+                });
 
-              core.info(`Deleted ${artifact.name} (created ${artifact.created_at})`);
-              deleted += 1;
-            } catch (error) {
-              core.warning(`Could not delete ${artifact.name} (${artifact.id}): ${error.message}`);
-              failed.push(artifact.name);
+                core.info(`Deleted ${artifact.name} (created ${artifact.created_at})`);
+                deleted += 1;
+                lastError = undefined;
+                break;
+              } catch (error) {
+                lastError = error;
+                if (attempt < 3) await new Promise((wait) => setTimeout(wait, attempt * 2000));
+              }
+            }
+
+            if (lastError) {
+              core.warning(
+                `Could not delete ${artifact.name} (${artifact.id}) after 3 tries: ${lastError.message}`,
+              );
+              failed.push({ name: artifact.name, status: lastError.status });
             }
           }
 
@@ -60,6 +75,17 @@ runs:
             ])
             .write();
 
-          if (failed.length > 0) {
-            core.setFailed(`${failed.length} artifact(s) could not be deleted: ${failed.join(', ')}`);
+          // Deleting nothing at all while expired artifacts exist is a permission or
+          // configuration problem, and has to be loud. One stubborn artifact among many is
+          // the API having a bad minute: tomorrow's run picks it up, and failing here only
+          // teaches people to ignore a red cleanup. A 4xx is never transient, so it fails
+          // whatever else succeeded.
+          const names = failed.map((entry) => entry.name).join(', ');
+          const structural = failed.some((entry) => entry.status && entry.status < 500);
+          if (failed.length > 0 && (deleted === 0 || structural)) {
+            core.setFailed(`${failed.length} artifact(s) could not be deleted: ${names}`);
+          } else if (failed.length > 0) {
+            core.warning(
+              `${failed.length} artifact(s) survived this run and will be retried tomorrow: ${names}`,
+            );
           }

package/loops/actions/identify-gate-subject/action.yml

@@ -96,8 +96,10 @@ runs:
         ci_run_id=""
         if [ -z "$ci_conclusion" ]; then
           head_sha="$(gh pr view "$PR_NUMBER" --repo "$REPO" --json headRefOid --jq '.headRefOid')"
+          # A run keeps the name it had when it ran, so a repository whose CI was renamed still
+          # carries runs under the old casing. Fold the name before comparing.
           ci_run="$(gh api "repos/$REPO/actions/runs?head_sha=$head_sha&per_page=100" \
-            --jq '[.workflow_runs[] | select(.name == "App: CI" or .name == "CI")] | sort_by(.created_at) | last')"
+            --jq '[.workflow_runs[] | select((.name | ascii_downcase) == "app: ci" or (.name | ascii_downcase) == "ci")] | sort_by(.created_at) | last')"
           
           if [ -n "$ci_run" ] && [ "$ci_run" != "null" ]; then
             ci_conclusion="$(jq -r '.conclusion // "pending"' <<<"$ci_run")"

package/loops/actions/remove-issue-labels/action.yml

@@ -9,7 +9,7 @@ inputs:
     description: Issue or pull request number.
     required: true
   labels:
-    description: Newline-delimited labels to remove.
+    description: Labels to remove, one per line. A comma-separated list is accepted as well.
     required: true
 runs:
   using: composite
@@ -22,7 +22,9 @@ runs:
       with:
         github-token: ${{ inputs.token }}
         script: |
-          for (const label of process.env.LABELS.split(/\r?\n/).filter(Boolean)) {
+          // Callers wrote `labels: a,b` while this split on newlines, so one label named "a,b"
+          // was removed: a 404, swallowed below, and neither label ever came off.
+          for (const label of process.env.LABELS.split(/\r?\n|,/).map((label) => label.trim()).filter(Boolean)) {
             try {
               await github.rest.issues.removeLabel({
                 ...context.repo,

package/loops/actions/validate-refine-output/validate-refine-output.sh

@@ -30,8 +30,17 @@ jq -r --arg marker "$marker" --arg prefix "$comment_prefix" --arg issue "$issue_
       (.body | type == "string") and (.body | test("[^[:space:]]")) and
       (.title | type == "string") and (.title | test("[^[:space:]]")))] | length;
 
+  # Signals about the run rather than about the issue. A worker reports these alongside
+  # its real work, and they say nothing about where that work was aimed, so they are not
+  # counted when deciding whether a run stayed on its own issue. Counting them meant a run
+  # that refined the issue perfectly and also noted a difficulty was judged invalid and
+  # its work discarded.
+  def is_run_signal:
+    .type == "report_incomplete" or .type == "missing_tool"
+    or .type == "missing_data" or .type == "noop";
+
   def has_only_source_items:
-    all(.items[];
+    all(.items[] | select(is_run_signal | not);
       (
         .type == "update_issue" and
         (.item_number == null or (.item_number | tostring) == $issue)
@@ -42,6 +51,12 @@ jq -r --arg marker "$marker" --arg prefix "$comment_prefix" --arg issue "$issue_
       ) or
       .type == "create_issue");
 
+  # The agent saying it did not finish. Survivable when it left real work behind, never
+  # when all it left was a comment: a failed run must not be read as a question, or the
+  # loop waits for an answer to something nobody asked.
+  def reported_incomplete:
+    any(.items[]; .type == "report_incomplete");
+
   def has_clarification:
     any(.items[]; .type == "add_comment" and (.item_number | tostring) == $issue and
       (.body | type == "string") and
@@ -54,7 +69,8 @@ jq -r --arg marker "$marker" --arg prefix "$comment_prefix" --arg issue "$issue_
   if child_count >= 2 and has_replacement_body and has_only_source_items then "split"
   elif child_count > 0 then "invalid"
   elif has_replacement_body and has_only_source_items then "complete"
-  elif has_clarification and (has_update | not) and has_only_source_items then "questions"
+  elif has_clarification and (has_update | not) and has_only_source_items
+    and (reported_incomplete | not) then "questions"
   else "invalid"
   end
 ' "$output_file"