@plainconceptsplatform/workflows 0.6.1 → 0.16.2

package/dist/tui.test.js

@@ -1,249 +0,0 @@
-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.test.d.ts

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

package/dist/workflow-catalog.test.js

@@ -1,29 +0,0 @@
-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/stale-recovery/action.yml

@@ -1,288 +0,0 @@
-# Managed by @plainconceptsplatform/workflows. Source: loops/actions/stale-recovery/action.yml. Update with workflows update --force; consumer edits may be overwritten.
-name: Recover stale agent work
-description: Reconcile Refine, Implement, and Merge Gate claims whose bot-working label has outlived the staleness threshold, and dispatch merge-gate for bot PRs with failed CI.
-inputs:
-  token:
-    description: GitHub token with issues write and pull-requests read access.
-    required: true
-  stale-threshold-hours:
-    description: Hours after which a bot-working claim is stale. Invalid or empty values use 2.
-    required: false
-    default: ''
-  refine-marker:
-    description: Marker identifying the comment a Refine run posts when it asks the author a question.
-    required: false
-    default: '<!-- agent-refine -->'
-  working-label:
-    description: Label marking an issue the bot currently owns.
-    required: false
-    default: bot-working
-  refine-label:
-    description: Label marking an issue queued for refinement.
-    required: false
-    default: refine
-  direct-label:
-    description: Label marking an issue with a free-form direct instruction.
-    required: false
-    default: direct
-  implement-label:
-    description: Label marking an issue queued for implementation.
-    required: false
-    default: implement
-  review-label:
-    description: Label marking an issue that needs a human.
-    required: false
-    default: review
-  ci-workflow-name:
-    description: Name of the CI workflow whose failure should trigger a merge-gate dispatch.
-    required: false
-    default: 'App: CI'
-  router-workflow-name:
-    description: Name of the work router workflow to dispatch.
-    required: false
-    default: 'All Work Router'
-runs:
-  using: composite
-  steps:
-    - name: Reconcile stale claims
-      uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
-      env:
-        STALE_THRESHOLD_HOURS: ${{ inputs.stale-threshold-hours }}
-        REFINE_MARKER: ${{ inputs.refine-marker }}
-        WORKING_LABEL: ${{ inputs.working-label }}
-        REFINE_LABEL: ${{ inputs.refine-label }}
-        DIRECT_LABEL: ${{ inputs.direct-label }}
-        IMPLEMENT_LABEL: ${{ inputs.implement-label }}
-        REVIEW_LABEL: ${{ inputs.review-label }}
-        CI_WORKFLOW_NAME: ${{ inputs.ci-workflow-name }}
-        ROUTER_WORKFLOW_NAME: ${{ inputs.router-workflow-name }}
-      with:
-        github-token: ${{ inputs.token }}
-        script: |
-          const WORKING = process.env.WORKING_LABEL;
-          const REVIEW = process.env.REVIEW_LABEL;
-          const MARKER = process.env.REFINE_MARKER;
-          const CI_WORKFLOW_NAME = process.env.CI_WORKFLOW_NAME;
-          const ROUTER_WORKFLOW_NAME = process.env.ROUTER_WORKFLOW_NAME;
-
-          const parsedHours = Number.parseInt(process.env.STALE_THRESHOLD_HOURS, 10);
-          const hours = Number.isInteger(parsedHours) && parsedHours > 0 ? parsedHours : 2;
-          const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
-
-          core.info(`Stale threshold: ${hours}h (cutoff ${cutoff.toISOString()})`);
-
-          const staleIssuesLabelled = async (label) => {
-            const issues = await github.paginate(github.rest.issues.listForRepo, {
-              ...context.repo,
-              state: 'open',
-              labels: `${WORKING},${label}`,
-              per_page: 100,
-            });
-
-            return issues.filter((issue) => new Date(issue.updated_at) < cutoff);
-          };
-
-          const removeWorking = async (issueNumber) => {
-            try {
-              await github.rest.issues.removeLabel({
-                ...context.repo,
-                issue_number: issueNumber,
-                name: WORKING,
-              });
-            } catch (error) {
-              if (error.status !== 404) throw error;
-            }
-          };
-
-          // Open bot pull requests keep work in flight. GraphQL exposes authorship and closing
-          // references together, so use `__typename` instead of matching a login.
-          const openPullRequests = [];
-
-          for (let cursor = null; ; ) {
-            const page = await github.graphql(
-              `query($owner: String!, $name: String!, $cursor: String) {
-                repository(owner: $owner, name: $name) {
-                  pullRequests(states: OPEN, first: 100, after: $cursor) {
-                    pageInfo { hasNextPage endCursor }
-                    nodes {
-                      number
-                      updatedAt
-                      author { __typename }
-                      closingIssuesReferences(first: 10) {
-                        nodes { number labels(first: 20) { nodes { name } } }
-                      }
-                    }
-                  }
-                }
-              }`,
-              { owner: context.repo.owner, name: context.repo.repo, cursor },
-            );
-
-            const { nodes, pageInfo } = page.repository.pullRequests;
-            openPullRequests.push(...nodes);
-
-            if (!pageInfo.hasNextPage) break;
-            cursor = pageInfo.endCursor;
-          }
-
-          const botPullRequests = openPullRequests.filter(
-            (pr) => pr.author?.__typename === 'Bot',
-          );
-
-          const issuesWithOpenBotPr = new Set(
-            botPullRequests.flatMap((pr) => pr.closingIssuesReferences.nodes.map((n) => n.number)),
-          );
-
-          const summary = {
-            refineEscalated: 0,
-            refineAwaitingAuthor: 0,
-            implementReleased: 0,
-            directReleased: 0,
-            mergeGateReleased: 0,
-            mergeGateDispatched: 0,
-          };
-
-          for (const issue of await staleIssuesLabelled(process.env.REFINE_LABEL)) {
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              ...context.repo,
-              issue_number: issue.number,
-              per_page: 100,
-            });
-
-            const lastMarker = comments.filter((c) => (c.body ?? '').includes(MARKER)).pop();
-            const lastHuman = comments.filter((c) => c.user?.type !== 'Bot').pop();
-
-            // The bot asked a question nobody has answered yet. Escalating would drop the
-            // question on the floor, so leave the claim in place.
-            if (lastMarker && !(lastHuman && new Date(lastHuman.created_at) > new Date(lastMarker.created_at))) {
-              core.info(`#${issue.number}: awaiting author reply, left alone`);
-              summary.refineAwaitingAuthor += 1;
-              continue;
-            }
-
-            await removeWorking(issue.number);
-            await github.rest.issues.addLabels({
-              ...context.repo,
-              issue_number: issue.number,
-              labels: [REVIEW],
-            });
-
-            core.info(`#${issue.number}: escalated to ${REVIEW}`);
-            summary.refineEscalated += 1;
-          }
-
-          for (const issue of await staleIssuesLabelled(process.env.IMPLEMENT_LABEL)) {
-            if (issuesWithOpenBotPr.has(issue.number)) {
-              core.info(`#${issue.number}: open bot pull request still in flight, left alone`);
-              continue;
-            }
-
-            await removeWorking(issue.number);
-            core.info(`#${issue.number}: released`);
-            summary.implementReleased += 1;
-          }
-
-          for (const issue of await staleIssuesLabelled(process.env.DIRECT_LABEL)) {
-            if (issuesWithOpenBotPr.has(issue.number)) {
-              core.info(`#${issue.number}: open bot pull request still in flight, left alone`);
-              continue;
-            }
-
-            await removeWorking(issue.number);
-            await github.rest.issues.addLabels({
-              ...context.repo,
-              issue_number: issue.number,
-              labels: [REVIEW],
-            });
-            core.info(`#${issue.number}: direct released, escalated to ${REVIEW}`);
-            summary.directReleased += 1;
-          }
-
-          for (const pr of botPullRequests.filter((p) => new Date(p.updatedAt) < cutoff)) {
-            for (const issue of pr.closingIssuesReferences.nodes) {
-              if (!issue.labels.nodes.some((label) => label.name === WORKING)) {
-                continue;
-              }
-
-              await removeWorking(issue.number);
-              core.info(`PR #${pr.number} / issue #${issue.number}: released`);
-              summary.mergeGateReleased += 1;
-            }
-          }
-
-          // The workflow_run trigger does not fire for PR-triggered CI completions on
-          // feature branches. This polls every stale-recovery cycle (2h) for bot PRs
-          // whose CI concluded failure and dispatches the merge-gate, which is the same
-          // thing the workflow_run trigger would have done. A run already in progress
-          // for the same PR is skipped by the router's concurrency group.
-          const ciWorkflow = await github.rest.actions.getWorkflow({
-            ...context.repo,
-            workflow_id: CI_WORKFLOW_NAME,
-          }).catch(() => null);
-
-          if (ciWorkflow) {
-            for (const pr of botPullRequests) {
-              const runs = await github.rest.actions.listWorkflowRuns({
-                ...context.repo,
-                workflow_id: CI_WORKFLOW_NAME,
-                branch: pr.number.toString(),
-                status: 'completed',
-                per_page: 1,
-              }).catch(() => ({ data: { workflow_runs: [] } }));
-
-              const latestRun = runs.data.workflow_runs[0];
-              if (!latestRun || latestRun.conclusion !== 'failure') continue;
-
-              // Skip if the issue already carries review (the agent already gave up).
-              const issueNumbers = pr.closingIssuesReferences.nodes.map((n) => n.number);
-              const hasReview = await Promise.all(
-                issueNumbers.map(async (n) => {
-                  const labels = await github.rest.issues.listLabelsOnIssue({
-                    ...context.repo,
-                    issue_number: n,
-                  }).catch(() => ({ data: [] }));
-                  return labels.data.some((l) => l.name === REVIEW);
-                }),
-              );
-              if (hasReview.some(Boolean)) continue;
-
-              const routerWorkflow = await github.rest.actions.getWorkflow({
-                ...context.repo,
-                workflow_id: ROUTER_WORKFLOW_NAME,
-              }).catch(() => null);
-
-              if (routerWorkflow) {
-                // Resolve the linked issue number for the dispatch.
-                const linkedIssue = issueNumbers[0];
-                if (!linkedIssue) continue;
-
-                await github.rest.actions.createWorkflowDispatch({
-                  ...context.repo,
-                  workflow_id: ROUTER_WORKFLOW_NAME,
-                  ref: 'main',
-                  inputs: {
-                    operation: 'merge-gate',
-                    'pr-number': pr.number.toString(),
-                    'ci-conclusion': 'failure',
-                    'ci-run-id': latestRun.id.toString(),
-                  },
-                });
-
-                core.info(`PR #${pr.number}: dispatched merge-gate for failed CI (run ${latestRun.id})`);
-                summary.mergeGateDispatched += 1;
-              }
-            }
-          }
-
-          await core.summary
-            .addHeading('Stale recovery', 2)
-            .addList([
-              `Threshold: ${hours} hours (cutoff ${cutoff.toISOString()})`,
-              `Refine escalated to ${REVIEW}: ${summary.refineEscalated}`,
-              `Refine awaiting author: ${summary.refineAwaitingAuthor}`,
-              `Implement released: ${summary.implementReleased}`,
-              `Direct released: ${summary.directReleased}`,
-              `Merge Gate released: ${summary.mergeGateReleased}`,
-              `Merge Gate dispatched for failed CI: ${summary.mergeGateDispatched}`,
-            ])
-            .write();

package/loops/actions/update-changelog/action.yml

@@ -1,113 +0,0 @@
-# Managed by @plainconceptsplatform/workflows. Source: loops/actions/update-changelog/action.yml. Update with `workflows update --force`; consumer edits may be overwritten.
-name: Update changelog
-description: Prepend a changelog entry for a landed issue and push it to the default branch.
-
-inputs:
-  token:
-    description: Token with contents write on the repository.
-    required: true
-  issue-number:
-    description: Issue the landed commit implements.
-    required: true
-  commit-sha:
-    description: Commit the work landed as. Its subject becomes the summary.
-    required: true
-  changelog-path:
-    description: Path to changelog.json.
-    required: false
-    default: apps/web/src/shared/data/changelog.json
-  max-entries:
-    description: Newest entries to keep.
-    required: false
-    default: "20"
-
-runs:
-  using: composite
-  steps:
-    - name: Prepend the entry and push
-      shell: bash
-      env:
-        GH_TOKEN: ${{ inputs.token }}
-        REPO: ${{ github.repository }}
-        ISSUE_NUMBER: ${{ inputs.issue-number }}
-        COMMIT_SHA: ${{ inputs.commit-sha }}
-        CHANGELOG_PATH: ${{ inputs.changelog-path }}
-        MAX_ENTRIES: ${{ inputs.max-entries }}
-        DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
-      run: |
-        set -euo pipefail
-
-        # This used to be part of the implement prompt. It is deterministic work, and leaving it
-        # to the agent made every implement touch the same file: two runs whose branches were cut
-        # before the other merged conflicted here, produced correct code, and still failed to open
-        # a pull request. Doing it after the merge means exactly one writer, always against a
-        # current default branch.
-
-        host="${GITHUB_SERVER_URL#https://}"
-        git config user.name "github-actions[bot]"
-        git config user.email "github-actions[bot]@users.noreply.github.com"
-        git remote set-url origin "https://x-access-token:${GH_TOKEN}@${host}/${GITHUB_REPOSITORY}.git"
-
-        git fetch --quiet origin "$DEFAULT_BRANCH"
-        git checkout --quiet -B "$DEFAULT_BRANCH" "origin/$DEFAULT_BRANCH"
-
-        if [ ! -f "$CHANGELOG_PATH" ]; then
-          echo "::notice::$CHANGELOG_PATH does not exist; nothing to update."
-          exit 0
-        fi
-
-        # Idempotent: a re-run, a retry, or a second call for the same commit must not add a
-        # duplicate row.
-        short_sha="${COMMIT_SHA:0:7}"
-        if jq -e --arg c "$short_sha" '.changes[]? | select(.commit == $c)' "$CHANGELOG_PATH" >/dev/null 2>&1; then
-          echo "::notice::$short_sha is already in the changelog."
-          exit 0
-        fi
-
-        title=$(gh issue view "$ISSUE_NUMBER" --repo "$REPO" --json title --jq '.title')
-
-        # The commit subject carries what actually changed. Strip the conventional-commit prefix
-        # and the trailing issue reference so the summary reads as prose rather than as a commit.
-        subject=$(git log -1 --format=%s "$COMMIT_SHA")
-        summary=$(printf '%s' "$subject" \
-          | sed -E 's/^[a-z]+(\([^)]*\))?!?: *//' \
-          | sed -E 's/ *\(#[0-9]+\) *$//')
-        [ -n "$summary" ] || summary="$title"
-        # Capitalise, because a commit subject conventionally starts lowercase and this is read
-        # by people rather than by tooling.
-        summary="$(printf '%s' "${summary:0:1}" | tr '[:lower:]' '[:upper:]')${summary:1}"
-
-        timestamp=$(git log -1 --format=%cI "$COMMIT_SHA")
-
-        tmp=$(mktemp)
-        jq --argjson n "$MAX_ENTRIES" \
-           --arg ts "$timestamp" \
-           --argjson issue "$ISSUE_NUMBER" \
-           --arg title "$title" \
-           --arg summary "$summary" \
-           --arg commit "$short_sha" \
-           '.changes = ([{timestamp: $ts, issue: $issue, title: $title, summary: $summary, commit: $commit}] + (.changes // []))[:$n]' \
-           "$CHANGELOG_PATH" > "$tmp"
-        mv "$tmp" "$CHANGELOG_PATH"
-
-        if git diff --quiet -- "$CHANGELOG_PATH"; then
-          echo "::notice::changelog unchanged."
-          exit 0
-        fi
-
-        git add -- "$CHANGELOG_PATH"
-        git commit --quiet -m "docs(changelog): record #${ISSUE_NUMBER}"
-
-        # The default branch may have moved while this ran. Rebase and retry rather than fail:
-        # only this action writes the file, so a rebase here cannot produce a content conflict.
-        for attempt in 1 2 3; do
-          if git push --quiet origin "$DEFAULT_BRANCH"; then
-            echo "Recorded #${ISSUE_NUMBER} at ${short_sha} in the changelog."
-            exit 0
-          fi
-          echo "::notice::push rejected, rebasing (attempt ${attempt})"
-          git fetch --quiet origin "$DEFAULT_BRANCH"
-          git rebase --quiet "origin/$DEFAULT_BRANCH" || { git rebase --abort || true; break; }
-        done
-
-        echo "::warning::Could not push the changelog entry for #${ISSUE_NUMBER}."