Release Notes

This page summarizes user-visible PRFlow changes. For a complete change history, see GitHub Releases. Release cadence: PRFlow versions continuously and publishes releases periodically, so a published version number skips the intermediate versions developed between two releases. A gap between consecutive tags is expected and does not mean a release is missing. Legacy review tier: Entries about automatic pull-request-triggered review apply only to repositories that installed that tier before July 29, 2026. Fresh installations do not receive it. Use a collaborator comment with /prflow:review for the supported cloud review path.

October 26, 2026

/prflow:spec more reliably re-checks the whole draft after audit fixes or a change you ask for, before showing it to you again. (#3274)

October 25, 2026

/prflow:spec can fall back to reading its audit-prompt template directly. The template now carries the boundary markers the reference load rule requires. (#3178)
/prflow:spec and /prflow:implement refute fewer true Verified: quotations that carry \"-escaped inner quotes or that a string join or comment splits across source lines. (#2579)
/prflow:spec’s audit prompt tells the auditor not to report a finding that rests on search output it never saw. (#2829)
/prflow:docs-verify --report-file replies with only the saved report’s path. The two research helpers /prflow:spec starts with do the same. (#2941)
/prflow:spec’s approach question covers each option’s recurring cost. Options can be compared by what each adds to or saves from later runs or uses of the changed system. (#2636)
/prflow:spec more reliably removes scope and acceptance criteria you never asked for. Its check now compares the draft with your story, any issue the story names, and your answers to its questions. (#3174)
/prflow:spec’s re-asked question after research can offer an option in the form the research favors, including one the original menu lacked. (#2830)
Spec asks fewer questions whose options another answer makes wrong or moot. Fewer questions are re-asked after you pick the approach. (#2882)
/prflow:spec’s report after each audit round is shorter. It names each finding briefly, with its grade and whether it was fixed. (#2865)
When /prflow:spec refines an existing issue, it may reword or merge the issue’s acceptance criteria while keeping their requirements. (#3105)
When /prflow:spec revises a draft, it now also corrects text in the investigation record (the comment it posts on the issue) that the revision makes false or outdated. (#3115)
/prflow:spec checks each term its draft creates or redefines against the files the issue names. If one of them already uses the term with another meaning, the draft states the change of meaning or uses a different word. (#2723)
/prflow:spec can end with nothing filed at any implementation-approach question. Choosing No change — file nothing ends the run with no GitHub writes and names any open issue it leaves for you to park, label or close. (#2759)
/prflow:spec’s early risk research treats a past run’s log or record as proof of current behavior only when it confirms which version produced it and what has changed since. Otherwise it reports the link as not established. (#2550)
Implement stops before branch work on an issue that still has its spec ## 🚫 Blocked section. The stop names the remedy: settle each open question in the issue, remove the section, then run again. (#3172)
Before you pick an approach, /prflow:spec can trace a value, text or file the change alters to the code and instructions that read it. It no longer searches only for the changed name. (#2391)
PRFlow’s review no longer drops a defect just because the checked text matches an acceptance criterion’s wording. A criterion excuses a defect only when its words cover the whole case. (#2810)
/prflow:implement no longer adds an “Issue-claim audit: clean” note to the workpad when its check of the issue finds nothing. (#2914)
/prflow:spec records each scope answer you give in full: the option’s text with its description, or your own words. The draft’s scope is checked against what you chose, not a paraphrase. (#3141)

October 24, 2026

Spec states each motivating case’s expected result as what the changed instructions decide for it. For a change to instructions a model follows, the issue names the deciding instruction, can disqualify a case the changed instructions do not decide as the change requires, and says whether a replayed case needs its original run’s context. (#3071)
Spec can weigh removing or reusing a repeatedly repaired design element before repairing it again. (#3145)
/prflow:spec’s approach question keeps a cost comparison when it shortens one into an option’s text. The short text still says whether the option adds or saves cost compared with current behavior, in which cases, and what remains uncertain. (#3138)
Spec audit grading spells out when a false statement or a policy conflict in a draft is a defect. (#3111)
After its second option check, /prflow:spec can still remove a proposed part of an option when its reads show every reason for that part false. The approach question says each removal was not re-checked. (#3099)
Spec audits and non-interactive filing require completed draft preparation. (#3162)
/prflow:review-and-fix can keep a deferred fix-delta finding deferred when the shadow pass raises it again at the same or a lower severity. The shadow pass now recognizes that re-raise as the deferral instead of starting an extra iteration. (#2529)
Background /prflow:spec sessions enter their own worktree before discovery starts. Discovery and risk agents’ report writes are no longer refused partway through, and the run’s records stay in one checkout. (#3019)
Fix passes compare a prose rule with the other rules deciding its inputs before changing it. (#3161)
/prflow:spec can apply an audit suggestion that deletes text or moves it to the investigation record. The approval question counts each applied one among the corrections. (#3020)
/prflow:spec re-reads each Blocked by prerequisite issue before asking you to file. It compares the issue’s title, body, and open or closed state and close reason with what the design used, and revisits the design before presenting when a change affects it. (#2908)
When an issue /prflow:spec drafts asks the implementing run to replay or test with a recorded input spec read, such as a retained payload or transcript, it quotes that input’s deciding fields. The quote is JSON-encoded; a long input is quoted near the failure and cited for the rest. (#2317)
/prflow:challenge judges a change against the user’s goal and challenges its linked issue as part of the proposal. It challenges what the change actually alters first, checks whether anyone relies on behavior the change removes or suppresses, and asks the user when a fact only they hold could change the verdict. (#3218)
The /prflow:spec investigation record can now post a bulleted, indented or wrapped rejected-candidates line whole. (#3114)
/prflow:spec offers to trigger /prflow:implement only when workflows.prflow is set to true. A list value such as ["true"] is now treated as unset, so the offer stays off. (#3180)
/prflow:spec has no clarification question limit. Replying “just create it” no longer stops the remaining questions. (#3143)

October 23, 2026

/prflow:spec checks its own draft the way the auditor will before any audit round. After fixing a round’s findings, it re-checks the whole draft, not only its edits. (#3170)

October 22, 2026

/prflow:spec on Claude Code’s interactive tier waits for a subagent by ending its turn. It resumes on that subagent’s completion notification instead of busy-polling or redoing the subagent’s reads. Headless, nested, Codex and other runs still never end the turn with a subagent pending. (#2847)
/prflow:implement no longer hand-fixes review-and-fix findings after its review completes. (#2482)
/prflow:spec no longer counts a paraphrase or an unchecked conclusion as verified Step 2 evidence. (#2639)
/prflow:implement checks acceptance criteria against your issue’s Desired Behavior and avoids deleting a check your issue keeps to meet one. (#2648)
/prflow:spec asks again about a disproved approach or scope reason as soon as the evidence arrives, and skips needless re-asks. A sub-choice reply now revises the draft without redrafting it. (#2674)
/prflow:spec helper agents read GitHub from your own repository. Helper and audit agents are now told to run GitHub lookups from your checkout instead of naming a guessed repository, and not to read a failed lookup as an empty result. (#3018)
Spec issues cite a rule’s home instead of copying it. The spec self-audit can now revise criteria and other issue text to point at the place a rule is already stated. (#2510)
Review reports can be assembled by a helper from the rendered checklist pieces. normalize-verdicts.py assemble builds the report from the engine’s draft, replacing its token lines with the rendered piece files and placing the issue-compliance file. (#2468)
/prflow:spec’s research peers no longer repeat each other’s whole-repository probes. Discovery owns the repository-wide searches and measurements, both research reports quote their evidence, and later steps can reuse it instead of reading the same sources again. /prflow:docs-verify --report-only reports no longer have a word limit. (#2864)
On interactive runs, spec now runs its option check before a follow-up question that chooses a mechanism inside the picked approach. (#2731)
/prflow:spec reuses earlier option-check findings later in the run. Approach questions repeat fewer risks the options already state, and the drafted issue carries related issues and facts the run already found. (#2942)

October 21, 2026

/prflow:spec runs an audit round on each saved draft before showing it to you, can offer another audit round with no limit, and shortens the filing question. The draft path, audit summary line and other notes move out of the question text. (#2982)
Issues drafted by /prflow:spec state each accepted limit and decision-rule mapping outcome in one place. Fewer copies can drift apart when the issue is revised. (#2383)
Review severity caps no longer promote lower-severity findings. This prevents a Suggestion from becoming a rejection solely because its cap is Important. (#2399)
/prflow:spec revisions can ask more questions or record more blocked decisions. Clarification also searches cited evidence for outcome-deciding terms. (#2989)
Cloud workflow templates follow the Claude Code Action v1 release line. The bundled Claude Code version and model aliases can change between reruns of the same commit. (#2981)
Review-and-fix can reuse unchanged checklist verdicts after a promoted iteration. The review that follows one can carry forward PASSes from the newest earlier iteration that ran Step 1 instead of re-verifying every checklist item. (#2381)
/prflow:implement can fix and re-review findings left by a capped review loop. (#2980)
The /prflow:implement cleanup pass checks rule restatements and coverage claims before review. The cleanup reviewer reports sentences that misstate a rule and coverage claims a search falsifies. (#3040)
Fixes prefer deleting text a review finding flags to rewording it. /prflow:review-and-fix and /prflow:fix can spend fewer re-reviews on text a fix rewrote. (#2344)
The shared writing standard adds a rule to keep each sentence true at the scope it states. Writers that load it are told to keep a condition every case shares and to add no limit the source lacks. (#2621)
/prflow:docs-verify --report-file accepts an absolute path inside the working directory’s .prflow/tmp/. /prflow:spec discovery no longer passes a path the flag’s own rule refuses. (#2918)

October 20, 2026

A plain label bullet such as - Potential Gotchas can now end a - Documentation Needed list item. /prflow:implement no longer treats the paths under that bullet as required documentation edits, nor reads the deliverables written after it. (#2477)
Resumed local /prflow:implement runs continue on the open PR’s own commits instead of a stale same-named branch. Branch setup can now stop the run as Blocked rather than continue on a branch it cannot safely update. (#2813)
/prflow:spec’s option checker sees what discovery found the code actually does. Its risk investigator can also be given the paths of evidence files saved earlier in the session, such as a downloaded job log. (#2667)
Local reviews no longer start building the verification checklist as soon as a checklist generator writes its output file. (#2551)
/prflow:spec Step 1 peers can write their own report files, sparing the run its retype of both reports. /prflow:docs-verify --report-only gains a --report-file flag that writes its report to a .prflow/tmp/ path. (#2666)
/prflow:spec can draft the issue from the risks, corrections and edge cases it recorded earlier in the run, and check the draft against them. (#2527)
A resumed /prflow:implement run re-runs the issue-claim audit without first checking for a reusable earlier audit. workpad.py no longer accepts --record-audit-inputs or reuse-check … audit. (#2451)
/prflow:spec says in an instruction-change issue whether each motivating case is replayed, and /prflow:implement’s pre-review verification skips the replays the issue rules out. (#2689)
/prflow:challenge also asks whether another stage, component or owner would solve the problem more cleanly. (#2915)
Implement’s progress notes describe version-control steps in plain words. Local worktree-isolated sessions are less likely to refuse a progress-note write and spend a call sending it again. (#2744)
/prflow:spec helper agents can lose fewer shell calls on macOS. The instructions a spec run gives its helper agents now include a rule for searching and reading without the wildcard and =-word command shapes zsh rejects. (#2755)
/prflow:spec’s filing preview lists the choices the run made itself, and its audit-round and risk-investigator briefs no longer present agent-written advice as the user’s decisions. (#2577)
/prflow:spec can run fewer repeat option checks before each implementation-approach question. Interactive runs can reach the implementation-approach question sooner and spend fewer subagent tokens. (#2850)
/prflow:implement replays the old instruction text before any new-text replay of a case the fix exists to change, and skips new-text replays that cannot tell the old text from the new. Replay actions can be graded from the replay’s own tool-call record. (#2638)
A case an acceptance criterion accepts can now stop failing checklist verification. /prflow:spec now writes each accepted limit an issue states into an acceptance criterion. (#2682)
Review-and-fix can send Suggestion and Minor findings about its own fixes back to the fixer at any threshold. A defect a fix introduces can be fixed in the same iteration, before the merge review sees it. (#2907)
/prflow:spec can read to settle a fact the option check left unconfirmed before it asks the approach question. The question then states what that read found, so a disproved fact can change an option or bring back a passed-over approach before you pick. (#2717)

October 19, 2026

/prflow:spec can recommend an approach option that rests on an unconfirmed fact. The question still shows each such fact as not confirmed. (#2562)
On Windows Git Bash, /prflow:implement’s issue audit and /prflow:fix can read a file as the base branch has it. They now read it by commit ID, so git no longer answers “Not a valid object name”. (#2790)
On native Windows, PRFlow’s Python helpers now launch the first bash.exe in a fully qualified PATH folder rather than a bare bash, and give a bash.exe in a System32, Sysnative or WindowsApps folder absolute paths in WSL’s /mnt/<drive>/… form. With no such bash.exe they launch bash. Set DEVFLOW_BASH to choose a bash explicitly. (#2792)
On Windows, a review run no longer deletes or moves files through a symbolic link at its shadow review directory. It acts on the symbolic link itself, not on the folder it points to. A directory junction there is still followed (#2808). (#1193)
/prflow:spec’s approach question marks facts the run confirmed itself and labels fewer unbacked facts as backed. Spec can skip an option-check re-run before asking. (#2650)
/prflow:spec’s option checker can write its own record, and returns the findings that bear on each option for the implementation-approach question to disclose before you pick. (#2578)
The /prflow:spec issue template tells drafters to name no other issue in a Blocked by reason. (#2805)
The /prflow:fix skill defers local test execution to repository policy. (#2805)
/prflow:spec collects a subagent’s result before continuing, instead of waiting for your next message. (#2844)
/prflow:spec’s filing question can show the draft path, the audit summary, the unfixed audit findings and the self-audit summary. (#2363)
Review-and-fix passes re-check fewer settled checklist items. A passed item on a file a fix edited can now keep its earlier result. (#2353)
/prflow:review-and-fix and /prflow:fix can restate a prose rule as one general clause instead of adding the case a finding says it missed. (#2523)
Reviews fail correct code less often over a checklist claim the review worded itself. Correct code is less often sent back to be fixed over a requirement only the reworded claim stated. (#2580)
Generated pull request titles describe the implemented solution. (#2848)

October 18, 2026

/prflow:review-and-fix can list a shadow review’s new low-severity findings in its ## Coverage report, and can decide “shadow agreed, full coverage” from the findings the loop recorded. A run no longer picks a route by hand for a shadow that adds only low-severity findings. (#2251)
Spec’s scope and side questions can name evidence against their recommended answer. You can see what the run already read that argues against the recommended option before you choose it. (#2513)
/prflow:implement passes the review-fix worker the digest of its latest prompt-extension check. A Phase 3 base-update merge that edits the extension no longer stops the run at the worker’s digest check. (#2564)
Implement runs no longer put their 🎉 or 👎 reaction on an unrelated comment that only mentions the command. (#2484)
/prflow:spec can drop a case its own revision added and state the case as a limit, rather than patch it. A fork question that fixing a finding raises about how to handle a case also offers to leave that case uncovered. (#2541)
/prflow:spec and /prflow:docs-verify --report-only treat cut-short output as an incomplete search. (#2369)
/prflow:review-and-fix declines a Suggestion or Minor finding only for a listed reason, and a later fix can re-check an earlier decline. (#2343)
Local reviews can spend less time waiting on checklist verifiers. A verifier asked to save its verdict is told to finish any check it is still running first. (#2519)
/prflow:spec can keep your assignment and implementation answers across its approval prompts instead of discarding them. A later prompt can show a kept answer, and you can change it before you approve. (#2664)
/prflow:spec walks each motivating case and named rule arm before asking for the design, and /prflow:implement keeps replaying the cases an issue names instead of swapping one out. (#2318)
/prflow:spec’s failed reference-load fallbacks are shorter and report what they skip. A run whose reference file fails to load no longer gets compact copies of that file’s checks, such as the contract and premise checks, and says which coverage it lost. (#2521)
Cloud review, review-and-fix, PR-description and retrospective runs’ built-in gh api grant now covers only your own repository’s endpoints. The built-in list no longer grants gh issue create, gh issue comment, gh pr comment, gh pr create, env or export; re-run the installer to pick this up, and upgrade prflow_version first or together with it. (#2672)

October 17, 2026

/prflow:review-and-fix <PR> reviews a branch that carries unpushed local commits instead of stopping. With --push-each-iteration, those earlier local commits are now reviewed with the PR and pushed with the first fix push. (#2068)
Local /prflow:implement runs without a vendored plugin copy spend fewer tool calls in the intake, review-fix and finalization workers. Intake and finalization no longer make a separate digest call, the three workers skip the vendored helper path once the run has found it missing, and the documentation and PR-description children are told the vendored folder is absent. (#2454)
/prflow:spec can ask the implementation-approach question again after you pick, so you choose with the corrected facts instead of approving a patched design. (#2539)
The comment analyzer can grade an unchanged instruction line your change makes false as Critical. (#2241)

October 16, 2026

Review-and-fix keeps a parked finding parked when the shadow review only adds new evidence. Before, a re-raise at the same or a lower severity with a different explanation reopened the fix loop just so the finding could be parked again. Now a different explanation alone no longer reopens it, and the new evidence is still recorded with the decision. The gate’s other promotion conditions still apply, for example a higher severity, a mis-grade rule match, or a missing or malformed input. (#2335)
Spec revisions route attacked text before composing a repair, including when an audit supplies no remedy. For example, when the issue template permits removal and that resolves the finding, the brief gets no replacement incidental claim. Needed statements are edited before adding explanation. (#2323)
Checklist verifiers receive absolute artifact paths for the reviewing checkout, reducing ambiguity when reviews run in worktrees. (#2321)
Implement skips a redundant telemetry save after review-and-fix. When the review-and-fix loop’s own exit save already reported persist-outcome: ok skipped for this run and nothing relevant changed since, /prflow:implement reuses that result instead of running the same save again (about 10 seconds in the recorded case). Missing, failed or uncertain evidence still runs the recovery save. (#2113)
The telemetry self-check follows the telemetry.enabled master switch. With the master switch false, lib/efficiency-trace.sh --self-check now stays silent even when efficiency_telemetry_enabled is explicitly true, matching --persist, which already skips the telemetry branch in that case. (#2113)
A run whose iteration records are all malformed now reports persist-outcome: lost partial-iterations instead of ok skipped, so the loss is no longer mistaken for telemetry being switched off. (#2113)
Review findings cite source-file lines, not patch positions. /prflow:review reviewers now number each finding’s lines, and its defect_signature.line_range, by their one-based lines in the file they read. A position in the patch never counts as a source line. Content missing or deleted from the current file is described without a current-file line, and its range stays null when no current-file span can be located. A base-file line is marked as base. A location whose file cannot be read, or whose line cannot be found, is marked unverified. The /prflow:implement cleanup reviewer also numbers each line one-based from the current working-tree file, never by patch position, and marks a location unverified when its file cannot be read or its line cannot be found. (#2092)
/prflow:review-and-fix checklists no longer restate earlier iterations’ findings. From the second iteration, the review’s checklist builds no item from the earlier findings passed to the review, so no item restating one overrides the reviewers’ decision not to raise it again. The reviewers still decide whether such a finding stands, and are told to report again a fix that did not work. (#2374)
Report shadow review limits accurately. Shadow reviews write into a separate directory to reduce accidental discovery of prior findings. Reports no longer claim verified shadow agreement when the engine ran inline in the loop’s informed context; separate writes do not isolate reads. (#2244)
The review engine no longer retypes resolved acceptance criteria into its return. When a review resolved one or more criteria, the engine leaves them out of the part it writes and the return assembler (review-dirty-tree.sh engine-return) fills acceptance_criteria from the resolver’s criteria.json, so each review entry spends less time on output and later fixes see the resolver’s exact text. When that file is absent or unusable, the assembler says so and the engine writes the criteria itself. (#2145, #2481)
Keep defects a checklist verifier finds outside its claim. A verifier that passes a narrow claim can now also report a separate defect it found while checking it. The review lists that defect with the ordinary findings and the fix loop routes it, where before it was lost in the passed item’s evidence. (#2240)
Review fixes use a focused class search. The review-and-fix loop no longer loads implementation sweep procedures for each correction, reducing the reference reading needed for small fixes. (#2111)
/prflow:implement’s review step no longer keeps the review extension loaded for its whole run, and a failed review extension load now shows on the workpad. The review-and-fix worker loads only the implement extension. Each review loads the review extension itself, including a review that runs inside the loop when its own dispatch fails. The workpad no longer has a Skill extension resolved: review.md row, and an older workpad’s unticked row of that name no longer blocks Complete or the reuse of a finished review. When a review reports that the review extension or a reviewer’s extension failed to load, was refused or could not be established, /prflow:review-and-fix records it in its reflections, once per extension each time the loop runs, and an implement run also writes it to the workpad; if that write fails, no workpad or pull request records the failed load. A review extension that fails to load no longer stops an implement run before its review; the review runs without that policy and reports the failed load. (#1796)
/prflow:implement can now delete a doc sentence its change makes false, or point it at the rule it describes, when readers do not need it where it is. (#2337)
An implement run no longer runs an extra shadow review just because a review check could not settle an acceptance criterion. Inside /prflow:implement, the review-and-fix loop skips its shadow pass when its first iteration is clean. An inconclusive check on an acceptance criterion, for example one that needs a command run or a CI result, no longer makes that iteration unclean; implement’s acceptance-criteria gate, whose verifier can run commands, checks such a criterion later in the run unless it is tagged (post-merge). An inconclusive check on anything else, or any failed check, still rules the skip out. (#2457)
/prflow:spec checks each design option against what the run recorded before asking you to choose. Before the implementation-approach question, a separate subagent with a fresh context reads what the run recorded. It checks each option, and each candidate the run dropped, for facts a recorded risk, constraint or edge case qualifies and for facts no checked record confirms. The question then names the ones that bear on each option. An option that rests on an unconfirmed fact is no longer marked (Recommended), unless your repository’s prompt extension sets its own recommendation policy; a fact whose kind is unclear is shown but keeps the mark. When the separate check cannot run or returns an incomplete or malformed result, /prflow:spec runs the same check itself and the question says the independent check did not run. The self-audit before the draft is shown also checks the draft against the chosen option’s listed risks and unconfirmed facts. (#2358)
/prflow:review-and-fix reads a smaller review result after each review pass. The review engine’s return file now writes each passing checklist row with only its id, verdict, severity, claim signature, verification mode and reuse fields; failing, inconclusive and other rows are written whole. The loop reads that file after every review pass and keeps it in context for the rest of the run, so each iteration costs fewer tokens. The full passing rows stay in the run directory’s retained checklist and verification files. (#2474)
A review finding that only argues against a decided acceptance criterion no longer rejects a pull request that meets its criteria. When prflow_review.verdict_severity_threshold is important or suggestion, a finding below Critical whose whole claim is behavior a decided criterion requires, or that asks for what a decided criterion excludes, gives APPROVE with notes instead of REJECT. It stays in the report at its grade, marked [decided by criterion <N>]. Some still block, for example a Critical finding, a finding that is partly a real defect, and one whose relation to a criterion is unclear. Inside /prflow:review-and-fix the fix loop routes such a finding to the fixer whatever the fix threshold, until its iteration cap. Repositories on the default critical threshold see no change. (#1793)
/prflow:spec no longer shows a FILE verdict that no auditor gave. The audit summary line no longer carries a FILE or REVISE value, and the approval question now says how many must-revise findings were fixed after the last audit round and whether the final draft was audited. (#2392)
Code review no longer passes or fails a checklist item on a line its search did not show. The checklist verifier reads that line in full before grading on it, and reports the item inconclusive when it cannot. (#2470)
/prflow:spec posts the investigation record on an existing issue it updates, as it does on a new one. An updated issue also gets the PRFlow label and the assign and implement questions. (#2494)

October 15, 2026

Checklist verification no longer executes shell commands. Verifiers inspect the supplied source snapshots and PR diff, and report INCONCLUSIVE when a claim needs execution or missing evidence. This removes live shell and API probes from checklist verification. (#2311)
Clarify spec choices, question dependencies, audit verdicts and publication rules; consolidate existing guidance and keep maintainer evaluation tools out of consumer installs. (#2310)
/prflow:spec’s fresh-context auditor walks the change instead of scanning for text shapes. The Step 3.6 audit prompt replaces its eleven-dimension checklist with a five-step walk — readers of removed or changed text, arms of added mechanisms, outcome, premises, criteria — under one bar for every finding: the quoted text, a concrete case, the wrong outcome and the read that shows it. The auditor returns findings only, never replacement wording; a universal claim is a defect only by counterexample; criterion placement, restatement and authoring-shape rules stay with the drafter. Live watches had found about three real defects among fifteen findings per run, most later-round findings attacking text an earlier round’s remedy added, and one triage batch’s review rejections all deletions or reworded arms nobody had walked. (#2315)
/prflow:spec researches choices you delegate. “You decide” or “I don’t know” makes it research the question and re-ask it with each option’s pros and cons and, where the evidence supports one, a recommendation. A second such reply takes the recommendation, except that it files a new issue rather than widening one and keeps a requested case in scope; with no recommendation, the question goes to Blocked. Each settled choice is named in chat and again before draft approval, or in the final outcome when it ends the run without filing. Delegating a question it recognizes as needing facts only you know sends it to Blocked without research; “just create it” and the question limit still end clarification. (#2301)
The review-and-fix fixer changes code for a failed checklist item only when it finds a real defect — The /prflow:review-and-fix fixer reads both the cited source and the requirement behind the claim before editing. Accurate evidence for a requirement the code does not have to meet is pushed back as claim-quality, a misread is still pushed back, and a read that settles none of these is pushed back as uncategorized, naming what could not be established. (#2259)
/prflow:review-and-fix can report a fix that did not work. When the previous iteration’s findings reach the review that opens an iteration, that review is told that a finding marked applied records a fix attempt, not a resolved defect, so it can report the finding again while its defect remains. Findings with any other decision are still re-raised only with new evidence. (#2260)
Review agents report defects, not fixes — PRFlow’s review agents and the fix-delta reviewer now give each finding’s file and line and what is wrong, and suggest no fix, deletion included. The fix loop chooses each fix itself, so it no longer applies a PRFlow reviewer’s ready-made fix that adds text and draws the next finding. (#2141)
Review checklist items fail less often on inputs that decide nothing. The checklist verifier now counts a counterexample only when a shipped caller or documented state can produce its input and that input reaches the code or text the claim is about; documented states include, for example, an input anyone outside the repository or a process can send, or a file can carry, through a public interface without a code change. Any other input decides nothing, so the item passes on positive evidence or comes back inconclusive; an input whose producer or reach the verifier cannot settle makes it inconclusive. The generator no longer words a claim around the input in its hint. Reviews raise fewer false FAILs, and the fix loop makes fewer edits to working code. (#2118)
Spec pairs current-state discovery with independent early risk investigation. The second parallel peer now checks request-specific assumptions and conditional failure paths before clarification and approach selection. Discovery keeps its complete coverage contract, failures retain usable evidence with explicit gaps, and the later draft audit remains unchanged. (#1832)
Discovery and planning follow your selected model. Code Explorer and Code Architect use the implementation run’s model by default. You get this through the normal plugin update. (#2380)
Faster /prflow:review-and-fix iterations. The reviewer that checks each fix now loads your review-and-fix extension itself, so the loop no longer copies the whole extension into every check. That saves about 30 seconds per check for a 9–10 KB extension. The reviewer applies the extension only when it loads a copy matching the one the loop loaded; otherwise it reports the check as not verified. If your vendored PRFlow is too old to report the extension’s fingerprint, these checks run without your extension, and the loop says so in its reflections until you upgrade. Review loops without a live progress comment, such as those /prflow:implement runs, also stop saving review-agent output files that nothing reads, so verification starts sooner. Standalone reviews and their PR comments are unchanged. (#2119)
Local review retry rounds no longer idle on a verifier that already replied. On the local tier, the wait after a /prflow:review refused-launch retry round now expects only the verifiers that round started and earlier ones that have not handed back. A verifier that handed back without writing its verdict goes straight to delivery recovery, saving about 60 seconds per affected retry round. (#2269)
/prflow:implement Phase 2 skips the code explorer when the orchestrator’s own reads of the requirements, audit findings, documentation map and current source establish that no question about existing behavior or affected consumers remains; otherwise it dispatches the explorer for the remaining questions. A dispatched explorer answers just those questions with findings that change the plan or expose consequential uncertainty, states it found none, or reports what it could not complete (#2014).
Local implement and review-and-fix runs stop spending calls that always fail. PRFlow’s subagents now carry the cloud’s refused command shapes in their own instructions instead of reading .prflow/tmp/command-shapes.md; only the review engine still reads that file, in the same message as its first other Read. After one decisive miss on the vendored extension loader or review skill, a subagent skips .prflow/vendor/prflow/ for the rest of its run. /prflow:implement skips its vendored-version check once its start-up probe has found no vendored folder, and the review engine looks up both vendored engine locations in one step. Cloud runs keep the vendored path first. (#2147)
Spec reduces unnecessary preservation criteria. For example, when your request is readable, a file’s presence in the planned changes no longer justifies freezing it, and guarantees already required by project guidance stay with review. Requested restrictions keep their scope and form. If you need something kept as it is, say so in your request. (#2116)

October 14, 2026

Removed the review-skills refactor’s unused helper surfaces, effort-telemetry fields and workflow step. checklist finalize … --no-groups now exits 2 with the helper’s usage error, resolve-review-overrides.py --effort-json is refused by its argument parser, and the view-materialize subcommand is gone from both review-dirty-tree.sh (exits 2, unknown subcommand) and review-engine-io.py; engine setup still builds the source views, and the producer’s stderr summary line now starts source-view: with the same fields. The fix loop’s iteration record drops dispatched_effort, so install-record refuses a draft that still holds it, and the telemetry record drops its per-iteration agent_effort block and dispatched_effort_present flag while staying at schema_version 1. The cloud workflows lose the inert Export provider effort capability to job env step that wrote PRFLOW_EFFORT_SUPPORTED; --effort is still gated on the provider step’s effort_supported output. The config backfill no longer carries its never-firing Haiku effort guard; the cleanup pass still removes effort from a Haiku-pinned agent_overrides entry. Mixed versions get no compatibility path: older skill text calling a removed surface, or writing dispatched_effort, fails against a newer helper copy. (#1884)
/prflow:spec’s Step 3.5 self-audit reports less. Its summary now lists what it found, what it revised for each finding, and anything it left unfinished or unverified. It no longer asks for a line per check that found nothing. The checks themselves still run. A spec prompt extension that cites the removed per-check lines or counts should stop citing them. (#2090)
/prflow:spec now runs a pre-mortem on its design for the whole run. From the first candidate approach until the run ends, it asks what the fix could break, checks each failure mode against the code, and drops the ones the change cannot cause. The approach question now lists each option’s failure modes beside its limits and cost, so you can choose around a gotcha before the issue is drafted. (#2262)
/prflow:spec asks for fewer evidence states when the evidence is prose a model reads. When a draft lets evidence excuse a case from a rule, or loosen, skip or demote its outcome, and that evidence is prose a model reads (a line in another agent’s reply, for example), the draft now covers the cases the issue template already routes for a value an agent reads: absent, its producing step failed, or unresolvable. Before, it had to cover four states: missing, malformed or wrong-type, produced by a step that did not run, and unreadable. Each case still keeps its previous outcome unless the request names it, and a new rule still states each one’s outcome. Evidence a program parses, such as a file or a field, still covers all four. (#2237)
/prflow:spec lists each clause of the text an issue changes. When a drafted issue deletes, replaces, moves, rewrites or exempts a case from text with more than one clause, arm or ordered step, whatever the draft calls that text, the investigation record lists each clause, arm and step by its quoted opening words as kept, moved to a named place, or removed, and the acceptance criteria name each one that is moved or removed. The Step 3.5 self-audit checks the issue body against this rule. Before, the rule applied only when a criterion’s subject was a rule, so it missed text a draft called reporting. (#2238)
/prflow:fix stops unless you are on the pull request’s branch. For a bound pull request, the pass now stops, changing nothing, unless the current branch is the pull request’s headRefName or tracks it (refs/heads/<headRefName> or refs/pull/<n>/head); a detached HEAD stops too. Before, a branch stacked on the pull request passed and received the fixes. The branch update now merges only the base branch for a pull request, and the final branch-sync report measures the head against a fresh headRefOid read instead of a remote branch fetched by name, which on a fork pull request was absent or the wrong branch. (#2219)
/prflow:spec revisions no longer print a revision-delta census. The revision check still verifies the facts each edit introduces, keeps a refuted or unverified fact out of the draft, and checks and corrects draft consistency; it no longer requires the per-class walk, falsifiable-zero entries, locator log or the closing revision-delta check: line. (#2091)
review no longer runs pr-test-analyzer on a diff whose changed files all have config-only extensions (.md, .json, .yml, .yaml, .toml, .ini, .lock, .txt) just because a path contains test or spec, such as a Markdown-only edit under skills/spec/. A test/spec path in any other file still marks the diff as test-relevant. (#2120)
/prflow:implement’s relocation sweep runs its cross-line search without the Grep tool. When the session has no Grep tool, the sweep now runs its cross-line phrase search with rg -U --hidden instead of recording that search unrunnable; it is unrunnable only when neither form can run. (#2256)
Review agents search the whole source view. The six /prflow:review reviewers and the checklist verifier now search a review’s source view including hidden paths such as .github/, .prflow/ and .changeset/ and files an ignore rule matches. Before, the search forms these agents used could skip those files, so a reference a change left behind in one of them could pass review. Searches of the working tree are unchanged. (#2242)
/prflow:spec Testing Strategy records gathered evidence, not what the implementing run can verify. The issue template now asks a draft to record the evidence already gathered and its limits, leaving to the implementing run whether to gather more, instead of disclosing evidence unavailable on the target environment and a resulting readiness limit. (#2268)
In-run reviewers no longer report Documentation Needed pages and Testing Strategy results as missing. Under /prflow:implement, the review brief now states that the run writes the issue’s Documentation Needed pages after review and records Testing Strategy check results on the issue workpad, so neither is a finding when absent from the diff or PR description; an existing line the diff makes false, and a test the Testing Strategy asks the change to add, are still findings. Standalone /prflow:review and /prflow:review-and-fix briefs are unchanged. (#2234)
/prflow:spec: the contracts quality group’s universal-quantifier row and its degraded copy now accept, as scoped with no rewrite, a universal claim about current code that a read confirms (each text states its exact conditions) (#2231).
/prflow:pr-description now finds the current branch’s pull request and updates its body in place, including the deferred review findings it previously missed. When it cannot tell whether the branch has a pull request, it reports why and leaves the pull request body unchanged. A comment-triggered cloud run still starts on the default branch and does not update the body (#2243).
A wrong checklist claim over correct code is settled in one answer. The review’s checklist verifier now reports one of four verdicts: PASS, FAIL, INVALID or INCONCLUSIVE. INVALID means your code is right and only the checklist’s own generated claim is wrong; on an item whose claim the checklist wrote, other than an acceptance-criterion check or a re-check of an earlier finding, the review records a wording-only pass at once, instead of sending the item to a second verifier whose answer could turn a non-issue into a rejection. Reports no longer carry a “Checklist errors” line: no failed checklist item is set aside from the verdict any more. Scripts that call the bundled normalize-verdicts.py helper’s prepare, collect, render or reverify-add directly must now pass --contract 2. (#2138)
preflight.py lint-changed --fail-on-findings prints where each failing linter’s output is. Directly after the LINT-CHANGED findings ops=<ids> line, it prints one LINT-CHANGED op=<op id> receipt=<path> line per id, in the same order. <path> is the absolute path of the receipt this run wrote for that op, with forward slashes on Windows; when the linter ran, the receipt’s findings field holds its output, so a caller no longer searches the receipt directory. A receipt path containing a line break is not printed, and the run exits 2. Other output and exit codes are unchanged. (#2140)
/prflow:implement checks a criterion about prose by reading the prose. At the final acceptance-criteria check, a criterion about what a skill, agent instruction, document or comment says is now tagged source-read. Its verifier passes it on a read of that text at the run’s head, with a pointer to the lines read and how they cover the criterion. It no longer needs an unrelated lint or test run that proves nothing about the text. A criterion about a refusal or rejection, a program’s output or exit status, or a measured value still needs an executed command, as do test, lint and build criteria. When the verifier reports that a source-read or non-command criterion needs a stricter kind of check, the run re-checks it under the next stricter class (non-command, then command) instead of routing it to the fix, rewrite, defer or Blocked steps. Only a run whose start-up check finds the vendored copy at the plugin’s version, or finds no vendored copy, uses the new class; on any other outcome those prose criteria stay non-command, as before. (#2246)
/prflow:implement runs its cleanup pass in Phase 2, before the sweeps and tests, and deletes, merges or rewords text only when every outcome of it that an acceptance criterion, a scope decision, a plan step serving one or a remaining rule still needs survives the edit. Phase 2’s sweeps, tests, motivating-case replays and commits now cover the cleanup’s edits; there is no separate refactor: cleanup commit and no cleanup step after the draft pull request opens. A finding PRFlow cannot confirm stays unapplied, is recorded on the workpad and never blocks the run. (#2236)
Review agents filter searches by file type without a glob. The /prflow:review reviewers narrow a search by file type only with rg -t <type> (for example -t md). Before, zsh could refuse an unquoted --include=*.md before the search ran, and a shell could expand an unquoted -g *.md into the wrong files, so local runs wasted calls. (#2142)
/prflow:spec asks when a word in your request means something different in your repository. Before its first clarification questions, /prflow:spec now compares the words in your request that name a thing, its owner, a state, a scope or a relationship with what those words mean in the evidence it already gathered and in glossary.md at your internal-docs root. When a word means something else in your repository, or could name more than one thing there, and the difference changes, or may change, what gets built, it asks you which meaning you intend before writing the acceptance criteria, unless your request already states its meaning and names the repository meaning it replaces. Words that match cost no extra question, and a non-interactive run lists these questions under the issue’s Blocked section. (#2302)
/prflow:review can now treat a finding already rejected on the pull request as settled (#2299). /prflow:fix, and the /prflow:review-and-fix fixer on a numbered pull request run with --push-each-iteration, can record an evidence-backed rejection as a Finding rejected "<finding>": <evidence> line in the PR description, and /prflow:pr-description keeps those lines. When the PR author is the GitHub Actions bot or trusted under allowed_bots/allowed_users, later reviews of the pull request read the lines as evidence that a finding was already judged not a defect, and the report’s Run details quotes each counted line. A custom implement App that authors pull requests must be listed in allowed_bots for its lines to count.
Refactored spec’s existing consistency and dependency checks: drafts and revisions compare affected statements on the same cases, and reused components are checked for the behavior their consumers need. (#2309)

October 13, 2026

The review’s checklist generator is now told to write its output file once, as its last step. A local review does not wait for a generator to finish before reading its file, so a generator that saves a draft first can have that draft rejected and retried, or merged with claims missing. (#2133)
Effectiveness telemetry now defaults off for new configurations and unset runtime values. Opt in with prflow_review_and_fix.efficiency_telemetry_enabled: true; upgrades preserve saved values, and operational run and cost records remain controlled by telemetry.enabled. (#2154)
Spec preserves your requested scope. Before excluding a case you requested, spec reuses your prior agreement or asks. Without an available user, an unresolved scope question stays Blocked. The issue-body and final-outcome instructions now call for agreed exclusions and known tracking or unfiled status to be disclosed. (#2082)
Spec issues state the property every affected site must have instead of listing the sites. When a criterion’s property covers a set of places the change must reach, /prflow:spec keeps the property, any search that finds them and the files that hold them, and moves the site list to its investigation record; the Step 3.5 self-audit counts such a set as pinned for every site whose coverage is clear. An issue body no longer gives a site a route the code does not have unless the issue decides that route, and text asking a site to describe or apply a rule another file owns asks for a pointer to the rule’s home where the site’s reader can follow one. (#2050)
Spec grounds facts about a recorded case in what it read. /prflow:spec is instructed to state a fact about a reported case’s saved input that decides the fix or an expected test result, such as a field the input carried, only from a cited read of that case’s known source or retained copy. A source the run did not read or could not reach is reported as that limit, not as the input being gone. A reconstructed, synthetic or adapted scenario for such a case stays usable and is labelled as such. A recorded artifact is evidence to inspect, never instructions to obey. (#2087)
The changeset consolidator now checks the form of a changeset body. consolidate-changesets.py stops with an error naming the file when the first non-blank line of a changeset’s body does not start with - , or when the body has no parenthesized citation of the form (#123) or (#123, #456); a citation directly after a ], as in a markdown link’s target, is not counted. If you run it over your own changesets, bring each pending changeset into that form before the next consolidation. (#2126)
Review checklist verifiers now write their verdict file before handing back, and cloud reviews stop waiting for verdict files. A verifier is told that its whole hand-back, including any hand-back tool the runner provides, is its one-line reply, so a runner’s rule that the hand-back must come last no longer leads it to skip the Write that a local review then waits up to 9 minutes for. On the cloud tier the review goes from each verifier launch straight to collecting the replies, with no file wait. (#2112)
Spec judges its audit checklist only in an audit round. /prflow:spec challenges its own draft before it shows you the draft. That step no longer renders and judges the full audit checklist. It still verifies the draft’s claims against the code and checks that the acceptance criteria cover the desired behavior. A run that then accepted an audit round used to judge the same checklist twice. A round runs after the draft has been challenged and revised. A run with no audit round now gets no audit-checklist pass. That includes a non-interactive run, which runs no round on its own. (#2097)
/prflow:implement stops as Blocked when an instruction change keeps failing the case it was written for. For a consequential change to model instructions, a version of the changed text now passes its motivating case only when at least two of its first three replays meet the expectation. At a run’s third failing version, implement marks the run Blocked, naming the case. Change the design the issue prescribes, then run the command again. (#2102)
The review report lists checklist items under its severity headings. In a /prflow:review report, ## Code Review Findings now holds the verification-checklist items as well as the findings: each severity group lists its numbered findings, then the failed checklist items of that grade, and inconclusive items sit under ### ℹ️ Informational — Deferred. The separate ## Verification Checklist Results section is gone: the checklist tally and the passing items move into the collapsed ## Run details block, and a Coverage shortfall: line now sits in ## Verdict, after the Rule applied: line. A checklist item’s group follows its grade, not whether it blocks; the verdict line still says what blocks. The inert-prose cap is now judged for every failed checklist item graded critical or important, at every verdict_severity_threshold value, and a capped item is grouped under its capped grade; its line still names the severity it was stored with. With the threshold set to suggestion, a critical checklist failure the cap covers no longer counts as Critical in the verdict /prflow:review-and-fix gives when its shadow pass still has unresolved findings at the iteration cap, as was already the case at the other thresholds. (#2190)
/prflow:implement Phase 3.4 now passes the evidence verifier the path of the validated Phase 3.3 review-fix handoff when that handoff lists unresolved findings, and the verifier checks each unresolved_findings entry against the criteria as a candidate counterexample: one describing a case inside a criterion’s stated terms makes it unmet when reproduced, or unestablished when it cannot be settled; a refuted entry, or one describing no case inside any criterion’s terms (a criterion-conflict dispute included), changes nothing. A handoff that was passed but cannot be read or lacks that array leaves every criterion unestablished. A criterion such an entry made unmet takes the gate’s fix: commit and re-verification like any other; the gate does not review that fix. /prflow:review-and-fix’s rule that a caller fixing the findings left unresolved at the iteration cap re-establishes independent coverage over the fix now allows a fix the caller’s own instructions except. (#2125)
Merged review checklist items quote the place they point to. When a review writes its checklist in several batches, each merged item now comes from one claim, keeping a claim that quotes the source when the group has one, so the quote, file and line always match. An item whose provenance value is a list or an object no longer stops the checklist step. (#2203)
A false comment about an input no code sends can now be capped as wording. When a checklist item fails at important because a comment or docstring overstates what uncalled code handles, the behavior-inert prose rule can now cap it if, among other conditions, a caller search finds no caller. It can still reject, for example at the important threshold when a tool or agent reads that comment or it reaches readers outside the repository, or at the suggestion threshold. A capped item’s evidence names the caller search and its result. (#2218)

October 12, 2026

lib/efficiency-trace.sh --correct-iter is removed; a caller now gets exit 2. The manual repair of a malformed iteration record already saved on the telemetry branch had no caller in PRFlow. --correct-iter and its four operands, --run-id, --iter, --corrected-file and --expected-digest, are now refused as an unknown argument with exit 2, under any action. Called without those operands, --persist and --self-check work as before, except that the --persist warning for a run whose effectiveness record omits a malformed iteration no longer names a repair command; that run still reports lost partial-iterations, and its record can no longer be repaired in place. (#2152)
Recover missing verifier files before repeating a review. Reviews request a missing answer file once from its original verifier and preserve existing findings when delivery fails. Missing evidence remains unverified. You get this through the normal plugin update. (#2136)
Serious fix-delta review findings, pushed-back ones included, no longer take the clean-iteration shortcut. The clean fast path is kept, and gate pushbacks are reported even when another gate outcome takes precedence. A later fix or disposition in the same iteration supersedes the earlier deferral; calibration and other bookkeeping retain it. Historical review evidence is preserved.
lib/efficiency-trace.sh --mode record is removed; a caller now gets exit 2. The mode printed the per-run effectiveness record to standard output and had no caller in PRFlow. --mode, with any value or none, is now refused as an unknown argument with exit 2, under any action. A call with neither --persist nor --self-check prints a usage message naming both on standard error and exits 2. --persist still derives the same record and writes it to the telemetry branch, and --self-check is unchanged. The mixed-source warning, which only record mode printed, is gone. (#2153)
A review no longer rejects a pull request over a guarantee nobody wrote. The review’s checklist now drops an absolute claim (“never”, “every”, “cannot”) that does not quote the change’s own text, so it is never checked or graded. Other checklist items are checked and graded as before. (#2084)
A failed checklist item the fix loop declined no longer keeps rejecting later iterations. From its second pass on, /prflow:review-and-fix used to carry the previous pass’s failed checklist items into the next one and check them again, so a failure the loop had declined to fix failed again and held the verdict at REJECT. Now only a passed item can carry over, keeping its earlier result when, among other conditions, its cited files are unchanged. A defect that remains is left to the checklist built fresh at each pass, the fix-delta check and any later /prflow:review. (#2148)
/prflow:spec audit rounds no longer pay for bookkeeping. An audit round now costs one auditor dispatch and your reading of its findings. The audit state tool and the staged draft write are gone: the run keeps one working-draft file, which it edits, presents, audits and posts as the issue body, with the title in a file beside it. The audit summary line is shorter. It shows rounds run, the must-revise, advisory and invalid counts, the unresolved must-revise count, and whether the draft is byte-for-byte the one the latest verdict round audited. One Create option replaces Create it as-is and File anyway. After filing from the saved draft file, PRFlow reads the issue body back and reports whether it matches the draft. (#2077)
Review-and-fix stops paying an extra round for fixes that cannot change a REJECT. When an iteration that ends in REJECT otherwise converges, the loop now runs another iteration only when that iteration fixed one of the items driving the REJECT, or when it fixed something and the REJECT drivers or fix records cannot be confirmed. A fix to any other finding, whatever its severity, no longer forces that extra review by itself; when the fix-delta check runs, it still reviews them. (#2151)
/prflow:spec fresh-context audit rounds are now told which issue the run amends and the choices you made. The fresh-context auditor receives the number of the issue the draft replaces, when the run amends one, and the decisions you made during the run, and is instructed not to report that issue as the draft’s duplicate and to name the decision, and the defect that justifies reopening it, in any finding that argues against one of your choices. Each audit round also no longer generates a separate instructions file first, and its return file is always under .prflow/, even in a checkout that still has only a .devflow/ directory. (#2105)
/prflow:spec no longer pushes approach recommendations toward stronger enforcement by default. Step 2 used to require a deterministic candidate whenever you proposed a wording change, to name the strongest mechanism it could find, and to step its recommendation up whenever the problem did not say a failure was tolerable. It now considers the relevant alternatives and recommends the least costly approach the checked evidence supports, explaining that approach’s limits and maintenance cost; an unclear requirement is asked about rather than answered with a heavier mechanism. (#2089)
Verification now matches the change’s risk and existing coverage. Implementation and fix runs can reuse sufficient coverage or direct checks instead of always adding tests first. Reviewers focus on consequential gaps, while your repository’s testing requirements and agreed criteria remain binding. Reproducing bugs with a failing test stays preferred, and reported results distinguish completed checks from unavailable evidence. (#2187)
Safer proportionate verification. Unresolved checks require sufficient evidence before a fix is reported resolved. Mutation-backup recovery preserves later edits, and coverage reviews distinguish consequential gaps from optional improvements. (#2195)
Review-and-fix records less bookkeeping and reports accurate applied-fix counts. Opt-in effectiveness telemetry now counts applied decisions, reports unknown input as unestablished, and no longer labels fix-applying iterations as adding nothing. (#2122)
Review agents assess the prepared diff and read each acceptance criterion once. Review agents now review the diff the review prepared, instead of building their own comparison against a newer base. If that diff cannot be opened, they report that they returned no results. A review brief no longer repeats the issue’s Acceptance Criteria section when it matches the criteria the brief already lists. (#2134)
/prflow:spec drafts no longer write out what the change leaves alone. The drafter still makes the same reads. A criterion can now point at the file that owns a set instead of listing it. An unchanged row quotes the old rule only where that rule contradicts itself, and a removed outcome whose loss is stated as accepted needs no fixture. A verified premise quotes only the clause that makes it true, without listing the other clauses read. (#2104)
The Documentation Needed gate now recognizes plain colon, period, and label-only openers. A handwritten issue body whose deliverable bullet read - Documentation Needed: — or with a period, a bare label, or a period/em dash inside the bold label — extracted no deliverable paths, so the Phase 4.1 documentation cross-check silently skipped. Plain and inside-bold labels now accept one common separator set (none, em dash, colon, or period), with the no-separator plain form required to end the line so extended labels stay closed, and the Stage 1 safety-net note recognizes the same spellings. (#2131)
Reviews spend less on checklist items that something else already checks. When the review’s checklist generator is sure a claim only restates an acceptance criterion (which the review already verifies as its own item), or that a test, lint or CI check the generator can name already asserts the claim against the real code, it leaves the claim out; when unsure, it keeps the claim. Matching repo-wide convention claims from new review batches, such as license headers, share a checklist item that names their cited files. Each claim is worded so the input its hint names would disprove it. (#2094)

October 11, 2026

A re-checked finding whose recorded behavior is still there but harms nothing now passes. When a pull request review re-checks an item from the previous review and the code still shows the behavior the earlier finding recorded, the item passes with evidence opening No defect: when nothing that reads that behavior fails because of it, it causes none of the harms the review grades severity by, such as wrong output, lost data or a security gap, any cost it adds is bounded by its inputs, and no decided criterion requires otherwise. That reason never applies, and the evidence says why, in cases including when the review cannot show that, when the decided criteria are missing or unusable, or when the earlier finding shows a statement still untrue in the reviewed code, or reports a missing test of changed code or a broken explicit project rule. Such a pass moves no finding of the same review to Informational — Deferred. (#2067)
/prflow:spec checks the text a finding attacks before revising the draft. At each revision — the Step 3.5 self-audit, an audit round, and a change you request at Step 4 — the run now loads the revision rule before editing, and reports when it cannot. For a finding, attacked text the brief does not need is deleted or moved to the investigation record, and an auditor’s suggested fix is weighed as one option rather than pasted in. The audit prompt likewise asks for a finding against a stated heuristic never to be fixed by adding the case: when deleting the attacked text is not enough, the fix restates the heuristic. (#2078)
The review-and-fix loop now checks draft iteration records against a shared schema to catch misplaced pushbacks. The new loop-verdict-marker.py install-record step refuses a misplaced pushbacks array with a pointer to fix_decisions. If neither installer form prints JSON or two corrections are refused, the loop logs the write failure and saves directly; that fallback can leave an unchecked record on disk. Readers warn about unknown top-level keys, and a resumed run no longer restores a synthesized or standalone-review record. (#2038)

October 10, 2026

/prflow:spec reads its degradation-routing table only when a reference load fails. A step whose condition calls for a fallback file now names that file and loads it directly, so condition-triggered fallbacks no longer read the table first. The table drops its row for itself (the skill root’s own paragraph covers a failed load of the table) and its marker-contract column. (#1829)

October 9, 2026

A cloud /prflow:review longer than one hour now posts its verdict. With a reviewer App configured (DEVFLOW_REVIEWER_APP_ID), the devflow.yml command job now runs the long-run credential refresher on /prflow:review too. It uses the new refresh-app-credentials.sh loop-token-file mode, which mints from the reviewer App at exactly the reviewer mint’s permission set, now declared once as DEVFLOW_REVIEWER_PERMISSIONS. It refreshes only the gh token file and leaves the review checkout’s GITHUB_TOKEN credential untouched. When the vendored refresher predates that mode, the review path launches nothing and logs one warning. The refresher now passes the App JWT to curl on stdin rather than in its argument list, on every path. (#1980)
/prflow:spec offers a further audit round on one rule, under one cap of three rounds. At the approval question, the audit-round option is now withheld whenever, among other cases, the current draft already carries a clean audit verdict, the latest round’s must-revise findings are waiting on a revision or uncounted, or the run has funded three rounds. Every REVISE round now takes the revise cycle, reversing #1918’s note that a final-byte pass’s REVISE findings go to your election: the separate final-byte pass, its extra round slot, and the coverage and calibration offer grounds are gone, so a run opens at most three audit rounds in total. A clean round with thin coverage or an unevidenced advisory finding is no longer re-offered. Runs that elect no audit round load a shorter Step 4 reference. (#1860)
A re-checked finding that a decided acceptance criterion settles now passes, with no Disputed criterion line. When a pull request review can read the issue’s decided criteria, it gives them to every item it re-checks from the previous review, whatever the description holds. Such an item passes when a criterion’s words require the behavior the earlier evidence called a defect, or exclude what the earlier finding asks, and the code shows that behavior. A finding that repeats only that earlier finding moves under Informational — Deferred with a [settled by criterion <N> — confirmed by <item id>] annotation, and the review re-checks such an item’s failure at or above the severity threshold once when a criterion settles its point. The fix skills still write Disputed criterion lines as a prompt to amend the issue or accept the criterion, but no review rule acts on them and Run details no longer reports them. (#1671)
The review-and-fix loop repairs a mistyped engine-return field in one helper call instead of running the whole engine inline, and files no follow-up issue for a deferral a later iteration decided. review-dirty-tree.sh engine-return now also refuses these shapes entry-close grades malformed: a diff_profile or cap_drops that is not an object, a present phase4_demoted or reject_drivers that is not an array of strings (null included), and a non-string reviewer-roster element (a shadow entry’s failed agents excepted). The engine fixes the named field and re-assembles; both helpers share one shape check. When loop-verdict-marker.py build-deferrals exits 1 on an unusable final iteration record or a failed manifest write, it now removes an earlier deferrals.json (naming one it cannot remove in its error reason), so /prflow:implement no longer files that superseded manifest’s deferrals. (#2002)
/prflow:fix and the review-and-fix loop check every fix against the acceptance criteria, wording-only edits included. A clarification that contradicts a criterion — for example one that edits text a criterion keeps unchanged — is now declined through the existing criterion-conflict path instead of committed, and findings the fix-delta gate sends back for repair get the same check. (#2027)
/prflow:spec no longer retries a failed config read before offering implementation. When /prflow:spec cannot read whether the cloud implement tier is enabled, it now withholds the “post /prflow:implement” offer straight away and says the tier state could not be established. It no longer falls back to reading the config file another way, so the separate config unreadable reason is gone. You can still file and assign the issue as before. (#1830)
/prflow:review-and-fix passes its PR number to each review pass. A pull-request review pass no longer fails setup with --mode head-override needs a numeric --pr and then looks the PR up again; a current-branch run passes no PR and keeps current-branch setup. (#2013)
A fanned-out review engine hands its report back as a Markdown file instead of a hand-escaped JSON string. The engine writes the Phase 4.1 report to its run directory’s verdict-body.md and passes it to review-dirty-tree.sh engine-return --report-file, which reads it as UTF-8 into the return’s report field without removing the source. entry-open deletes any leftover verdict-body.md when the next engine entry starts, so a later entry never reuses an earlier entry’s report. A missing, unreadable, non-UTF-8, empty or whitespace-only file, an input aliasing the return JSON or its .tmp staging file, or an authored report supplied alongside it, is refused with a named error. The return file’s schema is unchanged, and a call without --report-file still takes report from the authored JSON. (#2024)
/prflow:implement now finishes a run whose review you explicitly waived, instead of stopping again at completion. When you tell a run to skip review and continue, finalization carries that instruction and its source through to the Complete write. The waiver skips only the review-coverage check, writes no review record, and adds a workpad note saying review was waived and the change is unverified by review. Every other completion check still applies, and a run with no such instruction from you still needs its review-coverage record. (#2026)
/prflow:review keeps a verifier’s completed answer when only its verdict file is missing, instead of verifying the item again and re-running the whole review. When a checklist verifier returns a valid verdict but does not write its attempt file, the engine sends that same verifier one SendMessage asking it to write the answer it already returned to the same file. The verifier-written file is still required evidence, and the item is not verified again. A delivered file whose verdict, severity or other grading fields differ from the reply is stored INCONCLUSIVE. When the verifier cannot be reached, or the file is still absent afterwards, the item keeps its answer but the evidence check names it delivery-failed:<id>: the review-and-fix loop does not re-run the review for it, sends a REJECT’s other findings to the fix pass, and otherwise reports the failure. Any other missing verdict file keeps its one re-run. The review engine and review-fix worker agents and the generated cloud workflow allowlists now grant SendMessage; a copied workflow without that grant reports the delivery as a failure. (#2022)
The review troubleshooting page now states what a failed verdict post needs. Both the failed job and the review stall backstop’s renewed review request need the installed workflow and the vendored PRFlow helpers to be current. (#1979)
The review-and-fix loop now handles renames whose new path was added with git add -N. entry-close and the per-dispatch dirty-tree check read the work-tree rename as one record pair, so a short original path no longer reads as malformed. A rename present at entry-open is preserved; for one the engine creates during the window on the status-snapshot route, entry-close restores the original from HEAD and unstages the new file while keeping it on disk. entry-close also names a failing git hash-object on its before snapshot, or git failing to start, instead of reporting a mismatched or unreadable snapshot. (#1983)
A test’s own RED-to-GREEN run now discharges the mutation check. /prflow:implement, /prflow:fix and /prflow:review-and-fix no longer repeat a mutation check that a test’s own RED-to-GREEN run already proved: a RED at the same assertion, for the same defect, with nothing bearing on that failure changed since but the fix it drove, discharges it. A mutation still runs for anything that RED did not demonstrate, such as a preserved behavior the unfixed code already satisfied.
Under /prflow:implement, the review-and-fix loop no longer runs gh pr checkout when it enters review. Implement’s checkout already holds the PR branch, so Step 0.5 goes straight to the branch-sync gate, which still stops on a mismatched, unresolved or missing result. Standalone PR-mode /prflow:review-and-fix runs keep the checkout. (#2047)
/prflow:spec states which checks can show a reported bug is already gone. Before it recommends No change — file nothing, this run’s initial documentation and code checks must positively show each failure in your bug report gone; a failure the run merely did not reproduce does not count. When those checks fall back to a reduced inline check, its results can still count, and the evidence PRFlow gives you says the check was reduced. (#1978)

October 8, 2026

/prflow:spec now asks “Assign this issue to you?” and, when offered, whether to start implementation together with the approval question, before the issue is created. On a runner that asks one question at a time, they come right after you approve. After creation PRFlow applies the answers and asks nothing more, so you can approve and walk away.
/prflow:spec states each quality group’s routing trigger once and owes the skipped-step case for every new or changed gate. The quality-group rows of the degradation-routing table now point at the root’s Advanced quality-guidance routing bullet instead of restating its triggers, the issue template’s Current Behavior and Technical Context guidance no longer restates them, and the group files drop their shared intro sentences. The guarantee-class case — a deterministic hook, gate or backstop fires when the cooperative step it backs was skipped, idempotently where enforcement repeats — moves from the regression group to the contracts group, which every such draft loads. (#1852)
/prflow:spec saves the investigation record beside the draft and posts it in one step. The approval message now shows the record’s file path instead of printing the whole record, and Print the full draft in chat prints the record after the body. The record file is saved even when spec.investigation_record_enabled is false; that setting now stops only the comment, and the file is removed with the run’s scratch once the issue is filed. Publishing the record takes one helper call, and /prflow:implement no longer reads the posted record as an issue comment. (#1868)
/prflow:spec, /prflow:init and /prflow:retrospective-weekly report a refused prompt-extension load as unestablished. A load that prints no PROMPT-EXTENSION-STATUS: line on stderr, as after the client refuses the command, is now reported instead of being treated as no extension, as the skill-extensions documentation already describes. (#1964)
Spec-filed issues are shorter. The /prflow:spec issue template no longer adds a fixed scope note to Technical Context. It also drops the Technical Context file list and Dependencies bullet, and leaves out a Technical Context bullet that has nothing to say instead of writing “none”. Files are listed once, in Implementation Notes’ Relevant files, which opens with at minimum. Retrospective-audit and deferral follow-up issues follow the same shape. (#1837)
/prflow:spec can end with nothing filed. When a verified check from this run’s Step 1 shows the current tree no longer produces any failure a reported defect names, the implementation-approach question is asked before every other clarification question except whether to widen an existing issue, and recommends No change — file nothing; choosing it ends the run at Step 2 with nothing written to GitHub, and the outcome gives the evidence and names the open issues left for you to close (#1951).
A review verdict that fails to post now reads as undelivered. When both the review and the comment POST fail (FAILED no-durable-channel), post-review-verdict.sh no longer stamps the verdict marker on the progress comment, and derive-review-verdict.sh reads a progress comment’s verdict only from that marker, so the run derives incomplete. Once the installed workflow and vendored helpers are both current (re-run the installer with the new tag), a cloud /prflow:review run that was not cancelled fails its job on such a post, and the review stall backstop re-requests the review as it does after an engine error. (#1965)
/prflow:spec no longer rebuilds a lost working-draft file from memory. A failed write or edit of the working-draft file that is not a permission refusal or filesystem failure is re-read and retried once, and the draft moves to the chat message only when the first Write is refused or still fails. (#1946)
/prflow:spec’s Step 3.5 self-audit runs one omission pass and one revision. Item 5 is the only revision. The old item 6 self-check is gone and the summary moved from item 7 to item 6, so a spec skill extension that cites Step 3.5 items by number needs updating. The drafting rules for mechanical claims, occurrence counts, data-entity and replaced-gate reads, file references and multi-state contracts now live in the issue template. (#1819)
Checklist verification is faster and cheaper. Each checklist verifier now reads one item file that carries its source views, its verdict file and only the grading rules its claim needs, so every verifier loads less prose and the review no longer retypes revisions and rules into each dispatch. A verifier that answers without writing its verdict file no longer holds the verification wave for nine minutes after the other verifiers finish. Checklist batches are sized by diff size rather than a fixed ten files, so a large pull request with small changes uses fewer generators. (#1797, #1791, #1782)
A local review no longer idles after its checklist generators finish. Phase 1 now ends its generator dispatch with one wait on the batch files, which returns as soon as they exist instead of sitting out a nine-minute deadline. (#1783)
The checklist deduper and lite verification are gone. Cross-batch duplicates are now merged by identical claim signature without an extra agent, and no claim is settled by a string probe in place of a verifier. A prflow:checklist-deduper or devflow:checklist-deduper entry in prflow_review.agent_overrides still validates but is ignored, so you can delete it.
A claim that a path does not exist is settled from the reviewed commit’s file list. A verifier no longer leaves such a claim inconclusive for want of a deleted-file record. A checklist item left inconclusive because a file could not be read now caps the verdict at APPROVE WITH CAVEAT. (#1440)
Helper entry points the review-and-fix loop no longer calls are removed: a caller now gets exit 2, or 127 when it runs a deleted script directly.
- load-prompt-extension.sh --provenance, --diff-patch and --since: an unrecognized-argument error.
- loop-verdict-marker.py compose, eval-extension-shadow-trigger and write-active-entry-binding, and the --entry and --head options of check-evidence: an argparse usage error. check-evidence --iteration now requires --contract 2.
- review-dirty-tree.sh entry-open and entry-close without --contract 3: refused.
- lib/efficiency-trace.sh --mode, with any value: refused; --persist and --self-check are unchanged.
- scripts/stale-prose-lint.py and scripts/match-lint-adjudications.py are deleted: python3 <path> exits 2, a direct call 127 (not found).
- scripts/check-completion-evidence.py has no command line: run as a command it exits 2. /prflow:implement’s completion gate, which imports it, is unchanged.
A prompt extension can no longer declare an early shadow trigger. The shadow review runs at convergence only, and .prflow/skill-extensions/early-shadow-path-set.json is no longer read. An extension that still describes such a trigger is read as plain review policy. (#956)
workpad.py --review-coverage-disposition no longer accepts the extension-provenance cause class. A disposition that names it is refused as [review-coverage-cause-inadmissible], with no workpad edit.
Workflow allowlists no longer grant the three removed scripts. The generated TOOLS lists drop check-completion-evidence.py, stale-prose-lint.py and match-lint-adjudications.py; re-run install.sh to refresh an installed workflow. A workflow that still lists them keeps working.
A file a review subagent creates no longer stops a standalone /prflow:review-and-fix run. The loop still resets a subagent’s edits to tracked files before fixing; it lists both kinds in its output and never commits them. Under /prflow:implement such a file still blocks the run after the loop.
The loop applies the pull request’s own .prflow/skill-extensions/ policy, with no provenance check. Protect .prflow/skill-extensions/ with a CODEOWNERS entry so extension edits need an owner’s review.
A shorter loop exit. The loop no longer prints a telemetry table, per-iteration finding counts or an effectiveness trace, runs the completion-evidence check, or downgrades a final REJECT, and a clean gate writes no workpad reflection. A standalone --push-each-iteration run no longer re-runs the test suite at loop exit after merging the base branch; CI on the pushed head checks the merge.
A finding pushed back in two consecutive iterations no longer prints “Finding persists after pushback”.
prflow_review.stale_prose.enabled and .severity stay accepted and do nothing. A config that sets them still validates.
The loop’s deferrals.json no longer carries default_channel.
A shadow review that fails before writing its evidence now ends the loop as not verified instead of stopping it.
The review-fix worker can check claims about external tools on the web. prflow:review-fix-worker now has WebFetch and WebSearch.
/prflow:spec audit rounds read the auditor’s own return instead of a hand copy. When you elect an audit round, the auditor now writes its complete return — verdict, draft identity check and per-finding evidence — to the run’s audit report file, and the round is read straight from that file. A round takes fewer orchestration turns and less copied output, and the findings quoted to you are the auditor’s own. Runs that elect no audit round see no change. (#1748)
/prflow:review-and-fix now protects uncommitted edits in files you were already changing when a review agent touches them. Each engine entry records the content of every tracked file; when that record is available, closing the entry puts back each tracked file outside .prflow/tmp/ that the engine edited, staged or discarded, except a submodule checkout it moves without staging, a file marked assume-unchanged or skip-worktree, and an edit that line-ending conversion or a clean filter normalizes away. A file the engine creates is only unstaged, and a deletion the engine undoes stops the loop rather than deleting the file again (a staged deletion only when the engine also stages the file; a staged new file you deleted only while the entry’s git status snapshot is usable, without which the file is recreated with its staged content). When the record cannot be made (for example, an intent-to-add entry exists when the review starts), the loop falls back to its earlier behavior: an engine change to a file you had already modified is not undone, and is named only when the file’s git status changed. Before resetting, when git can, the loop saves the content it overwrites and names the saved object in its report, so git checkout <id> -- <path> recovers it until git prunes the object.
A re-review grades a previous finding against the finding itself. When /prflow:review re-checks a finding from the previous review that quotes no text still in the code, it now checks the finding’s own words instead of a generated restatement, so a misworded restatement can no longer fail a defect you already fixed. (#1992)
Implement-phase agents that hold Bash no longer prefer Grep and Glob tools a local run refuses. Implement-phase agents that hold Bash (intake, branch setup, issue-claim audit, evidence verification and finalization) replace their instruction to prefer Grep and Glob tools with the reviewer agents’ instruction to search through Bash grep/rg or a search tool the agent holds. (#1790)
/prflow:review-and-fix’s deferrals manifest holds every iteration’s standing deferral. Loop Exit builds deferrals.json with loop-verdict-marker.py build-deferrals from every iteration’s decisions, not only the final one’s, leaving out a deferral a later iteration fixed or decided again, and applies the widens-surface rule /prflow:review’s deferral matcher uses. /prflow:implement files its follow-up issues from that manifest.
The final report’s ## Coverage section lists every checklist FAIL and INCONCLUSIVE item of the last iteration that ran the checklist, marking a FAIL that iteration then fixed.
The fix loop uses /prflow:fix’s fix rules and its prflow:fix-delta-reviewer. When the loop cannot dispatch prflow:fix-delta-reviewer, it records fix-delta not verified instead of running a general-purpose stand-in, and the report’s ## Coverage section names the gap; the shadow pass stays the backstop, so the verdict is unchanged.
Every reviewer sees the acceptance criteria and, from iteration 2, the earlier findings. The loop passes the issue and the iteration to the review engine on every entry and, from iteration 2, a prior-findings file to each Step 1 entry; the shadow pass still sees no earlier findings.
Standalone /prflow:review no longer adds suspected over-grade notes. The fix loop still calibrates over-graded findings before promoting them.
Inside /prflow:implement, a review engine that cannot dispatch its reviewers stops the run with a remedy. Launch /prflow:implement at the top level, or raise the subagent nesting limit: in Claude Code set CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH to 4; in VS Code Copilot turn on chat.subagents.allowInvocationsFromSubagents. A standalone /prflow:review-and-fix still runs the engine inline.
New helper subcommands and contract. loop-verdict-marker.py build-deferrals and render-exit; review-dirty-tree.sh entry-open and entry-close take --contract 3, which adds the prior and engine_return fields, and refuse an earlier contract.

October 7, 2026

A review checks an approval against its checklist and reviewer records before posting it. /prflow:review now refuses an approve-family verdict while a checklist FAIL counts against your verdict_severity_threshold, and posts REJECT instead. It also refuses one while a reviewer the run planned, the final pass included, left no record of having run; the review then ends without a verdict, naming what was missing, and no longer re-runs reviewers itself — re-run the review. Local reviews of a pull request are checked the same way as cloud ones. A REJECT is checked too, for the reviewers every review runs, and ends without a verdict when one of them left no record. Once a verdict posts, the posting step ticks the progress comment’s last row and, for an approval, clears PRFlow’s own stale change requests. When the posting step posts nothing (both of its channels fail, it refuses an argument, or it prints nothing), the progress comment’s status reads ❌ <verdict> not posted with the reason; on a run with no progress comment the report now reaches the run’s chat output only, where before the review also posted it as a plain pull request comment. If your repository commits a vendored copy of PRFlow, re-vendor it with this update: until you do, a local review cannot render its checklist, Deferrals or Issue Compliance sections, so it approves at most with a caveat, and posts its verdict unchecked with the whole progress report as the review body, leaves the last row unticked and clears no stale change request. (#1656)
Deferrals listed in a pull request body no longer lower a finding’s weight. The review report’s ## Deferrals section still lists each deferral, and for one that matches a current finding now says whether that finding was filed at or above your threshold.
Helper-rendered report sections. The checklist results and issue-compliance sections are now produced by PRFlow’s helpers rather than written out by the model; the issue-compliance line names the issue by number, without its title. When the progress comment holds the report, a cloud review’s chat output is the verdict line and a pointer to that comment instead of the whole report; a local review still prints the full report.
/prflow:init now sets prflow.effort to medium. Cloud reviews run below medium skipped review steps more often. The setting applies to every cloud command except implementation, not only reviews, and to the weekly retrospective when prflow_retrospective.effort is unset, so those runs cost more than at low. Existing configs keep their value.
The final-pass reviewer is now the prflow:requesting-code-review agent. The review engine dispatches it like its other reviewers and loads your .prflow/skill-extensions/requesting-code-review.md itself, passing the text to the reviewer and reporting the extension’s load status in the review. Its prflow_review.agent_overrides key keeps working, and /prflow:requesting-code-review still runs the same reviewer on demand.
Review agents share one findings contract. All six reviewers grade findings on the same Critical, Important and Suggestion scale, set out at the end of each reviewer’s instructions; an untrue line is still graded by who reads it. Five of the six reviewers keep severity rules of their own on top of it. The comment and type-design reviewers now report severities on that scale in place of their own categories and 1–10 ratings. Reviewers run no mutation checks and none of the project’s tests; they verify a claim about a test by reading its source.
Reviewers search with grep or rg and skip the command-shapes read. Reviewer instructions no longer direct a Grep tool call or a read of the command-shapes file. (#1790, #1201)
A deferral in a pull request body can no longer hide the rest of the review report. The report’s ## Deferrals section escapes an HTML comment opener (<!--) in every field it shows, so text such as a deferral id no longer comments out the sections after it. A deferrals block that is present but cannot be read now says why in place of zero counts.
The review requested when CI passes is no longer skipped as a duplicate. When a new commit was pushed while an earlier review was running, that review could move to the new commit before its CI finished, and the review PRFlow requests once that commit’s CI passed was then skipped as a duplicate. A review whose progress comment shows it running no longer swallows that request. Two reviews of one commit may occasionally overlap. (#1490)
A deferrals block with no END marker after its START marker is now reported as unreadable in the report’s ## Deferrals section. Before, an END marker placed only before the START marker stopped the review’s deferral matcher, and a START marker with no END marker anywhere was read as no block.
The spec skill’s implementation-approach question is written in plain words. Its recommendation now says what the supporting check found, and the question says what the run could not check or ruled out without checking, instead of naming internal evidence labels or counting skipped entries. When nothing checked supports a recommendation, the question says so plainly. (#1858)
On macOS and Windows, a review no longer stops at engine setup when the repo tracks two paths whose names differ only in letter case. The review’s source view records the names the filesystem stores as one (readme beside README, foo beside FOO/x) as unread path-too-long entries instead of stopping with view-path or view-write; when both are files, the earlier one is left out too, so neither name is read as the other’s bytes. A harness .src rename onto a tracked .src file, and a root name stored as inventory.json, still stop as view-path.
/prflow:implement now has the agent record every skip its final suite run reported, so a run whose suite skipped a test ends Blocked instead of Complete. Phase 4.3 tells the agent to list each skip the suite’s output reports in the verification summary, pre-existing ones included, and no longer presents an empty skip list as the requirement.
Implement PR descriptions no longer report a stale CI or test-suite status. The PR description written near the end of an implement run is now checked for sentences reporting whether CI checks or the test suite passed, failed or are still running, and a stale or unsupported one is corrected. A Test Plan step naming a check to run is left as written. (#1424)
/prflow:implement no longer dispatches the code-architect because of a change’s size alone. It dispatches the architect only when a structural design decision is still open — the issue does not prescribe it, or discovery contradicts what it prescribes — or when that cannot be established; every other change is planned inline, however many files it touches. (#1778)
The weekly retrospective no longer audits or files a pattern that has gone quiet. A pattern is sent to Stage B, and can be filed, only when one of its occurrences merged at or after the earliest merge among the PRs the run scanned, or when the run cannot establish a merge time that decides this. (#1410)
Search fallbacks no longer miss hidden directories or walk sibling worktrees. The docs skills, /prflow:fix and implement’s Phase 2 sweeps now search with the Grep tool, else git grep --untracked -nP over the whole repository. The old rg rung skipped hidden directories such as .github/, and the old grep -rnE rung walked sibling worktrees and could stall past the Bash timeout. Implement’s sweeps count matches with git grep -c instead of rg or grep, and their cross-line phrase search uses the Grep tool’s multiline mode, else rg -U --hidden, replacing the tr form. A git built without PCRE fails the git grep rung loudly (exit 128) instead of returning no matches.
review-and-fix: fix-delta gate Suggestions now reach the fixer when your threshold admits them. With fix_severity_threshold: suggestion, a Suggestion or Minor finding from the Step 3.5 fix-delta gate was always parked as advisory, so a defect the gate had already spotted could come back as a PR-review REJECT. It now routes the way the iteration’s other findings of that severity route, and is re-fixed and re-gated in the same iteration under the gate’s existing two-attempt cap. Repositories on the default important or on critical see no change. (#1704)
/prflow:implement no longer writes a workpad row for a check that found nothing to act on. A passing dependency preflight, a clean issue-claim audit pass, a CI-verdict read that listed at least one run and whose every group passed with no skipped job, a docs pass with no changes, and a Phase 4.2 claim-audit class that found no false claim now write no workpad row of their own; findings, failures and checkpoint records are kept. (#1693)
A later /prflow:spec audit round now counts as a full audit of the draft. When you elect a second or third audit round, the audit summary now reports that latest round’s finding counts instead of an earlier round’s. A clean later round no longer triggers an extra automatic round you did not ask for. (#1747)
/prflow:spec re-checks the draft after each change. /prflow:spec now writes the draft to a working-draft file in the run directory, and the verified-premise check and the acceptance-criteria parseability gate re-read it after each change — so a fix those checks call for passes the no-options gate and revision-delta verification, and a draft revised at the Step 4 review is parsed again before it is filed.
/prflow:spec no longer writes its Testing Strategy coverage-sweep cases into Acceptance Criteria. A sweep case becomes a criterion only when the criterion grade adds or merges it; otherwise it stays a Testing Strategy case. The Testing Strategy guidance in the issue template is also shorter. (#1838)

October 6, 2026

/prflow:spec leaves decisions an implementer can clearly make to the implementer. /prflow:spec no longer asks about, or writes into the issue, a decision you left open that a competent implementer could clearly make from your request and the codebase, unless the issue lists it as one item of a complete set; the implementer makes it and the pull-request review judges it. It still asks which implementation approach to take, and asks whenever it is unclear whether an implementer could decide. When a rule sorts cases that cannot all be listed, such as the scope of a change, the issue states it once as the rule, which way it fails when a case is unclear, and the limit it accepts, and every check, the fresh-context audit included, accepts that instead of asking for more cases; a set whose members can all be listed is still listed member by member. A revision now fixes what produced a finding across the whole draft, not only the line the finding names. Issues come out shorter and audit rounds stop adding one missed case at a time. (#1806)
Reviews no longer block a pull request on an inaccurate code comment or internal doc. An untrue code comment, docstring or repository-internal doc page is now reported as a Suggestion. Customer-facing prose such as a README, a published doc page or a release note is reported as Important at most. Neither one REJECTs the pull request at the default threshold. An untrue line that a tool or agent acts on, such as a skill body or a lint directive, still blocks as before, and a finding that the code misses a case it should cover is still graded on that gap, wherever the gap is described.
Run evidence and cloud cost records are kept even with the effectiveness record turned off. Each run’s JSON workpad files now reach the telemetry branch (a run dir whose name is an unfilled placeholder is still refused), including a standalone review’s findings and checklist, which were dropped when the run had no iteration record. Setting prflow_review_and_fix.efficiency_telemetry_enabled to false now stops only the effectiveness record (and the data synthesized to feed it) and denied-command records: cloud runs keep recording their cost and run profile, and only telemetry.enabled: false stops those. The weekly retrospective’s trailing four-week cost and duration lines now say when the last figure was recorded instead of presenting older weeks as current, a regression line compares a week only with the four calendar weeks before it, and its cost ranking no longer counts standalone review runs as fix-loop iterations. Upgrade note: in a repository with efficiency_telemetry_enabled false, the next writable run copies any leftover run files (findings, checklists, prior comments) and cloud cost records to the telemetry branch, which anyone who can read the repository can read; set telemetry.enabled to false to keep them off it. (#1808)
Reviews start faster. One helper call now gathers a review’s diff and related issue, plus a pull request’s refs and description when there is one, including for a standalone review of a pull request number. A local /prflow:review-and-fix run now keeps one progress comment across its iterations. The stale-prose check no longer runs. prflow_review.stale_prose.enabled and severity still validate but are ignored. A per-agent effort in prflow_review.agent_overrides was never applied and is now ignored, with no notice; every review agent runs at the session effort. /prflow:init no longer scaffolds either setting. (#1792, #1794)
Fix: /prflow:create-issue now runs exactly like /prflow:spec. The alias hands its arguments to /prflow:spec and runs it as its own skill. Before, the alias read the spec instructions as a file and added its own setup rules. Those rules could stop a run that /prflow:spec would have continued, and the user story reached spec only indirectly. /prflow:create-issue and /devflow:create-issue are permanent aliases, and the docs no longer call them transitional. (#1826)
/prflow:spec no longer checks its scratch files before showing the draft. The approval message no longer carries two path=… class=… lines, and a missing scratch file no longer re-runs the docs check or the derivation pass. scripts/cleanup-spec-run.sh --probe-run-state is removed. (#1824)
/prflow:spec asks one visual question for a UI change instead of two. When an issue changes what users see and you have not already shared a screenshot or mockup, the spec run now asks once: attach a screenshot or mockup, or confirm the proposed visual details (layout, states, responsive behavior, style). It no longer asks for a screenshot first and then follows up on the details. Non-UI issues still get no visual question. (#1853)
/prflow:spec now reports when it could not add the PRFlow label to a new issue. The run’s final summary names the label as not applied, with the reason. (#1869)
/prflow:fix is shorter and stops on a wrong checkout. Its body is about a fifth of its former size. On a pull request it fetches, then stops before changing anything unless it can read the pull request, the working tree is clean and you are on the pull request’s head or ahead of it. It also stops when it cannot tell whether the branch has a pull request, or when a bare number in front of the feedback is not the current branch’s pull request. The eleven-fact preflight block and the completion-evidence check are gone from the pass, which now reports each finding as fixed, pushed back or deferred with its evidence, plus the local test result, the fix-delta gate line and a branch-sync measurement. When the local test run is denied, it reads the pull request’s checks only if the pull request’s head is the commit holding every fix; otherwise it reports the tests as unverified and does not claim completion. The receiving_review.fix_severity_threshold setting keeps its values and default; an array or object there now counts as unset.
Update prompt extensions that name removed /prflow:fix sections. Every ## section of the old body is gone, among them the Reception Preflight, Update the Branch First (Step 0), Verification Gate (Step 8) and Record Every Deferral, so a .prflow/skill-extensions/fix.md that points at one of them now points at nothing; point it at a step’s heading or a fix-discipline section name instead. An extension or script that calls reception-record.py changes too: it no longer accepts append-disposition, --token or --session-dir.
A fix makes the smallest edit that closes its finding. Whatever the severity, /prflow:fix deletes the faulty code or text or makes the smallest closing edit, and adds new text or a new code path only when the finding, or a rule the fix triggers, needs it. The rule lives in skills/fix/references/fix-discipline.md. (#1770)
/prflow:fix no longer stalls on an unclear finding. The pass skips that finding and any finding it may affect, records the open question as the deferral, and fixes the rest. (#1657)
The direct-pass fix-delta review is a named agent. /prflow:fix now reviews its own fixes through the new fix-delta-reviewer agent, which computes the fix delta itself and returns one line per finding; how the pass routes those findings is unchanged. Where that agent type cannot be dispatched, the gate line reads not verified.
/prflow:spec loads less text when it drafts an issue. The issue template’s checklist, which repeated rules the template already states, is now one self-check sentence. The run no longer records a disposition line for each acceptance criterion, so the approval prompt no longer shows a disposition note beside the criterion count. (#1836)
/prflow:spec tracks its progress in your runner’s own task tool. The run now uses whatever task-tracking tool your runner offers, whatever its name. A run with no task tool keeps its checklist in the conversation and no longer writes a checklist file. The first line of the run says which tracker is in use. (#1827)
/prflow:spec asks before rewriting an existing issue. It widens an open issue only when your request names it or, after its duplicate search finds one, you choose to widen it; a non-interactive run never widens an issue you did not name and, when it goes on, files a new issue and names the suspected duplicate. On a widen, the approval question says that approving replaces the issue’s title and body, and a confirmed widen tries to register the new body’s declared prerequisites as blocked-by links, naming any it could not link. A run that files or widens says in its final outcome when the duplicate search could not run. (#1831)
/prflow:spec no longer writes a Steelman record or a steelman-projection-<slug>.json file, and Step 3.6 entry and the Step 4 presentation gate no longer read them back. Step 3.5 reports its summary in chat only. A change requested at the approval pause is checked by Revision-delta verification alone instead of re-running Step 3.5 (it now also fails a revision that leaves a Desired Behavior obligation with no acceptance criterion); kept at fork: lines are still recorded in the derivation artifact. A spec prompt extension that names the removed record or JSON file should stop naming them. (#1817)

October 5, 2026

/prflow:docs-verify --report-only no longer returns a status per duty. Its last report field, Duty statuses, is replaced by Not established: each duty the run did not carry out or could not establish, and each internal-documentation page it located but did not read in full, with a one-clause reason each, or none. /prflow:spec Step 1 copies that field into its evidence file and no longer checks the documentation lead’s location against its own resolution. A consumer extension or caller that names duty statuses now names a field that no longer exists.
/prflow:spec reports a config-withheld investigation record plainly. /prflow:spec: with spec.investigation_record_enabled set to false, the final outcome reports only that the investigation record was withheld by config; it no longer names a Considered-and-rejected: line as lost.
/prflow:spec widens replace the issue’s title along with its body. The approved draft’s title goes in the same request as the body, instead of the old title staying in place.
/prflow:spec keeps mechanisms and heuristic case lists out of acceptance criteria. A mechanism you did not ask for goes in Implementation Notes unless another surface reads it as a contract, and a heuristic’s criterion states its rule, which way it fails and its limit. (#1752)
/prflow:retrospective-weekly now sends each recurring category to Stage B once per run. When several actionable patterns outside cooldown share a category, only the first-ranked one is dispatched; the others read “not filed” in the report, and a notice in the run output names them. The --full pattern view and every record’s status are unchanged.
/prflow:review-and-fix now links each fix decision and deferral to the finding it acts on, so a decision can no longer be attributed to a different finding. When it skips a checklist failure on a file the PR changes beyond comments, the skip no longer downgrades a REJECT. (#1751)
Cloud CI verification no longer dispatches CI for a commit that is not checked out. ci-verification-request.py request now refuses a head SHA that differs from the checkout’s current commit, naming that commit, before it runs any pre-request check or dispatches CI. It also refuses when the current commit cannot be read. A mistyped SHA now costs one quick retry instead of a failed CI run on the pull request. (#1773)
/prflow:retrospective-weekly stores every record with the repository its pull request belongs to again, so patterns built from analyzed pull requests reach Stage B instead of being refused because their occurrences name no repository. When the weekly run merges new records into the learnings store, every record that names no repository, new or already stored, gains the run’s repository and, when its pull request number is an integer, its pr_key. When it updates stored records it reports their count on stderr, and when a record needs the run’s repository but that repository cannot be resolved, it stores nothing. A pull request analyzed again ends with one record of that kind, replacing every stored record it matches. The scan’s warning about records that name no repository now says the next merge gives them the run’s repository instead of advising a migration script. (#1765)

October 4, 2026

Review-and-fix re-checks an earlier fix before undoing it. Before a fix deletes or rewrites text, the fixer checks that it does not bring back a finding about that file that an earlier iteration of the same run fixed, and reworks the edit so both stay fixed. When both can’t hold, the later fix is not made and its finding is pushed back. (#1695)

October 2, 2026

Native-Windows paths no longer break /prflow:spec’s audit or /prflow:implement’s setup. On native Windows, helpers now print paths with forward slashes, so a path pasted into a Git Bash command names a real file. Printed paths on Linux, macOS and WSL are unchanged. (#1665)
Fix: /prflow:implement no longer risks stopping as Blocked after a clean review or finalization. The check that reads each worker’s result printed nothing when a review-fix or finalization result passed, and a check that prints nothing is how a refused command looks, so a successful run could be stopped as Blocked. That check now prints the passing result’s outcome, for example {"outcome":"proceed"}, on every pass. A failing result is reported as before. You get this through the normal plugin update. (#1699)
/prflow:implement’s acceptance-criteria gate writes a smaller workpad record. Each Phase 3.4 pass now records the tally and one line for each criterion the gate does not tick; when every criterion is ticked, or there are none, the record is the tally line alone. The pass no longer writes a note naming its scratch attempt directory, and tick calls carry no note. The verifier’s evidence for a ticked criterion no longer reaches the issue. (#1530)
/prflow:implement files only real action items under the workpad’s “⚠️ Action required”. When the review-fix loop soft-proceeds, a leftover finding graded below Important is now a note under “ℹ️ Notes”; an Important one stays under “Action required”. A finding the run declined because it would weaken an acceptance criterion is now recorded as an “Issue accuracy” note, and the PR body’s Disputed criterion line is unchanged. (#1698)
A page your issue’s Documentation Needed note only points at no longer blocks a finished /prflow:implement run. In a line such as `docs/guide.md`: link to `docs/setup.md`, the text after the colon now describes the edit and is not read as another file to edit, so docs/setup.md is no longer a required deliverable and is no longer reported as a refused deliverable. Files named before the colon, or outside any such description, are still required. The issue template now tells writers to name by path only the files the change edits. (#1691)
A criterion is tagged post-merge only by an exact (post-merge) ending or an unambiguous phrase. An acceptance criterion that names a post-merge or post-deploy flag, path or file — such as --exclude-post-merge or a .husky/post-merge hook — is no longer tagged post-merge and stays in implement’s merge gate. A criterion is tagged only when it ends in exactly (post-merge), lowercase, or uses a multi-word phrase such as “after merge” or “on a live PR”. (post-deploy), (Post-Merge), [post-merge] and a criterion that says only “verify post-merge that …” are no longer tagged; end such a criterion in (post-merge) to keep it out of the merge gate. (#1700)
/prflow:spec’s investigation-record comment no longer carries the run’s raw working notes. The first comment on a spec-filed issue is now the investigation record PRFlow sorted out of the body, plus one Considered-and-rejected: line when the run passed over heavier approaches. The criterion disposition, steelman, self-audit and evidence-bundle sections are no longer appended: they were written before later revisions, could contradict the final issue body, and made up most of the comment. A record over 65,536 bytes, a conservative bound on GitHub’s comment limit, is not posted rather than cut. (#1669)
A first-pass restate no longer makes implement’s acceptance-criteria verifiers grade a criterion alone. The verifiers now treat a dispatch as a re-verification pass only when it carries the exact line This is a re-verification pass., so a restate, rerun or redispatch request without it still lets sibling criteria and extra coverage excuse a criterion, instead of costing a fix round. (#1507)
/prflow:spec questions keep their background under a terse output style. Every clarification question now opens with one or two sentences on what the answer decides and what it touches, even when your output style asks for no preamble; a chat message before the questions may add more but never replaces it. Before its next question, or before drafting when none follows, the run also names, one line each, every decision it settled without asking that your story does not state, so you can contest it before it reaches the draft. (#1660)
/prflow:spec also writes an Implementation Notes “no X” or size-cap decision as an acceptance criterion. Only a criterion has standing against a review finding, so for an issue spec writes, the review-and-fix loop’s existing criterion-conflict decline now covers such a decision. Spec also checks each criterion against the Implementation Notes and reconciles a conflict before filing the issue; a decision that cannot be a criterion is removed from the Notes. Hand-written issues are unchanged. (#1696)
Cloud /prflow:implement runs get through the documentation pass’s deliverable and config reads as written. Phase 4.1 now runs both Documentation Needed reads and the six docs-config reads through the installed .prflow/vendor/prflow/ helpers first, which the cloud tier allows, and falls back to the plugin path when that copy cannot run. (#1539)
One malformed allowed_tools entry no longer silently drops every extra tool grant on a cloud run. The cloud config job now keeps each prflow.allowed_tools or prflow_implement.allowed_tools entry that is a non-empty single-line string and skips the rest with a warning naming the key, each skipped index and its JSON type. A non-null value that is not an array grants nothing and also warns. Entries that used to pass through are now skipped: numbers, booleans, and the values of an object written in place of the array. Entries containing a line break can no longer write extra lines into the job’s outputs. Takes effect after you re-run install.sh --apply, which refreshes the config action and the retrospective workflow. (#1435)
The /prflow:spec issue template now says where a Documentation Needed description ends. The text after `docs/guide.md`: can end before the end of the line, for example at ;, . or the next `path`:. Put a page the change only points at before that point, or describe it without its path. (#1723)
A malformed review finding no longer crashes the deferral match. A malformed review finding — one that is not an object, or whose line range is not two whole line numbers in order — no longer crashes the review’s deferral match, and your other deferrals are still matched. A deferral whose line range is reversed is now rejected as malformed instead of matching a finding. (#1554)
An acceptance criterion keeps its indented paragraph after a blank line. When a checkbox criterion continues with an indented paragraph or nested list after a blank line, /prflow:implement now mirrors, gates and reviews the whole criterion instead of silently cutting it off at the blank line. A non-indented line or the next checkbox still ends it, and post-merge trigger phrases match across the whole joined criterion. (#1715)

October 1, 2026

/prflow:spec counts an item verified only when a run-time read confirms it. /prflow:spec now states one definition of “verified”: an item counts only when a read made during the run covers its locator in the file as it still stands and confirms it. The Step 3.5 record and the revision-delta evidence line count only such items and name each other item unverified. The facts an adopted edit introduces are enumerated from the edit’s replacement text, and a fact list supplied with the edit is treated as a starting point. issue-audit-state.py record-adjudication now refuses a round that holds fewer finding-evidence records than findings (finding-evidence-count). On a round with findings, record-return now points its next_call= line at record-finding-evidence, and record-finding-evidence points its line at query-finding-evidence.
/prflow:spec asks before a draft makes code parse the layout of Markdown a model writes. Such code now reads only the parts the producer marks for machines by default; parsing headings, section order or bullet shapes becomes a question to the user, recorded as blocked on a run with no user. (#1557)
/prflow:spec Step 4 loads only the post-approval steps its run takes. /prflow:spec Step 4 now loads only the post-approval steps its run takes: filing a new issue or widening an existing one loads skills/spec/references/step-4-create.md, read alongside the approval re-query, so every pre-approval turn carries less text. Sub-step 3a now asks its decision question in the same reply that shows the audit summary line, the investigation record and the draft path, with the question last.
Review and review-and-fix no longer hold a pull request at REJECT on a checklist item’s own error. A re-review’s seed from the prior report is now re-checked against the reviewed head’s text rather than an excerpt copied from an earlier round, so a fix the review prescribed stops re-failing. A confirmed source defect and an unmet acceptance criterion still weigh at their severity.
New /prflow:help command troubleshoots a PRFlow problem. It asks what you ran and what went wrong, checks your PRFlow version against the newest release, other installed copies, the environment and gh sign-in, .prflow/config.json, the vendored copy, a failed cloud run’s log, and — for a local session — the model and effort level against the recommendations published at https://prflow.ai/docs/configuration/recommended-models-and-effort. It gives one verdict: setup problem (with the fix), likely PRFlow bug, or undetermined. Only a likely bug, or an undetermined case you confirm, gets a Markdown report under .prflow/tmp/help/ for you to review and share; the command posts nothing anywhere.
/prflow:spec checks comparisons between two runs. A drafted criterion or test that compares one run’s output with another’s is now grounded like a comparison with a fixed value, and must name the other run and the input both runs take. (#1597)
The weekly retrospective saves its learnings to the telemetry branch instead of opening a state pull request. Its records (retrospectives.jsonl, experiment-records.jsonl, overrides.json) and each run’s report now live under .prflow/logs/learnings/ on the telemetry branch. A run loads them into the untracked .prflow/learnings/ working copy, saves them before filing issues and again at the end, and opens no pull request. This also fixes a stale read: the run used to check out the default branch after opening its state pull request, so the filing caps and the report read last week’s files. A save refuses, pushing nothing, when someone else changed the stored records during the run; when the first save does not land, refused or failed, the run files no issue and the report says why. retro-helper.sh dismiss <pattern-key> now stops a recurring pattern. /prflow:init and install.sh --apply copy still-tracked learnings files to the branch and stage their removal for you to commit; a tracked file that differs from records already on the branch, or has uncommitted changes, stops them, staging nothing. The scheduled workflow no longer skips a week while a state pull request is open, appends the report to the job summary, and drops lib/open-state-pr.sh, lib/post-status.sh and scripts/retrospective-state-guard.sh. Bump prflow_version and re-run install.sh in the same upgrade. (#1511)
/prflow:spec offers to split a feature whose parts could ship separately. When one feature’s change spans several parts that could each ship alone as a useful PR, spec now asks whether to file one issue per part, so each PR is reviewed against a smaller diff and fewer criteria. You can decline the split; a non-interactive run files one issue and records the recommended split. (#1662)
/prflow:spec drafts that loosen a check now name what happens to evidence they cannot read. When a draft lets evidence exempt a case from a rule, or loosens, skips or demotes an outcome, its before→after mapping now covers each state in which that evidence cannot be read. Each state keeps its previous outcome unless the request names it; a new rule states each one’s outcome. Implement then builds that behavior up front instead of review rejecting the PR once per uncovered input. (#1661)
/prflow:spec revisions delete attacked text before adding remedies. When a review finding attacks draft text, a revision now deletes an unrequested criterion or moves derivable text to the investigation record instead of adding the finding’s remedy, so review rounds stop growing the draft. (#1664)
/prflow:spec no longer copies both documentation-check reports into its Step 1 evidence file. The file now holds a short record per lead (doc verdict and location, relevant files, and what it did not establish), so each spec run spends several thousand fewer output tokens and finishes Step 1 sooner. (#1659)
Stricter than criterion and Disputed criterion lines in a pull request description quote the criterion’s text. They no longer cite its number, so amending the issue can no longer point a line at the wrong criterion. A PR review counts a Stricter line only while its quoted text matches a current criterion; a line whose criterion was reworded or removed, or a numbered Stricter line written before this release, is ignored until a fix pass discloses again.

September 30, 2026

The fix-delta gate now applies your review-and-fix extension. The reviewer /prflow:review-and-fix runs over each fix iteration’s changes now receives your .prflow/skill-extensions/review-and-fix.md rules as review policy, so the checks you wrote for it apply in the iteration that needs them. That reviewer sometimes runs without them — for example when the pull request changes the extension file, or when the file sits behind a symbolic link. (#1456)
The coverage, error-handling and code reviewers grade findings in the engine’s severity words, with no scores. The coverage reviewer (pr-test-analyzer) and the error-handling reviewer (silent-failure-hunter) label every finding Critical, Important or Suggestion, and the code reviewer (code-reviewer) labels every finding Critical or Important; none emits a numeric rating, a confidence score or a CRITICAL/HIGH/MEDIUM band. A missing test for an edge case of working code is now a Suggestion, so at the default fix threshold important the fix loop reports it instead of writing the test, unless the convergence shadow’s park calibration promotes it. A missing test is Important only when a changed function’s main behavior is untested, and Critical only when its regression could lose or corrupt kept data, open a security hole or stop the whole system; a coverage gap the old scale rated highly for a user-facing error is no longer Critical by default. Code the coverage reviewer finds already wrong is reported as a defect graded by fail direction, so one that can lose data now reaches Critical, and a previous test_gap deferral no longer matches it until it is deferred again under its new kind. A code-reviewer finding that reached Critical only through a high confidence score is now Important, and a code-reviewer bug that can lose data, open a security hole or stop the system is now Critical. A recorded test-authoring waiver no longer lowers any review grade: review stops reading it, while the fix loop still does not re-impose waived ceremony on the surfaces a waiver names unless review grades that ceremony’s finding Important or Critical. No verdict rule or threshold changes. (#1564)
/prflow:spec names the search behind every set of existing members it claims is complete, and re-runs it or marks it superseded when, for example, an answer or revision changes the design. (#1438)
The review accepts a stricter-than-criterion fix disclosed in the PR description once a verifier confirms it against the code. In a pull-request review, a Stricter than criterion <N>: <case> — <why> line starting a line of the PR description, with N a decided criterion’s number, can now reach the checklist verifier for that criterion. When, among other conditions, the verifier confirms the code covers the case the line names and still meets every other case the criterion names, the criterion passes and a finding that only reports that departure moves to Informational — Deferred instead of driving a REJECT. A line the code does not bear out changes nothing, and a disclosure never clears a defect beyond the departure it names. The review’s Run details list each line’s outcome. (#1501)
/prflow:spec drafts now state a changed decision rule’s full before→after effect. A draft that changes a decision rule — for example a grade, route, verdict or guard — maps the rule’s outcome per input class and mode with the old rule quoted, and reads every effect claim from that mapping; universal claims such as “nothing else moves” are now found by what they assert rather than by keyword. (#1579)
A review re-checks a failed checklist item it doubts before rejecting on it. When the review’s own reading of a file in the reviewed code contradicts the evidence behind a failed checklist item at or above your verdict_severity_threshold, the review sends that item back to a verifier once, with the doubt as a claim to check. The re-check’s answer, a pass or a failure at its own severity, replaces the stored failure unless the source-view check rejects its evidence; an inconclusive or unusable re-check keeps the failure. Doubts resting on the pull request’s text or an author’s comment are not re-checked, and neither is an item settled by a text probe, an item whose cited file the review cannot read, or any item in a review whose verification results had to be written without the verdict helper. The report shows each doubt and its outcome only in Run details, instead of as a note under the failed item that changed nothing. Each re-check costs one more verification. (#1527)
The review-and-fix loop no longer runs its Loop Exit completion-evidence check under /prflow:implement. There the implement run’s own Phase 4.3 completion gate validates the final tree, so the loop builds no operand files, runs no validator, appends no — completion evidence: token to its verdict and records no reflection bullet for it — ending the run-after-run non-pass verdicts and forced retrospectives the check produced there. Standalone /prflow:review-and-fix and direct /prflow:fix runs keep the check unchanged. (#1529)
A re-review after a REJECT now always runs the full review. It no longer re-checks only the named blockers of the earlier REJECT. The first re-review keeps the REJECT, whatever severity it grades the problem, when it finds still untrue a PR line that a finding of the earlier review rejected under the untrue-line rule; inside /prflow:review-and-fix, each later iteration that re-checks it keeps it too while that line stays untrue. A few review-side conditions stop this carry, for example a re-check item the review could not build correctly. (#1482)
A direct /prflow:fix pass reviews its own fixes before claiming completion. A direct /prflow:fix pass that fixed at least one finding now has its own delta reviewed by one blinded subagent before it claims completion, using the review-and-fix loop’s fix-delta checks. The completion claim adds a fix-delta gate: <outcome> line and reads “complete” only when the gate is clean, refixed, skipped (no fix applied) or pushed back. Verification Gate item 2 also treats a PR-body sentence the fix made false as a documented falsehood to fix.
/prflow:spec criteria over a multi-clause rule name every clause they touch. /prflow:spec now makes a criterion or Verified: premise over a multi-clause rule name every clause, arm and ordering it touches, so a clause the draft never mentions no longer reaches review unaddressed.
/prflow:spec audit rounds route a missing dispatch pointer to a named failure. /prflow:spec audit rounds now send a round whose instruction generator printed no dispatch pointer to a failure route that names that case, and the Step 3.6 boundary read gives query-boundary’s call form, so the orchestrator no longer passes it a --draft-file flag it rejects.
Rule pointers replace restatements only where the rule’s home is loaded. The review-and-fix loop now replaces a restated rule with a pointer to the rule’s home only where that home is loaded wherever the pointer is read, and /prflow:spec keeps its universal-claim rule in one home with three load-scoped copies instead of restating its trigger in always-loaded files.
/prflow:review no longer skips an unreadable newer report in its prior-report re-check. /prflow:review’s prior-report re-check no longer skips an unreadable comment newer than the report it would select: it records prior-report: unavailable (comments-payload-malformed), capping the verdict at APPROVE WITH CAVEAT, instead of silently re-checking an older report.
/prflow:review waits for verifier verdicts in one call. /prflow:review Phase 2 now ends each verifier fan-out message (the first wave and each refused-dispatch re-issue round) with one foreground normalize-verdicts.py wait call over the launched ids, so a local pass is no longer woken once per verifier hand-back. The new wait mode polls the verdicts directory until an <id>-*.json file exists for every id, the deadline passes, or the directory exists but cannot be listed; it prints present, missing, waited_s and deadline_hit and exits 0 (a usage error exits 2, and an unexpected exception prints the helper’s internal-error object); ids still missing take the existing verdict_file_absent path unless the helper reports the directory not listable; that case and any other output fall back to collecting every dispatch as before.
A wrongly worded checklist item no longer rejects correct code. /prflow:review no longer rejects a pull request over a checklist item worded wrongly while the code is right. A paraphrased item whose verifier answers FAIL with inaccuracy_scope: none and property_proven: true now gets one re-ask, and a re-ask that proves the property stores PASS. The checklist generator no longer paraphrases a source more narrowly than it reads, and requires untouched text to stay only when a criterion or named rule does.
A criterion dispute is now decided once and can reach the PR description. A review-and-fix loop declines a finding over a disputed criterion once — for example, when the fix would contradict the criterion — then copies that decline forward and stops editing around the finding in later iterations. Before a criterion-conflict exit, for example a final REJECT whose every trigger is such a dispute, the loop now runs its blinded shadow pass; the verdict stays REJECT. Under /prflow:implement, each dispute can be written into the pull request description as a Disputed criterion <N>: line, so the maintainer can amend the criterion on the issue or accept it. (#1535)
/prflow:review-and-fix stops fixing findings the review deferred. /prflow:review-and-fix no longer routes a finding the review demoted to ### ℹ️ Informational — Deferred (an honored deferral, a confirmed stricter-than-criterion disclosure, or a disclosure foreclosure) to the fixer, the parked population or the shadow’s promotion test when it can pair that report line to the finding. Pairing is exact: a line that matches no finding (a corroborated line whose merged instance list differs from each finding’s included), matches several unrelated findings, or shares a finding with another line demotes nothing and is recorded as a phase4-demotion unpaired: note; so does an unreadable report. A demotion from a review the loop ran inline, without a dispatched engine agent, does not carry into later iterations.
A resumed /prflow:implement run can now reuse its earlier clean issue-claim audit and its committed Plan. The Phase 1.6 reuse gate no longer counts the run’s own authorized-workpad-decision items, and intake no longer files the run’s own unfinished review work as a correction. A Verified: premise refuted only because the branch edited the cited file is recorded as a branch-changed note and nothing else, unless an earlier audit already flagged that bullet or the run cannot read its saved workpad. The Phase 2 resume gate no longer requires a Plan row for the run’s own decisions or for verification, review and documentation obligations; it names each one it carries forward and still runs full discovery when it cannot classify an item. (#1528)
One workpad compaction now lasts a whole implement run. workpad.py compact moves bullets down to a low watermark (_COMPACT_LOW_WATER_BYTES in scripts/workpad.py) instead of stopping just under the warning line, so the next few notes no longer trigger another compaction. The moved bullets are appended to the issue’s newest overflow comment when it keeps its header lines and still has room, instead of a new comment on every call. The cloud-CI completion-evidence row is now stored compressed, and workpads written before this change stay readable. (#1547)
Review-and-fix now notes when a pull request edits its own review-and-fix extension. On each shadow review pass, review-and-fix records a Reflections note when the pull request under review edits any of its review-and-fix extension files, when any of those files has local changes (untracked or ignored copies included), or when their provenance cannot be checked, because its calibration gates read that extension. A run that ends without a shadow pass records no note. The note blocks nothing, and a run whose provenance checks pass sees no change. (#1472)
/prflow:spec states one decided behavior per fork. /prflow:spec’s no-options rule is now a short semantic rule instead of a word list with exemptions: an issue states one decided behavior per fork and leaves no alternative, open question or deferred choice outside ## 🚫 Blocked. Wording the user approved, or wording the issue prescribes for the implementer to ship verbatim, is never reworded silently by any check (the check asks you instead), so a definition that uses “could” in its possibility sense keeps the meaning the user approved. Follow-up issues drafted by /prflow:implement and issues filed by the retrospective audit read the same rule. (#1569)
A re-review checks a Disputed criterion <N>: line against the criteria, so a point the criteria settle stops rejecting the PR. /prflow:implement records a fix it declines because it would weaken or contradict criterion N as one Disputed criterion <N>: line at the end of the PR body; a direct /prflow:fix pass now does too. On the next review, the check that re-verifies an earlier failure reads the line with the issue’s criteria and passes only when a criterion’s words settle the point and the code shows it — for example, a criterion that excludes the arm the finding asks for. A finding that repeats only the earlier failure that check passed moves to Informational — Deferred. A line the criteria do not bear out changes nothing: the failure and the verdict stand. (#1441)
A resumed cloud implement run continues its review-and-fix loop instead of restarting at iteration 1. Each fix-applying iteration now records the head it ends on (iteration_head), and a resume binds that record through base-merge commits added since, so a rate-limit or stall death costs only the interrupted iteration and the iteration cap holds. A resume that committed no new implementation work, with a clean tree, also skips the Phase 3.2 cleanup pass. A record written before this change carries no iteration_head, so a re-fix commit after the head it recorded ends its continuation; on the cloud tier, repositories with telemetry disabled keep the fresh start. (#1537)

September 29, 2026

Untrue internal documentation no longer blocks a review. /prflow:review: an untrue sentence in internal documentation that the review shows no tool or agent reads to decide behavior no longer blocks a review at a critical or important verdict threshold, while the report still lists it and the fix loop still corrects it when its stored severity meets the fix-severity threshold (#1425). Prose an agent loads as instructions (a skill or agent body, CLAUDE.md, AGENTS.md, a prompt extension) now counts as behavior-affecting.
Review docs describe the internal-documentation cap. /prflow:review’s published docs now state that an untrue sentence in internal documentation no tool or agent reads to decide behavior no longer blocks a review at a critical or important threshold, while the report still lists it and the fix loop still corrects it; /prflow:fix states that an untrue line in a README, published doc, release note or user-facing message always blocks (#1425).
/prflow:spec now makes an issue account for the guards or guarantees it deletes or narrows and keeps a doc criterion from asking for a restatement of the conditions of the rule it describes, and /prflow:implement’s operand trace no longer counts agent recall across a subagent dispatch as a producing step — for example, a draft that deletes a guard names the mechanism still bounding it or accepts the loss, the approach menu offers deleting such a guard, the audit flags repairing one, and a doc criterion asks for a pointer or a one-line effect (#1516).
/prflow:spec Step 4 classifies its run-state files with a helper mode instead of reading ls -lL rows. scripts/cleanup-spec-run.sh --probe-run-state <slug> --root . checks the run’s two run-state files with bash file tests and prints one path=<path> class=present|absent|unestablished line for each, which the draft message shows; an empty or unsafe slug prints one run_state=unestablished reason=unsafe-slug line instead, and otherwise a missing or non-directory --root prints one run_state=unestablished reason=no-root line. The always-loaded skill text no longer carries the ls row-reading rules, and the classification no longer depends on which ls the host ships. (#1381)
/prflow:spec now widens an existing issue only from a non-empty body and reports the outcome accurately. An update never sent is reported as not attempted, with the reason; a failed read-back as unverified rather than a failed write. (#1434)
A review now reports every instance of a defect class in the same pass. Each reviewer checks the diff, and each file a finding names, for other instances of the class it found: sibling branches, mirrored or coupled sites, and restatements of the same claim. It groups one file’s instances into one finding that names each with its line, and reports another file’s instances as that file’s own finding. A rejected pull request therefore gets the whole class in one round instead of one gap per round. The test-coverage reviewer lists every untested input shape, input combination, caller-supplied value and branch of a new or changed function that it rates 5 or higher, in one finding per function. A finding line can be longer, and a review can report fewer findings. No verdict rule or severity threshold changes: each instance keeps its own severity, and a grouped finding carries only the severity its most severe instance already had. (#1510)
Fixers and reviewers remove or point at a rule before adding to it. Fixers, reviewers and implement’s claim sweep now delete or point at a rule’s home before adding — for example, a fixer deletes a failing claim before rewording it, and a reviewer’s suggested fix leads with removal or reuse — docs passes point at a rule or describe its effect instead of restating it, and in /prflow:fix a fix that changes what a rule decides re-reads the issue’s acceptance criteria; a fix stricter than a criterion is disclosed, for example as a Stricter than criterion line in the pull request description.
Review-and-fix now checks each working-tree copy of its extension before trusting the shadow review. On runs that load the extension from the working tree (for example local, interactive and cloud implement runs), the shadow review’s provenance check looked only at .prflow/skill-extensions/review-and-fix.md. It now also covers the legacy .prflow/prompt-extensions/ file and the superseded .devflow/ directory, so a pull request editing one of them is reported as not independently verified (“shadow agreement not verified”), the same as one that edits the canonical file. A symlinked extension file or extension directory now always reports the shadow as not independently verified, and so does a gitignored local copy of the extension. (#1513)
A review re-checks the defects the pull request’s previous review reported. A pull-request review, except one the blocker-recheck fast path settles, reads the newest PRFlow review progress comment on that pull request stamped with its posted verdict, other than its own, that GitHub Actions or an author your allowed_bots or allowed_users settings trust posted. A report voided as incomplete is passed over, and a * in allowed_bots trusts no bot beyond GitHub Actions and the ones it lists by name. Each failed checklist item and each finding in it, except a finding the report lists under Informational — Deferred, becomes a checklist item verified next to the freshly generated ones. One that still fails blocks the verdict like any other failed item; one that passes explains why the earlier evidence no longer holds. The report’s Run details records which earlier report was used, or why none was (including how many untrusted reports were skipped). A review that could not establish the earlier report (for example, when the comments cannot be fetched or an author’s permission cannot be checked), or whose re-check items did not all reach the checklist, is capped at APPROVE WITH CAVEAT, and so are the later passes of a review-and-fix loop after such a first pass. A later pass of a review-and-fix loop no longer drops an item the previous pass failed because the fix changed its file; it verifies the item again. Each re-checked defect costs one more verification. (#1512)

September 28, 2026

Spec loads contract guidance for Testing Strategy assertions and reuses quality-group rules during its draft check, reducing duplicated instructions. (#1378)
The default claude_model is now claude-opus-5-5. New installs and re-scaffolds that lack a claude_model key get Claude Opus 5.5 instead of Claude Opus 5; an existing claude_model value is kept.
Unverifiable checklist items no longer reject a PR. /prflow:review no longer rejects a pull request over a checklist item it could not verify. An INCONCLUSIVE item now gives APPROVE with notes at any verdict_severity_threshold, and the report lists it under a ### Unverified heading for the human merger. The verdict is capped at APPROVE WITH CAVEAT when the checklist holds at least one item and every item is inconclusive, or when an item is inconclusive because verification itself fell short, such as a verifier that timed out. A checklist FAIL still rejects at or above the threshold. /prflow:review-and-fix no longer keeps a REJECT on an INCONCLUSIVE item, and on an APPROVE WITH CAVEAT verdict it still fixes findings and failed checklist items at or above fix_severity_threshold; a checklist item it left inconclusive that the final shadow review fails now counts as a new failure. The blocker-recheck fast path accepts a prior report with inconclusive items. (#1423)
Share trigger-time configuration across command and implement workflows. A refreshed workflow now fails with an upgrade instruction when its installed config action lacks projection support or its projector script is missing or unreadable, including when the workflow is disabled in config. (#1397)
/prflow:review-and-fix reviews its own fixes before stopping. /prflow:review-and-fix no longer stops early on a REJECT whose driver it fixed in the same iteration: when the iteration fixed a REJECT driver or any finding or failed checklist item at or above fix_severity_threshold, or its fix records cannot be confirmed, the loop runs one more iteration so the engine reviews the fixes, up to max_iterations. Any other REJECT still converges as before. /prflow:implement’s changed-contract sweep now also finds every reader of an output value whose inputs changed, such as a verdict, status, exit code or field value, and checks that each reader routes the new inputs. (#1439)
/prflow:spec now accounts for each universal-quantifier sentence it leaves unpinned. Step 3.5’s universal-quantifier sweep records how many quantifier sentences it pinned and removed, and each sentence it keeps unpinned with a locator and its reason, instead of a bare “no ungrounded universal quantifier” line. The universal-quantifier rule it applies now covers every universal quantifier asserted about the system under change outside ## 🚫 Blocked, Implementation Notes included, so such a “never” or “always” sentence there must be pinned, scoped or removed unless it is mandated template boilerplate or rule text the change ships. (#1323)
spec-context-eval.py measures whole /prflow:spec runs. scripts/spec-context-eval.py now measures a whole /prflow:spec run. A run starts at the first main-thread record labelled with the spec skill and ends at the end of its session file (in manifest mode, of its declared event span), so the records Claude Code writes without that label after a subagent hands back are counted too. turn_count counts API turns, and a response written as several records adds its output tokens once. In corpus and paired mode, a turn shared by a resumed or forked session file and the file it was copied from counts in at most one of them when they share a corpus (in paired mode, on the same side). Run records gain cumulative_context, the summary gains median_turn_count and median_cumulative_context, and the paired delta gains mean_cumulative_context_per_run. The skip channels a session folder’s subagent transcripts, .meta.json and custom-title.json files and tool-results/*.txt files land in no longer make the paired context deltas read unestablished. The shared transcript reader, used by the cloud review job’s evidence gate, now reads a JSONL record holding a raw U+2028, U+2029 or U+0085 as one record. (#1332)
The shared marker readers now recognize CRLF marker lines, and the verdict-gap classifier no longer accepts trailing-text markers. COMMENTED reviews with a line-1 <!-- prflow:review-verdict> prefix now fail closed instead of being skipped during verdict selection. (#1398)
A pull request that edits the review-and-fix extension can complete after a clean review. When a pull request edits .prflow/skill-extensions/review-and-fix.md and its shadow review runs as a fanned-out engine pass with no parent-issued reviewer dispatch, that edit no longer keeps the shadow agreement from being verified, so /prflow:implement no longer stops Blocked at finalization for that reason. An inline shadow of such a pull request is still reported as not independently verified. (#1468)
/prflow:implement now rechecks the acceptance criteria when one of the sweeps it runs between writing and testing the code adds, removes or changes a path from a condition to an outcome that the plan does not describe, fixes or reverts a sweep change that makes false a criterion the issue’s Desired Behavior supports, and can rewrite, or defer to a follow-up issue, criteria that recheck finds can no longer all be met. (#1457)
A cloud implement run that auto-resumes on its last allowed attempt is no longer reported as 💥 Failed. When the agent job failed after the stall backstop had already posted the resume that reached stall_backstop.max_resume_attempts, the recovery job counted that resume, read the cap as exhausted, and marked the issue 💥 Failed with a “re-run manually” comment while the resumed run was starting. It now logs a warning and leaves the issue alone when its resume check reports a resume already posted for that run or reports that it could not read the issue’s comments; otherwise it still marks the run 💥 Failed. (#1477)
A repeatedly skipped finding no longer stops /prflow:review-and-fix. /prflow:review-and-fix: a finding skipped in two consecutive iterations no longer stops the loop. It still reports “Finding persists after pushback … Manual review needed.”, now once per finding per run, and a finding the earlier iteration settled by disclosure still does not trigger it unless it drives the current REJECT. The loop then continues as it would without the repeat skip; for example, an iteration that ended in REJECT after fixing its driver now gets another review pass, up to the iteration cap. This holds for standalone runs as well as /prflow:implement runs.
Acceptance-criterion verifiers now check the code’s other branches under a criterion’s condition before passing it (for example, an error path that silently allows the opposite outcome now fails the criterion). (#1458)
/prflow:implement restate re-dispatches no longer force unmet. /prflow:implement Phase 3.4: a restate-evidence re-dispatch no longer tells the evidence verifier to record a measured value and report unmet whenever it differs from the stated terms. The prompt now only states that satisfied needs the two strings byte-equal, so the verifier’s own rule decides when to copy the stated terms. The prompt no longer pushes a criterion met except for behavior a sibling criterion requires to unmet, so it can tick on restate.
Checklist claims state what must hold. /prflow:review: the checklist generator now words every item’s claim as what must hold — for an item about authored text, what that text asserts — and puts a suspected defect in the item’s verify hint. Before, an item about authored text written as a suspected defect that the verifier disproved was stored as a FAIL that could not be normalized, so a proven-correct PR could be rejected with nothing to fix.
An implement run whose PR edits its own review-and-fix extension no longer stops Blocked at finalization. When the fix loop’s shadow returned every reviewer and raised nothing new, but its prompt attestation recorded only extension-provenance entries (the edited .prflow/skill-extensions/review-and-fix.md), the run recorded unverified shadow coverage with no admissible cause and stopped Blocked with the PR left draft. The run now records a shadow-coverage disposition with the new cause class extension-provenance and publishes; the workpad’s disposition row and its Action-required reflection state that shadow agreement was not independently verified. workpad.py admits this cause only for the shadow-coverage gap and only when every always-on reviewer’s roster row reads dispatched and no member reads missing. A run with any other prompt addendum still blocks. (#1484)
Warn when a review progress comment cannot be marked failed, and stop the workflow’s stale-REJECT safety net from dismissing earlier change requests when the cloud review evidence gate fails. (#1293)
Aligned spec drafting guidance with its issue template. The worked example now uses an already-chosen dependency and declares a documentation deliverable, and the creation step accurately points to the posting recipe. (#1380)
A review no longer approves an unmet acceptance criterion on an exception it never showed. A finding that shows the change misses a decided acceptance criterion of the linked issue is excused as sibling behavior or extra coverage only when the report’s Run details show that the exception covers that finding. Otherwise, including when the reviewer cannot read the checklist verifier’s definition of the exceptions, the finding still rejects the PR. (#1432)
Re-mirror amended acceptance criteria with workpad.py acs-remirror. After amending an issue’s criteria mid-PR, run workpad.py acs-remirror <issue> while no implementation run is live on the issue (it refuses unless the workpad’s Status is Complete), then re-review: it re-mirrors the criteria from the issue body (it accepts no other source) and records one progress note. The review report no longer calls such an amendment a sibling PR’s overwrite or reports the new criteria as dropped findings: it names both possible causes, lists them as “not in the workpad”, and points at the command. (#1492)

September 27, 2026

New test guards can now be mutation-checked when the test suite cannot be pointed at a copy of the file. /prflow:review-and-fix and /prflow:implement still break a copy when the guard’s test accepts one. When the test can only read the file where it lives (at a fixed path, through a module import, or through a directory root), they now break the file itself, run the single focused test, and restore its exact original bytes, checked against a saved copy, before committing it. If those bytes cannot be restored, the run stops instead of committing a broken file, and /prflow:implement refuses every checkpoint commit, whichever files it includes, until every unsettled check is settled. Previously both allowed only a copy, which such suites could not use. (#1219)
/prflow:spec builds the investigation record with a bundled helper. /prflow:spec now assembles the investigation-record comment with a bundled helper, scripts/build-investigation-record.py, instead of having the model copy the decision-record sections or write its own extraction script. The helper folds the Considered-and-rejected: line and the criterion disposition, steelman, self-audit and evidence-bundle sections into the record (self-audit is a planned new name for the steelman section; no spec step writes it yet), breaks the /prflow:, /devflow: and @claude workflow-trigger tokens with a zero-width space, and keeps the record within 65,536 UTF-8 bytes, a conservative bound on GitHub’s 65,536-character comment limit, by truncating the largest folded sections first and then omitting whole ones under a notice naming them. When the record cannot fit that bound or the helper cannot run, the record is not posted, instead of being posted without its folded sections.
/prflow:spec checks each limit a revision accepts. /prflow:spec’s revision-batch draft-consistency check now also covers each limit a batch accepts — a case the batch’s own mechanism knowingly leaves uncovered. The limit passes only when every Desired Behavior sentence and acceptance criterion covering that case states it; otherwise it is a draft-consistency conflict and the batch is revised before the draft is presented, so a limit a revision accepts no longer leaves an approved criterion promising the case it leaves out.
/prflow:review reads the unmet-criterion rule alongside sibling criteria. /prflow:review no longer rejects, with no deferral possible, a PR whose code meets an acceptance criterion as the other acceptance criteria limit it. The unmet-decided-criterion rule now allows the two departures the checklist verifier already allows: behavior another criterion requires, in the case that criterion names, and the criterion’s required check applied to more files, inputs or cases than it names, unless a criterion excludes that. A finding either exception removes stays in the report and is weighed against the configured severity threshold. A departure on a case no other criterion names still rejects.
Refining an existing issue with /prflow:spec no longer fails its body check on a faithful write. After rewriting the issue body, spec now reads it back with gh api … --template '{{.body}}', which adds no trailing newline, and requires an exact match. The previous --jq .body read-back added a trailing newline, so every faithful write looked different from what was sent. (#1384)
/prflow:implement’s criteria gate grades criteria alongside their siblings. /prflow:implement’s acceptance-criteria gate now grades each criterion as limited by the issue’s other criteria, as /prflow:review does, so a run no longer spends a fix, rewrite or deferral on a criterion review would pass. Behavior another criterion requires in the case it names, and extra coverage no criterion excludes, no longer fail a criterion on the gate’s first grading; a re-verification after a fix still grades each criterion alone. A criterion the code does not meet, including a path no other criterion names, still blocks the gate. (#1339)

September 26, 2026

Pre-audit /prflow:spec drafts show a short audit summary. /prflow:spec: a draft presented before any audit round now shows a short audit summary line — the audit has not run, the body and investigation record are unaudited, plus the acceptance-criteria count and bundle coverage — instead of a line of placeholder audit fields. Runs with a completed round, or with lost audit state, keep the full line.
/prflow:spec no longer promises an issue that does not exist. /prflow:spec no longer drafts a body that promises an out-of-scope item “needs its own issue” when no such issue exists: the body links a tracking issue the run already knows, or states only the scope boundary, and the run names each unlinked item as unfiled in its final outcome.
/prflow:review grades each criterion alongside its siblings. /prflow:review now grades each acceptance criterion as limited by the issue’s other criteria, so a correct PR is no longer rejected on one criterion’s wording. Behavior another criterion requires in the case it names, and extra coverage no criterion excludes, no longer fail a criterion when the run’s criteria list is readable; otherwise each criterion is graded alone, as before. A failing criterion still rejects the PR, and its report line now says to fix the code or have the issue author amend the criterion instead of calling it a checklist-construction failure.
/prflow:spec checks each revised sentence against the whole draft. /prflow:spec: each sentence a draft revision adds, changes or removes, an auditor’s recommended edit included, is now checked against the rest of the draft, so a fix no longer contradicts another acceptance criterion, drops an exclusion one states, or adds an open-ended obligation. Advisory edits from an audit round that clears the draft for filing are no longer applied automatically; they reach the draft only when you choose Change something first at the approval step. (#1331)
Local implement and review-and-fix runs warn on a vendored-version mismatch. When a committed or leftover .prflow/vendor/prflow/ tree carries a different version from the plugin your session loaded, a local /prflow:implement or /prflow:review-and-fix run now prints one warning naming both versions, both plugin.json paths and the remedies, and continues, instead of silently mixing one release’s skills with another’s helper scripts. /prflow:implement also records a note reflection naming both versions on its issue workpad. When a vendored tree is present but either version cannot be read, the run prints one warning naming the cause and continues. (#1232)
Unmatched checklist citations no longer reject a PR. /prflow:review no longer rejects a PR because a checklist verifier wrote its file_checked citation in a form the collector cannot match. Such an item keeps its verdict and severity, and the report lists it on one non-blocking Unmatched citations (not blocking): line. A citation still blocks as path-outside-view when it names an unwritten path, or when one of its ;-, ,- or and-separated parts, read as a single path, is absolute, drive-lettered or home-relative (~ or ~user/…) outside the reviewed view, climbs above its root, or lies under the other bound view.
Native Windows: allowlists read correctly in the deferral and lint-adjudication matchers. On native Windows, the deferral matcher now reads prflow.allowed_bots and prflow.allowed_users, and the lint-adjudication matcher prflow.allowed_bots, correctly, so deferrals from a trusted PR author and adjudications from an allowlisted comment author are honored instead of being rejected as untrusted.
Native Windows: consistent forward-slash paths and aliased --out paths accepted. On native Windows, the review loop’s entry binding, the early-shadow stamp’s path_set and diff_patch, the prior-run scan’s unlistable-directory message and the AC verifier’s dispositions_path now report paths with forward slashes, as they already did on Linux and macOS; the scan’s per-run error messages no longer carry the OS error’s file path. parse-acs.py --out also accepts an absolute path below .prflow/tmp that reaches the repository through a short (8.3) name or a symlink, and refuses one whose parent directory resolves outside .prflow/tmp through a symlink. (#1355)
Issue-body caching works through aliased repository paths. /prflow:implement no longer refuses to cache the issue body when the cache path is spelled through an alias of the repository root, such as a Windows short name (RUNNER~1), a subst drive, or macOS /tmp. (#1358)
A failed workpad read no longer drops post-merge checks from the PR description. /prflow:pr-description now reports whether its workpad lookup read the workpad, found none, had no issue number, or failed, and a failed read keeps the existing Post-Merge Verification section instead of removing it. Implement runs cross-check the reported post-merge count against the workpad and raise an Action-required reflection, naming the failure cause, when the lookup fails or the counts disagree. Rows ticked with an uppercase [X] or indented now count as post-merge items. (#1182)

September 25, 2026

/prflow:spec audits on native Windows now establish steering. The audit instruction file was written with Windows line endings, so every audit round reported steering as not established and offered a re-audit that could never succeed. The file now holds the exact bytes the audit checks against, so a clean audit round establishes steering on Windows as it does on Linux and macOS. (#1210)
A review checklist item checked by a quick text search now claims only what that search checks. Such an item skips the verifier and passes when one exact string is present, or absent, in one file. A claim that says more, about several files, a count, a meaning, or the whole repository, now goes to the verifier instead of passing unchecked. (#1259)
/prflow:implement now fixes documentation it makes out of date during implementation. When a change makes an existing sentence in your docs false, the run now rewrites that sentence during implementation, so the in-run review checks it along with the code. Previously the run left the sentence for the final documentation step, and the only review of that edit came after the run. New pages and new content still come from the final documentation step. (#1246)
The PR review comment now leads with the verdict and collapses its detail. A finished /prflow:review comment shows the verdict, the rule that decided it and a one-sentence merge-readiness summary first, followed by the findings and checklist results that need action. Suggestions, passed checklist items, failure evidence, the per-agent reports and run diagnostics sit in collapsed blocks one click away. The status line now names the reviewed commit, and the comment no longer carries run-telemetry or effectiveness-trace sections; the telemetry record is still saved to the telemetry branch wherever it was saved before. The verdict rules are unchanged. When the cloud review evidence gate fails a run, the comment’s verdict now reads REVIEW INCOMPLETE — review evidence gate failed: … instead of keeping the unbacked verdict. (#1228)
lint-changed no longer fails on findings from a ruff outside your pinned family. A ruff whose major.minor differs from the lint manifest’s pin reports a different rule set, so preflight.py lint-changed --fail-on-findings no longer exits 1 on its findings and prints LINT-CHANGED unverified ops=<ids> reason=ruff-family-skew reported=<X.Y> pinned=<A.B> instead. A CI verification request is no longer refused over them. A ruff whose version cannot be established, or a skewed ruff that times out or fails to launch, still gates as before. (#1199)
A review no longer rejects a verifier’s verdict because its evidence quotes a json code fence. A verdict file that is a valid JSON object is now read as the verdict it holds, and a code fence counts only when its markers start a line. Before, a fence quoted inside the evidence, such as a test fixture, was taken as the verdict and reported as unparseable, which forced a critical INCONCLUSIVE item and could reject the PR. (#1254)
CI verification no longer reuses a cancelled run. After ci-verification-request.py wait prints CANCELLED, SUPERSEDED or STALLED, the request is marked as settled with no verdict, so the next request for the same commit no longer prints REUSE for it. --force-dispatch is no longer needed to recover. A new optional wait --cancel-queued-after <seconds> operand cancels a run whose job has waited for a runner at least that long and prints STALLED with exit status 6. Without the operand, wait never cancels a run or prints STALLED. (#1184)
Acceptance criteria that conflict or cannot be met as written no longer reach the cloud review unresolved. /prflow:spec now flags three more conflict shapes before an issue ships: a criterion requiring what another bars, a criterion that drops a qualifier or exclusion another states, and a criterion guaranteeing an output produced only on some outcomes. /prflow:implement checks the criteria for conflicts, and for a criterion no requested change can make true, when it writes the plan. It rewrites the fewest criteria that resolve a defect, recording each rewrite as a scope decision, or it defers the conflicting set to a follow-up issue when a rewrite would drop a guarantee the issue’s Desired Behavior states or would have to pick a reading Desired Behavior leaves open. The Phase 3.4 acceptance-criteria gate routes the same defects the same way. (#1252)
/prflow:implement’s Documentation Needed gate no longer counts a deliverable page as delivered just because an earlier phase edited it. Each named deliverable is now judged by whether a commit in this docs pass touched it, or whether it is in the run’s diff and a docs subagent returned an already-current: <path> — <section heading> line for it. The self-heal re-check uses the same docs-pass range. (#1266)
A review voided by the cloud review evidence gate no longer reads as approved. The review progress comment no longer keeps its prflow:review-verdict marker, so once the voided review is dismissed the verdict deriver reads that run as incomplete instead of approved and the stale-REJECT cleanup no longer acts on it. workpad.py patch gains --drop-leading-marker KIND so a caller can remove a leading marker on purpose. The review report’s Checklist errors line now says each listed item blocks only at or above the verdict severity threshold. (#1270)
Shipped shell helpers now run under macOS’s stock /bin/bash 3.2. /prflow:implement on a Mac with no newer bash first on PATH stopped Blocked after gh pr create succeeded, because resolve-existing-pr.sh could not read the new PR’s URL; fetch-pr-context.sh, which the local retrospective runs, failed to parse. Both now work, as do flip-review-progress-failed.sh, render-grounding-block.sh and scrub-transcript.sh; output under newer bash is unchanged. (#1291)
A failed stall cancel no longer settles the CI verification request. When ci-verification-request.py wait --cancel-queued-after reports STALLED … cancel=failed, the request stays unsettled unless an earlier wait for it printed CANCELLED, SUPERSEDED or STALLED … cancel=ok. A later request for the same head without --force-dispatch then reuses the newest unsettled run it has correlated for that head, normally the stalled run, instead of dispatching a second run that competes with it for runners. The next wait --cancel-queued-after retries the cancel if a job is still queued past the bound. With --cancel-queued-after, a PENDING line now ends with stall-check=unestablished when a run view read during that wait returned data that stall detection could not use. (#1272)
Re-running /prflow:implement on an issue no longer stops at setup on Windows. When an earlier run left a git repository or other read-only files in the issue’s scratch folder, Windows could not delete them, so cleanup failed and the next run on the same issue stopped with UNAVAILABLE create. Scratch cleanup now clears the read-only flag and retries the delete once, and it handles folders nested past 260 characters, so these leftover folders are removed. When the issue’s scratch folder is itself a symlink or a junction, cleanup still refuses it and deletes nothing through it. (#1205)
/prflow:implement’s code explorer no longer pastes source into the run. It now answers with the file path, the line range and a summary in its own words even when asked for quoted or full-text lines, so the run’s context no longer carries a copy of a file it reads again before editing. (#1160)
The review now honors deferrals from local implement runs and, once prflow.allowed_bots holds *, from repositories without the PRFlow GitHub App. A pull-request author is a trusted deferral filer when it is a bot listed in prflow.allowed_bots, any bot whose head branch is in your repository (not a fork) while prflow.allowed_bots holds a * entry, or a human who passes prflow.allowed_users and has write, maintain or admin access. Previously only a listed bot qualified, so a run opened under your own login, or as github-actions[bot], had every deferral rejected and its parked findings counted at full severity. The PRFlow trigger gate reads a * in prflow.allowed_bots as a literal login, so an unlisted bot still cannot trigger a run, though claude-code-action’s own bot check, which receives the same list, reads * as all bots; set prflow_retrospective.watched_authors explicitly when using it, since the retrospective otherwise reads its authors from that list. When the permission check cannot complete, the review says so instead of reporting a policy rejection. (#1078)
/prflow:fix and the review-and-fix loop now check the claims a fix writes before committing it. A comment, doc or release-note sentence a fix adds or edits is re-checked in full. A claim about what changed (“as before”, “previously”) is checked against the base commit, and a claim about a setting’s meaning is checked against every place that reads the setting. (#1308)
Branch setup runs its first command in worktree-isolated sessions. A local /prflow:implement run no longer loses a turn at branch setup to a refused helper command: the branch-setup and issue-claim-audit agents now name the helper directory as a placeholder they fill in, instead of a shell variable the session refuses. (#1208)
A met bound no longer fails the implement acceptance-criteria gate on wording alone. When a measurement meets a bound of any direction or wording, the evidence verifier now records its observed value as an exact copy of the stated terms and keeps the measurement in its evidence. A criterion that states both a bound and a set of cases records the bound, and is unmet when any case is uncovered. A restate re-dispatch now tells the verifier the two values must match exactly and adds no other format instruction, so a correct criterion ticks without extra restate rounds. (#1179)
/prflow:review on Windows no longer stops on a file name Windows cannot store or read back. Previously, a reviewed commit holding a name such as a?b, a:b or a name over 255 characters stopped the whole review. A name such as NUL, x. or y was written but read back empty or as another file’s bytes. Each such file is now recorded as unreadable, and a passing claim about it grades INCONCLUSIVE; a symlink with such a name is recorded as a symlink. The rest of the review goes on. A name is treated this way when it holds <, >, :, ", |, ?, * or a character with code 0–31, ends with a space or a period, exceeds 255 UTF-16 code units, or is NUL in any letter case. Other reserved device names, such as CON, COM1, aux.c or nul.txt, work on current Windows and stay reviewable. On older Windows builds, a claim about such a file can read the device instead. macOS and Linux write the same files as before. (#1204)

September 24, 2026

Agents no longer open with a failing shell call on local runs. Each Bash-capable agent now reads .prflow/tmp/command-shapes.md once with the Read tool instead of probing it with ls or cat. A missing, refused, errored or empty read is final, so local runs, where the file never exists, skip the shell error each agent used to hit. Cloud runs that have the file still limit their commands to the shapes it permits. (#1129)
Padded denial counts read the same on jq 1.8. scripts/build-denial-record.sh and scripts/extract-execution-shape.sh now strip surrounding whitespace before parsing a string denial count, so a padded " 7 " publishes the count 7 and a padded " 0 " publishes permission_denials: absent on jq 1.8 hosts (Homebrew, the Windows runner image) exactly as on jq 1.7. (#1082)
Reviews stop re-checking a correct PASS whose commit id lost its last characters. When a checklist verifier records a 12–39-character lowercase hex prefix of exactly one of the run’s bound head or base revisions, the review collector now expands it to that full revision and grades the verdict as usual, noting the expansion in its input warnings. A prefix of both revisions, of neither, or shorter than 12 characters is still treated as missing. (#1113) The shipped workflows now pin anthropics/claude-code-action to the tagged release v1.0.233 (commit 8cf3482550831fb35a4fc3fbf7ca139cf8028b4c, installing Claude Code 2.1.281) instead of an untagged main commit. When a concurrent writer rejects the telemetry push, the re-parent onto the fetched tip now spawns git processes bounded by the number of paths that differ between the two tips instead of by the number of stored paths, so a review-and-fix Loop Exit’s --persist no longer stalls as the telemetry store grows. The review engine’s view materialization now stops with a view-path error naming the refused path when the reviewed commit writes a file or directory at root inventory.json or inventory.json.tmp. Previously such a file was silently overwritten with the view manifest and a directory failed as an opaque filesystem error. Such a repo still cannot be reviewed; the stop now says why.
Review no longer approves a pull request whose checklist verifier confirmed a false authored sentence. When a verifier passes a checklist claim about a comment, doc line or other text a person wrote in the code, but also reports that this text is itself false, the review now records that item as a failure marked CONFIRMED SOURCE DEFECT (raw PASS) and rejects the run, the same outcome as when the claim is worded the other way round. On a run that binds commit views, if the verifier’s view of the code cannot be confirmed, the item is still reported as inconclusive rather than as a confirmed defect. (#1140)
An implement run whose final review REJECT is downgraded to a caveat can now complete. When the review-and-fix loop’s final REJECT qualifies for the downgrade to APPROVE WITH CAVEAT (every remaining trigger set aside as out of scope, already tracked, or a disproved claim), the loop now runs its independent shadow review on the final iteration first. The downgrade stands only when that shadow, with full coverage and an attested prompt, returns a non-REJECT verdict with no new Critical or Important finding and re-grades no parked finding; any other shadow result ends the run as REJECT, without starting another iteration. (#1122)
Reviews no longer stop on Windows when a tracked file’s path is too long. On Windows, the review’s copy of your repository is now written through extended-length paths, so a path of 260 characters or more is copied like any other file, even with Windows long paths turned off, as long as no single file or folder name exceeds 255 characters. On macOS and Linux, a file whose name is too long for the filesystem to store is recorded as unreadable instead of stopping the whole review: claims about that file are graded inconclusive, and the setup summary line reports how many such files there were (path_too_long=<N>). (#1190)
Implement’s code-writing step, review-and-fix’s fix step, and finalization’s docs and PR-description steps now edit files with the Edit tool, never a shell-scripted text replacement. On Windows the Bash tool collapses a doubled backslash, so a shell edit could exit successfully without landing or corrupt the file. (#1191)
implement no longer re-litigates an old CI failure when newer runs are green apart from jobs you skip on purpose. List those job names as skipped by design in your implement prompt extension, exactly as GitHub reports them when skipped. A green run whose only skipped jobs are on that list now counts as a pass, so an older failure behind it no longer triggers covering-check re-runs or a repair attempt. Without a list, behavior is unchanged. (#1185)
Verification-checklist problems now block a review only when they are serious enough. The review’s checklist checker now grades each item critical, important or suggestion by how much would break if the claim were false. A FAIL or INCONCLUSIVE item rejects the pull request only at or above prflow_review.verdict_severity_threshold, the same line reviewer findings use (default critical). A lower-graded item does not reject on its own and is listed in the report with its severity. The review-and-fix loop sends a checklist FAIL to the fixer as it sends a reviewer finding of the same severity, and never sends an INCONCLUSIVE item. Any item the checker did not grade, or whose grade cannot be trusted, counts as critical. To make more checklist items reject, set verdict_severity_threshold to important or suggestion. This also makes reviewer findings at that level reject. (#1220)
A cloud PR review that skips its specialist reviewers now recovers before posting. Before posting a verdict, the review checks that the code, silent-failure and comment reviewers were each dispatched and recorded. If one was not, it dispatches that reviewer again; if its result still cannot be recorded, the run stops without a verdict. Before, it could post an approval that the workflow later dismissed and marked stuck. (#1156)
Reviews no longer ask the checker to confirm platform behavior it cannot observe. When changed code depends on how the operating system, shell or language runtime behaves, the review’s checklist now asks what the code does with each outcome that behavior can produce, rather than which outcome a given platform produces. A correct platform-specific pull request collects fewer INCONCLUSIVE checklist items. A comment or doc line in the diff that states platform behavior is still checked as written. (#1203)

September 23, 2026

Every acceptance criterion now gets exactly one review checklist item. The review builds one checklist item per decided acceptance criterion itself, outside the 100-item checklist cap, so an issue with many criteria no longer loses some of them to a 25-item limit and no longer receives a “Coverage shortfall” REJECT for that reason. The report now shows an Acceptance coverage: <itemized> of <resolved> decided criteria itemized line, and a review that builds a checklist still REJECTs when any criterion could not be itemized. (#973)
Review-and-fix reviewers now see findings the loop declined in any earlier iteration. From iteration 3 on, the prior-findings context handed to each primary-pass reviewer carries the previous iteration’s findings plus the pushed-back and deferred findings recorded by earlier iterations, each tagged with its iteration, so a finding declined two or more iterations back reaches reviewers as already considered rather than new. Findings fixed before the previous iteration are not carried. (#1021)
Review-and-fix declines findings that would weaken an acceptance criterion. The review engine’s return file now carries the run’s resolved acceptance criteria (the return helper rejects a return that omits them), and the fix step declines any finding whose fix would weaken or contradict one, at every severity, recording a claim-quality pushback that quotes the criterion. Inside /prflow:implement, a finding that persists after pushback ends the loop with its current verdict instead of waiting for input, and a criterion-conflict residual soft-proceeds rather than blocking the run. Runs with no resolved criteria decline nothing new. (#996)
Review verification: a checklist item re-asked only for its two auxiliary fields now keeps its first answer’s evidence, file_checked and view_revision (the engine names that answer’s nonce under a new pinned_from inputs key). A re-ask that proves the property can now keep its normalized PASS through the view-provenance gate instead of being demoted to INCONCLUSIVE, and a FAIL that survives the re-ask shows the first answer’s evidence (#1027).
/prflow:review-and-fix --push-each-iteration, which /prflow:implement runs, now merges the base branch and pushes after each fix iteration’s fix-delta gate settles instead of after each fix commit. Inner re-fix commits ride that one push, so a fix iteration starts CI once rather than once per commit, and the fix-delta gate no longer reviews a base-branch merge as part of the iteration’s fixes. (#1019)
/prflow:spec issue template: an acceptance criterion that states a policy an agent applies at run time now names the value the agent reads, the step that produces it, and the agent’s route when that value is absent, its producing step fails, or the value is unresolvable; a quality-checklist row checks it (#1022).
Review-and-fix iterations now try to read the sweep definitions before reporting the fix-delta sweeps as unrunnable. A fix-applying iteration records the sweeps as unrunnable only after its own Read of a source file fails or leaves the set incomplete — one of the three Phase 2 phase files, or a warranted sweep’s gated reference — and its sweeps: unrunnable record names that file’s path and the failure the Read returned or the missing marker. A later fix-applying iteration re-attempts every read an earlier one recorded as incomplete, so one failed read no longer disables the sweeps for the rest of the run. The breadcrumb no longer offers not-read as an outcome. No-fix iterations record the same not-run evidence as before. (#1018)
Review-and-fix reviewers now see every earlier finding the loop did not fix, not only pushed-back and deferred ones. From iteration 3 on, findings from iterations before the previous one are carried into reviewers’ prior-findings context unless they were fixed, so advisory, parked and severity-re-graded findings reach reviewers as already considered rather than new. An earlier iteration record that holds no findings list is now skipped with the same log line as a missing or unreadable one. (#1041)
Review-and-fix: a finding the fixer declines because its fix would weaken an acceptance criterion no longer clears a Critical. Inside /prflow:implement, a Critical or ungradeable residual takes the Blocked path even when declined, and only a decline that quotes one whole criterion lets a lower-graded residual soft-proceed. The decline also no longer counts toward downgrading a REJECT to APPROVE WITH CAVEAT (#1042).
Fix loops stop re-verifying unchanged multi-file evidence. From the second review-and-fix iteration on, a carried checklist PASS whose evidence cites several files keeps its verdict when every cited file is tracked at HEAD and unchanged since the prior iteration’s review, instead of costing a fresh verifier dispatch. A citation naming any changed, untracked or missing file, a symlink, or a ./-style alias of a file still verifies fresh. (#1028)
Each checklist verifier reads only its own item. A review pass now writes every item it sends to a verifier into its own file, in a directory beside the checklist, and the verifier reads that file instead of the whole checklist, so a large checklist costs less to verify and a verifier no longer pages through it to find its entry. When those files cannot be written, verifiers read the checklist as before. Claim details the checklist generator supplies when asked for missing fields before verification are now saved into the checklist, so the item files and verdict normalization use them. The verdict format, nonce binding and evidence gate are unchanged. (#1025)
A resumed implement run no longer logs its own edits as issue-accuracy defects. When the issue-claim audit finds a Verified: premise refuted in a file the branch already changed, it records a branch-changed note instead of an issue-accuracy reflection, and still discards the premise. When the branch diff cannot be computed, the refutation keeps the issue-accuracy reflection and records why. (#979)
Checklist verifiers stop wasting turns on the source-view inventory. A verifier now reads its cited file at the path it derives from the repository path, and checks the view’s inventory.json only when that file is missing, with a search for the one path rather than a read of the whole file. The inventory now holds one entry per line with non-ASCII paths written literally, so that search returns one short line. The review’s dispatch lines name each view as <view-dir> (revision <sha>), so a verifier no longer reads the directory and revision as one path. (#1059)
A true “file X unchanged” acceptance criterion no longer grades INCONCLUSIVE and forces a review REJECT. The checklist verifier now cites the untouched path itself from the head source view (the base view when the path is gone at head), or, for a directory or file class, one tracked file the diffed pathspec matches, instead of the run’s diff, which the source-view check cannot accept. (#1092)
An implement run’s acceptance-criterion rewrite can no longer disagree with its recorded scope decision. A rewrite that carries its scope-decision record, as the rewrite procedure requires, now lands only when the new criterion matches that record, so a partial criterion is refused instead of silently replacing the full one. The implement instructions now record a rewrite or deferral made after the draft PR opens against that PR, so the review accounts for those criteria instead of reporting them as dropped. (#1067, #1077)
/prflow:implement no longer hits a refused Complete write on the review.md extension row, and posts 🎉 only after Complete lands. The review-fix worker now ticks that row from its own load of the review extension, not from the review engine subagent’s load, which reports nothing back. Any row it cannot tick gets a note in the form the Complete gate accepts, which names the row and says state not established. The 🎉 reaction on the triggering comment now waits for the Complete write to land, so a refused or unverified write no longer shows success early. (#1071)
A local /prflow:implement run no longer fails two calls in its issue-claim audit. The auditor now runs its record validator and projection gate through the helper directory its dispatch passes, instead of trying the vendored .prflow/vendor/prflow/… path first, which does not exist in a repo that does not vendor PRFlow. Cloud runs are unchanged: there the helper directory is still the vendored path. (#1055)
A standalone /prflow:review-and-fix <PR> shows every reviewer’s findings in the live progress comment again. Claude Code refused the review engine’s per-reviewer findings-<agent>.md write when the engine ran as a subagent, which dropped that reviewer’s block from ## Findings (live). The block file is now p3-<agent>.md and is written only when the run holds a live progress comment, so implement runs no longer spend a refused write per reviewer. If a block write still fails, the review warns and skips that live append. At the verdict it rebuilds the block from the findings it holds, or names the reviewer whose findings it could not recover. (#1057)
The implement review-fix and finalization workers now check their handoffs with the validator’s real command. Both worker bodies give the full flag form of validate-review-fix-handoff.py (vendored path first, skill-anchored fallback), so a run no longer spends a refused positional call or a --help probe before the worker’s self-check. When the check names a fault, the worker fixes it and checks once more, so a malformed handoff is corrected inside the worker instead of blocking the run at the parent. No config change; the validator and the parent’s checks are unchanged. (#1096)
One malformed deferral no longer drops every deferral in a review. The review’s deferral matcher now shape-checks each entry before any guard runs. It rejects an entry that is not a mapping, or whose reason, reason.category, finding, finding.file, finding.line_range or follow_up holds a present value of the wrong type, as malformed-entry; the matcher’s JSON record for that rejection carries a detail naming the field, while the review report shows the reason only. The other entries are still matched. A null reason or follow_up is not malformed, and a matching entry carrying one no longer crashes the matcher. Every such entry now reports malformed-entry. Here is what each did before:
- Honored: an entry with a non-string reason.category (including 0, false, [] and {}), or a line_range holding a float or a boolean.
- Rejected for another reason: the other wrong-typed entries that did not crash were unmatched, widens-surface or missing-follow-up-issue. A malformed entry on a changed line is now malformed-entry, not widens-surface.
- Crashed the matcher: every remaining shape, including a foreclosure entry whose follow_up is not a mapping. The crash dropped every deferral.
- Also fixed: a deferrals value that is not a list is ignored with a warning. A foreclosure whose disclosure.path cannot be resolved fails with disclosure-unverified. An id that YAML loads as a date no longer crashes the output. (#974)
A cloud review verdict now requires the specialist reviewers to have run. A cloud /prflow:review that posts a verdict without dispatching all three always-on specialist reviewers (code reviewer, silent-failure hunter, comment analyzer) now fails the review evidence gate: the PR gets a comment naming the missing reviewers and the PRFlow:ReviewStuck label, and a merge-gating verdict is dismissed. The blocker-recheck fast path stays exempt, and a workflow that supplies no execution transcript keeps its current behavior. When a run’s checklist evidence is also missing, its evidence-missing recovery now dispatches any reviewers it skipped. (#1051) The review’s criteria resolver (workpad.py acs-resolve) now follows chained scope-decision rewrite records. A criterion an implement run rewrote twice (A→B, then B→C) resolves to its current workpad text and reports CHANGED: A -> C, instead of routing to pr-identity-mismatch and reviewing the PR against the stale issue text.

A criterion that is both deferred and rewritten to a text the workpad does not carry now reports DEFERRED: A (previously CHANGED: A -> B); the source token is unchanged.

/prflow:spec no longer drafts a size or limit acceptance criterion that is already false before the change. When a file the change does not touch already breaks a tree-wide limit such as “every shipped file stays under N bytes”, the criterion covers only the files the change adds or edits, and a file or summed budget already over the limit must not grow. A limit every file already meets, or one the change introduces, can still cover every file. (#1066)
Review verification: a verifier PASS whose file_checked separates two cited files with a space (a.py:12 b.py:40) now keeps its PASS when both files are in the reviewed commit’s inventory, instead of being demoted to INCONCLUSIVE and forcing a REJECT. A citation naming any file outside the inventory still demotes (#1102).
Run diagnostics now render under jq 1.8. On a runner with jq 1.8 (the Windows runner image, Homebrew), the execution-diagnostics block came out empty and the permission-denial count and Claude Code version were reported as unavailable. They now report the same values on jq 1.6, 1.7 and 1.8. (#999)
A quantified acceptance criterion whose recorded value does not match goes back to the evidence verifier. When the verifiers call a criterion satisfied but the evidence verifier’s recorded stated and observed values differ, are blank, or are missing, /prflow:implement now asks that verifier to restate its record instead of escalating the criterion to an orchestrator judgment, which could rewrite it. The values must still match exactly. The evidence verifier now writes the observed value in the same form as the stated one (the bound itself when a measurement meets an “at most” bound), with the measurement and commentary kept in its evidence, and a criterion about a file’s presence or content is checked by the evidence verifier alone, even when a lint covers that file. (#1068)
Shorter final-pass reviewer prompt. The review engine no longer writes the findings contract and the prompt-extension status rules into the final-pass reviewer’s prompt on every pass. The reviewer now reads them from a shared contract file, so each review pass spends less time and fewer output tokens composing that prompt. Review output is unchanged, and a direct /prflow:requesting-code-review run is unaffected. (#1016)
Telemetry persistence no longer waits on a credential prompt. The end-of-loop telemetry save now closes standard input, turns off git’s terminal and Git Credential Manager prompts, and unsets SSH_ASKPASS (Git for Windows points it at a GUI prompt); a GIT_ASKPASS or core.askPass you set still runs. Over HTTPS it abandons a transfer that sends nothing for 30 seconds; SSH and connection setup are not time-bounded. A save that cannot authenticate fails with a warning instead of holding the run. (#997) /prflow:init and install.sh --apply now advance the prflow_version pin they wrote. Previously the pin stayed on the first release tag it wrote. /prflow:init installs from the plugin cache, which is not a git checkout, so it pins a release tag rather than a commit SHA. The installer then treated its own tag as a hand-set pin and never moved it. It now records the pin it owns in .prflow/install-manifest.json (prflow_version_stamp, so commit that file) and updates a pin that still matches that record. Any other value is kept: the installer re-stamps only a value that is empty, looks like a commit SHA, matches that record, or falls under the upgrade case below.

The installer also no longer moves its own vX.Y.Z pin to an older vX.Y.Z release. That usually means a Claude Code session is still running the previous plugin after an update. The installer keeps the pin and asks you to restart and run /prflow:init again, which also refreshes the workflow files that run wrote from the older release. To downgrade on purpose, set prflow_version by hand. A repository whose manifest predates prflow_version_stamp is unstuck on the first run that records one: a release tag older than the one that manifest last recorded is treated as the installer’s own and updated. If you pinned an older tag by hand, set it again after upgrading. A tag pin in a repository with no .prflow/install-manifest.json at all is kept as hand-set; set prflow_version to "" once and the next run pins it and keeps it current from then on.

Local review passes no longer poll for verifier results. The review engine now waits for its checklist generator, deduper and checklist verifier dispatches to finish before moving on, and /prflow:implement does the same for its code explorer and architect. Local runs stop spending turns and tokens checking whether results have arrived; cloud runs are unchanged. (#1112)
PRFlow’s shell steps now read native Windows jq and Python output correctly. A native Windows jq.exe ends each output line with a carriage return, which broke several steps on Windows runs: almost every run with permission denials persisted no denial record; execution diagnostics misreported the denial count and CLI version; review verdicts and green CI could be misread; only the last superseded run was cancelled; the weekly retrospective’s selection, reconcile and filing could fail; and settings files, config.json and the retrospectives corpus were written with CRLF lines. PRFlow now strips that carriage return and writes LF-only output, and the native-session transcript fallback finds this run’s session files on Windows. The denial record’s failure message now names the failed step and no longer echoes any fragment of a denied command. (#1050)
Review no longer rejects a verified “directory unchanged” criterion over its citation. When a review checklist verifier proved a claim about a whole directory (for example, “nothing under .github/workflows changed”) and cited that directory, the review graded the item inconclusive and could post a REJECT that cost an extra fix round. A citation of a tracked directory that still holds files at the reviewed commit is now accepted; a root, trailing-slash, absolute, partial-name or missing directory is still refused. (#1123)
Implement runs no longer stop at the issue-claim audit over a misnamed handoff field. The issue-claim auditor now copies its workpad result under the exact field names the run expects and checks its own handoff with the same reader the run uses, correcting a named problem once before returning. (#1131)
The review’s final-pass reviewer loads your requesting-code-review prompt extension again. Its dispatch now tells it to run the extension command before any other tool call, exactly as written. Without that instruction the reviewer read its reference files first, then ran the helper by an absolute path the cloud allowlist does not grant, so the load was refused and your extension never reached the review.
Documentation files an issue names under **Documentation Needed:** are now required. When an issue wrote the label with the colon inside the bold, /prflow:implement found no required documentation files and finished without checking that they were updated. It now reads that form like the other accepted forms, and a none. written after it declares that no files are required. (#1125)
Deferred review findings are sorted correctly on Windows. Before filing follow-up issues, /prflow:implement checks whether a deferred finding’s file is already a required documentation file. On Windows this check always failed, so the result was reported as unavailable. It now runs. (#1124)
An implement run whose final Complete write is refused now repairs it or ends Blocked within a bounded number of calls. The prompt-extension row refusal now prints, for each offending row, the exact note it accepts: Extension resolved: <name>.md — state not established (<cause>). Phase 4.3 now routes each refusal cause: an over-budget note is shortened, an over-size workpad is compacted, missing completion evidence or a missing required artifact ends Blocked, and an unrecognised refusal (usually a failed gh call) is re-sent once. Each remedy or cause gets at most one follow-up before the run records the failure and ends Blocked with a 👎 reaction. (#1103)
An implement run re-sends a refused final Complete write only when a GitHub call failed. A refusal with no recognised cause now ends Blocked, naming the refusal, instead of being re-sent once first. (#1103)
A checklist verifier that replies without writing its verdict file is now re-dispatched inside the review. Before, the reply’s verdict was tallied but the missing file failed the review’s evidence check, spending the fix loop’s one recovery or dismissing a cloud review’s approval. The review now re-dispatches that verifier once under a fresh nonce and keeps the reply’s verdict meanwhile, and the fix loop’s recovery writes to the verdict directory the evidence check reads. (#1144)
Implement runs flag acceptance criteria the review disputed. When the review loop declines a finding because fixing it would contradict an acceptance criterion, the implement workpad now records an Action-required reflection quoting that criterion and the declined finding, even if a later review iteration approves. The maintainer can amend the issue or accept the criterion. If the check cannot read the review records, the workpad says so instead of reporting no disputes. The issue template also asks a criterion that recognizes a case by what a value lacks to name every other output of that value’s producer that lacks it, and its route. (#1136)

September 22, 2026

A {1} in the implement or review runner variable becomes the issue or pull-request number. The implement claude job and the command job now expand {1}, in bare labels and JSON arrays, to the target issue or pull-request number. This applies to DEVFLOW_IMPLEMENT_RUNNER, DEVFLOW_REVIEW_RUNNER, DEVFLOW_LIGHT_RUNNER and DEVFLOW_RUNNER as those jobs read them. A consumer that launches a runner per job can set a label such as ci-{0}-issue-{1} without editing the shipped workflows. When no number resolves, a variable containing {1} is skipped for the next one in the chain, so no job waits on a half-formed label. A value without {1} resolves exactly as before. Check existing values: a literal {1} now changes meaning. In a JSON-array value that contains {1}, {0} and {{ are now expanded as well. The light and retrospective jobs still expand only {0}, and a {1} in a variable they read fails their evaluation. (#830)
A review that recovers from missing verification evidence now updates its progress comment. When a review’s first verdict post was refused for missing evidence and the review re-ran verification, the progress comment kept the earlier report and completion status while the posted verdict reflected the recovered run. The review now rewrites the comment’s report and status from the recovered results before posting the verdict again, so the two agree. (#532)
A telemetry branch that kept the old name is accepted again. If your telemetry.branch names a branch that still stores records under .devflow/logs/ — the old devflow-telemetry name kept through config, or a branch you renamed by hand — /prflow:init or install.sh --apply now moves those records to .prflow/logs/ in one commit on the same branch, keeping every record’s contents and deleting no branch. Writable runs then persist records to it again. A branch holding any other files is left untouched, and ordinary runs never rewrite the branch themselves. (#337)
The scheduled retrospective keeps a copy of its learning records. Every devflow-retrospective.yml run now uploads .prflow/learnings/ as the artifact retrospective-learnings-<run id>-<attempt> (kept 7 days), even when the state push fails or the run is cancelled, so a lost push no longer discards the week’s analysis — download the artifact and commit its files instead of re-running. Re-run install.sh to pick up the updated workflow. (#396)
The weekly retrospective now links a pull request to its issue far more often. It reads GitHub’s own closing-issue link first, then a Closes/Fixes/Resolves keyword in the PR body, then the branch name — including a branch named for your configured implementation_branch_prefix (previously only claude/ was recognised, so any other configured prefix silently lost its linkage) and, as a last resort, a bare issue-<number>-<slug> branch. Runs that used to be recorded as NoIssue — and audited as if they had left no trail — now resolve their issue and its workpad. (#945)
Fixed the credential-refresher cleanup misidentifying its own job on Windows runners. On a self-hosted Windows runner the stop step compared its own pidfile and the swept pidfiles in different path forms, so it reaped its own live refresher and then warned that the refresher had never started. It now compares both in the same normalized form, signals its own refresher, and reaps only other jobs’ pidfiles; reading a refresher’s process command line no longer logs a spurious “ignored null byte” warning. (#614)
/prflow:implement no longer stops at Phase 1 on Windows. The issue-body cache (preflight.py issue-body --out) and parse-acs.py --out refused every path inside .prflow/tmp, because git reports the repository root with forward slashes and the containment check compared it against a backslash-normalized path. Both now normalize the scratch root before comparing; paths outside .prflow/tmp are still refused.
An implement intake that stops early now reports its real cause. The intake handoff reader rejected a correct error/blocked handoff from a worker that stopped before classifying the issue or loading the workpad, so the run recorded schema errors instead of the worker’s reason. On a stop record, issue.classification, workpad.id and workpad.observed_status may now be null unless completed_steps marks their step complete, and a rejected stop record’s blocked_reason is echoed on stderr. A proceed handoff keeps every requirement. (#983)
The implement intake worker now checks its own handoff before returning. It copies the extension loader’s digest whole, including its bytes= part, and runs the same handoff reader the orchestrator uses, correcting any field the reader names, so a shortened digest is caught when the handoff is written rather than first at the orchestrator’s Phase 1 check. (#984)
Cloud subagents stop issuing Bash commands the permission matcher refuses. The cloud workflows now write the grounding block’s command-shapes table to .prflow/tmp/command-shapes.md, and every Bash-using PRFlow agent reads it before composing a command; the table adds rows for git -c <key>=<value> and for an expansion or absolute path as the command name. The base-branch update checkpoint fences now run the granted vendored helper path first, keeping the portable anchor as the fallback, and the implement tier grants gh pr checkout and the vendored pr-note-block.py. Re-run install.sh --apply to pick up the workflow change; with an older installed workflow the file is absent and agents behave as before. (#985)
Local implement runs waste fewer calls and read failed CI logs sooner. An implement run now checks once at start whether .prflow/vendor/prflow/scripts/ exists; without it, every helper call goes straight to the plugin’s own copy instead of failing on the vendored path first. The fresh-session check no longer counts local slash-command output, such as plugin management or reloads, as prior work. page-job-log.py, the failed-job recap in ci-verification-request.py, and the review’s direct log fetch now read a job’s log through the jobs-logs API, which serves a finished job’s log while the rest of the run is still going. (#989)
Cloud workflows can run Claude Opus 5.5. The shipped workflows pinned a Claude Code release (2.1.263) that the API refuses for claude-opus-5-5, so every run configured for that model failed on its first call. The workflows now run Claude Code 2.1.280. (#995)

September 21, 2026

The review-and-fix loop brackets each review-engine run with two helper calls, and the review-fix worker’s post-loop telemetry backstop runs one persist and one self-check. review-dirty-tree.sh entry-open clears the run’s diff cache, snapshots the working tree and records the snapshot’s object ID before an engine dispatch; entry-close runs the branch guard, the compare-and-restore and the entry’s evidence grade after it, each printing one JSON line the loop routes on. The same checks run as before with fewer turns; the loop’s fallback fences stay in the prose, so a consumer whose vendored helper predates this change keeps working unchanged. Inside /prflow:implement, the worker’s backstop after the loop no longer repeats the discovery persist the cloud workflow’s own backstop step runs, and it gates the dispatch-corroboration self-check on the persist call’s own outcome line instead of a separate config read. (#898, #899)
The review-and-fix loop’s second and later iterations reuse prior PASS verdicts instead of re-verifying every checklist item. checklist carry now reads the prior iteration’s metadata-intact Step 1.8 snapshot pair (checklist-step1-iter-<N-1>.json joined by id with verification-step1-iter-<N-1>.json) instead of the verdict-only checklist projection in iter-<N-1>.json, which lacked the source_file and category the carry rule needs and so carried nothing on every multi-iteration run. A carried item reuses its PASS only when its verification row’s file_checked, line anchors removed, is a single path tracked at HEAD and outside the changed-file set; every other carried item verifies fresh, and the collector’s commit-binding gate still demotes a reused PASS whose cited path is absent from the head-view inventory. An unusable snapshot carries nothing with a breadcrumb naming the file and the cause. About 1.2 minutes saved per second-iteration pass at measured checklist sizes. (#890)
Faster review-and-fix loop entry. The review-and-fix loop now resolves its run key, configuration values (iteration cap, fix-severity threshold, below-threshold window and telemetry flag) and run directory in one helper call, and proves the PR-head branch check in one more, instead of a run of separate shell steps. A /prflow:review-and-fix run — and the review-and-fix pass inside /prflow:implement — reaches its first review in fewer turns, with no change to what is reviewed: the same gates, the same iteration count, the same evidence. A consumer whose vendored helpers predate this change degrades transparently to the previous steps. (#894)
The review-and-fix parked-class sweep no longer starts a fix iteration for comment rewordings alone. A sibling the sweep discovers promotes only when the destination iteration’s own fix admission would route it — at or above fix_severity_threshold, inside the fix_below_threshold_iterations window or beside a Critical/Important sibling — and a sibling whose only impact is behavior-inert prose never drives a promotion by itself (it rides along when another sibling drives). Every sibling not promoted is parked with the existing parked-sibling: class-sweep marker and a parking_evidence.basis naming the reason. At the default important threshold nothing changes. (#857)
A clean PR is no longer rejected when a verifier cites two files with a comma or checks what the PR changed against a moved base branch. The review collector now resolves a file_checked value that joins two repository paths with a comma (each with its own line anchors) to both paths, so a proven PASS on a cross-file claim keeps its verdict instead of being demoted to INCONCLUSIVE; a path outside the reviewed commit, a blank citation, and the view directory alone are still demoted. The checklist verifier settles a claim about what the PR changes or leaves untouched against the merge-base (three-dot) diff between its base and head revisions, so commits the base branch gained after the fork point are no longer recorded as PR changes. (#932)
Refusal criteria need an observed refusal before /prflow:implement marks them satisfied. When an acceptance criterion says something is refused, rejected, or blocked, the evidence verifier now marks it satisfied only if a command it ran fed in the input that should be refused and saw the refusal or error message. Routing prose, a by-construction argument, a count of passing assertions, a digest match, or a report that only describes the failure is not enough, and the verifier names which of these was offered. Other criteria are verified as before. (#874)
Gate a CI verification request on your own fast checks. The new opt-in prflow_implement.ci_verification.pre_request_checks setting lists commands that must pass before an implementation run dispatches a CI verification run; a failing command refuses the request, so a defect your linters already catch never costs a CI round. A failure the base branch already has does not block the run. preflight.py lint-changed gains --fail-on-findings, so the changed-file lint can serve as one of those checks. Nothing changes until you list a command. (#870)

September 20, 2026

/prflow:spec now files issues with ## Technical Context and ## Implementation Notes collapsed by default, so the acceptance criteria are visible without scrolling past the implementer reference material. Every other section renders open, and agents read the body text unchanged.
A review no longer files a Critical falsehood against a doc line naming a value an agent wrote at runtime. A backticked token now counts as a symbol claim only where your tree defines it — a tool emits or parses it, or a shipped skill or agent body mandates it verbatim. A token nothing defines refutes nothing and is graded at most a clarity suggestion, while a misspelling of a token the tree does define is still a blocking falsehood. The rule is stated once, so every review agent reads it once. (#832) Refresh implementation policy before the documentation worker starts, reusing an unchanged policy only while its complete content remains resident. Changed policy is fully read and its pending obligations reconciled before dispatch. The worker still independently loads policy and refuses a later digest mismatch. Align review phase routing so checklist generation and independent reviewers are dispatched together, with results collected before the final verdict.
Auto-review no longer fires on a draft or conflicting pull request. When CI goes green, the automatic review request now re-checks the pull request’s live state and is withheld if the PR has been reverted to draft or carries merge conflicts — previously only a PR that was already a draft when CI started was skipped. Mark the PR ready for review, or resolve the conflicts and push a new green commit, to request the review again (commenting /prflow:review by hand always works). (#858)
Re-triggering an implement run that already finished a clean review can now reuse that review instead of running it again. The review-progress rows on the issue workpad are now recorded by the fix loop as each review phase’s evidence passes, so a resumed run that stopped right after a clean review finds those rows complete and skips the expensive review phases when its recorded review still matches. Previously the rows were left unticked, which made the resume re-run the whole review. (#856)
Review checklist evidence is now bound to the reviewed commit. The review engine materializes a commit-bound source view (a run-scoped file inventory plus blobs from the resolved head and base commits) at Phase 0.2 in every mode, including standalone PR mode, and checklist generation, verification and lite probes read repository evidence from that view instead of the checkout — so a base-checkout that differs from the reviewed head can no longer report a head-present file as absent or fabricate a tracked-worker requirement from a test fixture. Every verdict carries the view_revision it read, and the collector rejects a PASS whose provenance the bound inventory cannot confirm. Harness-instruction files (CLAUDE.md, AGENTS.md, .claude/**) are stored under a .src suffix so a PR-authored copy is never loaded as instructions, and the source view fails closed on an unavailable commit, failed read, partial materialization or unsafe path. A wording-only contradiction now reliably draws its one-shot auxiliary re-ask, and reports distinguish wrong-source evidence, unsupported generated requirements and confirmed source defects. (#851)
Reshaped the Phase 3.4 acceptance-criteria dispositions record into an exception-shaped, collapsed workpad bullet. ac-verifier-artifacts.py now writes ac-dispositions.md as a <details> block whose summary states the criterion and tick tallies; a criterion that ticked cleanly carries only four keys, and a criterion that blocked carries the fields that explain it (reason, sides, missing_sides, undischarged_slots, stated_terms, observed_value, and each expected side’s reported status and dispositions). The reflection parser in lib/fetch-pr-context.sh now recognises a bullet whose own text embeds an inline <details>…</details>, so a following friction bullet is no longer silently uncounted. The record shrinks the workpad and points a maintainer at why each criterion blocked. (#681)
Review Phase 2 launches every verifier in one wave instead of batches of 8. The review engine now dispatches the verifier of every fresh checklist item from a single message and waits only for its slowest verifier rather than for eight-at-a-time batches, so a review, a review-and-fix loop, or an implement run reaches its verdict sooner at the same token cost and with every launched item verified by its own agent. A launch the harness refuses (agent thread limit reached) is re-issued with the other refused items once the wave returns, so a harness that caps concurrency verifies the pass in ceiling-sized waves and drops no item; an item whose re-issue launches nothing ends INCONCLUSIVE. Peak concurrent verifier agents rise from 8 to the pass’s fresh-item count. (#885)
Phase 1 intake writes the issue-body cache and the acceptance-criteria file through the bundled helpers instead of retyping them. preflight.py gains an issue-body subcommand that fetches the body once and writes it byte-exact to --out, and parse-acs.py gains --out that writes the rendered criteria to a file; the intake reference now routes both through those helpers on both the IGNORED and NOT_IGNORED arms and reads the files back. A cloud implement run no longer spends output tokens re-emitting the body it already fetched, and the cached body is the exact bytes gh printed rather than a model-authored copy that could pick up the tool-result envelope’s trailing tags. (#891)
A resumed implement run continues its review-and-fix loop at the next iteration instead of restarting from iteration 1. When a cloud implement run is killed mid-loop (a rate cap, a runner reclaim, an expired credential) and the stall backstop re-triggers it, the loop now asks the new loop-verdict-marker.py continue-run subcommand whether a prior attempt of the same slug left iteration records bound to the current head — on-disk siblings first, the telemetry branch’s durable copy second — and, when one binds, restores iter-1.json through iter-<N>.json into its run root (each stamped restored_from) and starts at iteration N+1, carrying the prior head, checklist and findings forward and running the convergence-time shadow as on any later iteration. Every other outcome, including an older vendored helper that lacks the subcommand, starts fresh exactly as before; a standalone /prflow:review-and-fix run never asks. Restored records are excluded from the resumed run’s efficiency-record iteration count and cost sums so a killed attempt is never double-counted. (#893)
Review-engine passes take their batch slices and verifier dispatch plan from the helpers. In the local-diff modes review-dirty-tree.sh engine-setup now mints Phase 1’s work directory (phase1_work_dir) and, on a diff of more than 10 changed files, writes each batch’s slice of the cached diff and reports the batches in its record; a slice it cannot write is unavailable and that batch keeps the existing shell fence. normalize-verdicts.py prepare wipes the iteration’s verdicts directory, partitions the checklist exactly as the collector does and prints one nonce per agent item, so Phase 2 dispatches without reading the checklist artifact into the engine’s context. No tool grant, workflow, config key or artifact shape changes; an older vendored helper keeps coverage through the retained fence and the hand partition. (#887)
The review’s checklist generators now read the pull request’s commit. The checklist-generator dispatch names the run’s head source view, the same way the verifier and reviewer dispatches already do, so the checklist is enumerated from the reviewed commit rather than the branch the runner checked out — on the cloud tier, the default branch. (#896)
A proven PASS is no longer demoted when the verifier cites several line anchors, two files, or the view-directory path. The review collector’s view-provenance gate now resolves file_checked to the bare repository path(s) it cites before the inventory lookup: a comma-separated anchor list (path:18,158,318-321), two citations joined by ; or and, a path under the bound view’s own directory (relative, absolute or symlink-resolved), a \-separated path, and a harness-instruction file’s .src stored name all match. Every cited path must still be in that view’s inventory, so a path genuinely outside the reviewed commit is demoted exactly as before. The verifier contract states the canonical file_checked shape once. Since the gate landed, a clean review whose verifier cited two places was labeled REJECT. (#901)
loop-verdict-marker.py continue-run reports a resume’s prior-run state more precisely. A sibling run directory that holds no iteration record (only deferrals.json, say) no longer counts as a prior run, so the helper’s none line reads no-prior-run or no-telemetry-branch instead of no-well-formed-record; a restore whose lower records are absent or malformed adds one stderr summary naming the iterations it could not restore, while the stdout line keeps its closed shape; and the telemetry blob read shares the helper’s one git environment (GIT_TERMINAL_PROMPT=0) with its other git calls. The module docstring now states the two origin reaches (ls-remote, then fetch). (#919)
A resumed implement run can reuse a review it already completed at the same head. On an in-flight resume, the intake worker filed the run’s own unfinished work (an unchecked acceptance-criteria gate, an unrecorded final verification) as a review-related correction, and Phase 3 §3.1 read any such correction as a reason to skip its review-reuse check, so a review completed just before the run was killed was always re-run. Intake now files a correction only where there is a claim to correct — a completion claim the workpad makes that later evidence contradicts, or an obligation a comment raises — and leaves a head-bound clean review record to §3.1’s reuse-check, which verifies head, merge-base, issue digest and Review rows itself. A corrective comment asking for a fresh review still gets one; unreadable resume evidence still yields a sourced unestablished obligation. The handoff schema is unchanged. (#897)
Review Phase 2 dispatch plan and setup hardening. normalize-verdicts.py prepare no longer reports a lite checklist item in missing_fields, so the field-completion re-ask names agent items only; and engine-setup fails closed with a filesystem stop, removing its caches, when Phase 1’s work directory cannot be created, instead of exiting with a traceback. Follow-up to the #887 helpers. (#928)

September 19, 2026

/prflow:implement now reads the CI verdict your branch has already recorded, before it commits the acceptance-criteria gate and the whole documentation phase to that head. When the review-and-fix phase returns clean, the run lists the branch’s completed pull-request and push runs and settles each one from its jobs, not its run-level conclusion — so a run whose expensive jobs were skipped (what a repository’s own mid-run-push suppression produces, and what makes a check read green in seconds) counts as no verdict at all, and the run keeps walking back to the last result that actually reported. A stale, unfinished, or unrecognised job conclusion counts the same way, so an incomplete run is never read as a pass. Previously that failure was re-discovered only at the final verification step, after every review and documentation dispatch had already run against the rejected head. (#786)
A failing verdict never stops a healthy run. A verdict settled on the current head is treated as a present failure; one settled on an ancestor is decided by re-running only the focused check covering each failed job, never the suite; and anything the run cannot establish — no settling run, a rewritten head, a refused or unparseable read, a covering check this environment cannot run — is recorded as a note and the run continues exactly as before. Only an established, surviving failure is repaired, in one attempt, before the gate runs. (#786)
Give a standalone /prflow:review its own runner with the new optional DEVFLOW_REVIEW_RUNNER variable. The cloud review workflow’s command job already split its runner two ways — /prflow:review-and-fix and /prflow:pr-description take DEVFLOW_RUNNER’s capacity for the test suite, while a standalone /prflow:review takes DEVFLOW_LIGHT_RUNNER. But a standalone review is model-API-bound and runs for tens of minutes, and DEVFLOW_LIGHT_RUNNER also governs the one-core helper jobs that finish in about a minute — so sizing one tier always mis-sized the other. Set DEVFLOW_REVIEW_RUNNER (a bare label or a JSON label array, the same shapes as the other runner variables) and the standalone-review job alone moves to it. Leave it unset and the expression falls through to DEVFLOW_LIGHT_RUNNER, then DEVFLOW_RUNNER, then ubuntu-latest, so nothing moves.
Verifiers no longer pass a claim on a probe that could not support it. The acceptance-criteria evidence verifier and the checklist verifier now treat a refused or errored probe as establishing nothing (never a no-match or absence result), require a probe narrower than the claim’s scope to say why that scope covers the claim before it can back a pass, and require a claim about logic the diff changed to be measured against that artifact’s own bytes rather than a re-typed copy. The issue-claim auditor’s count pass now records the number of distinct items and names the enumeration command it counted. A checklist item categorised absolute_claim must also trace one named adversarial input through the code before it can report the property proven. (#620)
A review no longer measures your pull request against a base it never forked from. On a cloud review the job shallow-fetched the base branch, and every later git merge-base in that job then answered with a far older commit instead of failing — so a one-file change sitting behind a busy base was measured as dozens of files and thousands of lines, demanding checklist evidence it never owed and ending in a PRFlow:ReviewStuck verdict about files the pull request never touched. The review job now keeps the full history its checkout fetched, and the diff measurement refuses to report a size at all in a shallow clone — reported as an unestablished check rather than a failed review. (#802)
Warn when a nested repository ignores an ancestor .prflow/. PRFlow resolves its default configuration and prompt-extension paths from the nearest Git root. In a submodule, a vendored inner repository, or a monorepo whose .prflow/ does not sit at the Git root, that root carries no configuration and every read quietly fell back to a built-in default. Those reads now write one line to stderr naming the root they used, the ancestor .prflow/ they did not read, and the explicit option that points them at it. Path resolution is unchanged, so output and exit codes are exactly as before, and a repository with its own .prflow/ stays silent. (#12)
The weekly retrospective now fails visibly when its delivery fails. A scheduled retrospective run records each required delivery operation — state-PR push, issue filing, and report post — in one run-bound outcome record, and an unconditional workflow step classifies that record after the agent finishes: a positively-established delivery failure now fails the job instead of concluding success on the agent step alone, while missing or incomplete evidence is reported as a warning without failing the job. When the agent stopped before recording, a read-only GitHub check fails the job if the learnings branch or report comment is absent; a week with no new pull requests stays green. The workflow refuses an installed helper that lacks the outcome-record capability before launching, so the enforcement activates only when the matching workflow and plugin version are deployed together. (#395)
Implement’s resume no longer re-runs a clean issue-claim audit the workpad already records. The audit’s completing write records an audit-inputs row binding it to the live issue body, the resolved acceptance criteria, the run capability, the versioning policy and the merge-base with the base branch; workpad.py reuse-check <issue> audit checks all five. Phase 1.6 adopts the recorded audit only when every input matches and the base has moved at most three commits since; any mismatch, drift, or unresolved input re-runs the audit. (#689)
A cancelled cloud implement run that recovery cannot attribute now says so instead of reporting a clean recovery. When every evidence read succeeds but finds neither a reclaim marker nor a human-cancellation notice, the cause is unknown and may be deterministic, so recovery still declines to auto-resume — but the workflow now raises a warning and the workpad note names the declined recovery, points at the branch holding the committed work, and asks you to investigate the cause before re-running. A failed evidence read keeps the plain cancelled note. (#798)
PRFlow helpers now explain themselves and fail with a clear message. pr-note-block.py accepts an optional body-file argument (strip [<file>], add <note> [<file>]), reading stdin only when no file is given; --help prints usage, and a misuse (no subcommand, unknown subcommand, add with no note, an extra operand, an empty or non-UTF-8 body, or a missing/unreadable file) prints one usage line on stderr and exits 2 with empty stdout. discover-deferral-manifests.py, normalize-verdicts.py and prompt-surface-growth.py treat --help or -h anywhere on the command line as a help request, printing usage and doing nothing else; discover-deferral-manifests.py lists its three invocation forms. (#636)
Human-facing output from shipped scripts/ and lib/ helpers now uses the prflow: prefix instead of devflow: . The one exception is the devflow: posted comment on # breadcrumb, which several workflow and script consumers match exactly; it stays unchanged and is recorded in lib/rename-map.json’s frozen identifiers. Other devflow-family prefixes remain as they were, so logs still show both names in places this change did not touch. Nobody has to change a setting. (#636)
/prflow:implement runs its documentation pass before the acceptance-criteria gate, so an awaited completion verification overlaps the rest of the run. After the review-and-fix loop the orchestrator dispatches the finalization worker with STAGE: documentation: it runs the documentation pass, then — when the consumer’s implement extension defines a verification that is requested and awaited — requests it for the pushed head without waiting. The acceptance-criteria gate, follow-up filing and the PR description run while that verification does; final-tree evidence is still established for the HEAD finalization reads, so a head that moves afterwards needs its own request. A failed stage only loses the overlap: finalization runs the documentation pass itself when the workpad Documentation row is unticked.
A resumed run no longer re-waits a CI failure already on record. ci-verification-request.py request adopts a prior attempt’s completed same-head dispatch run that concluded failure when no green one exists, so wait reports that verdict at once; the fix-loop phase’s last-real-CI-verdict read now counts workflow_dispatch runs, and a resumed run takes that read before dispatching the loop.
An implement run whose first review iteration is clean no longer runs the fix loop’s confirmation passes. When the review-and-fix loop runs inside /prflow:implement and iteration 1 is clean — a non-rejecting engine verdict with no failed or inconclusive check, a complete reviewer roster, no finding that stands at Important or above, a verified fix-delta gate that raised no such finding, and a parked-class sweep that registered nothing to fix — the loop skips the iteration-2 re-review and the shadow pass and reports shadow skipped, iteration 1 clean; the pull-request review is the independent pass for that run. A first iteration that fixed, pushed back, deferred or parked an Important finding runs the loop as before, as do standalone /prflow:review-and-fix, the bounded re-review after unresolved shadow findings, and a run whose prompt extension declares a shadow trigger that holds. The loop-verdict marker gains a coverage=skipped token, read as CLEAN-SHADOW-SKIPPED. (#822)
Review passes spend less time on checklist verification. A verifier dispatch now names its checklist item and verdict file instead of re-stating the verification rules, a verifier that wrote its verdict file replies with one line instead of a full report, and the bundled helper assembles the verification results file that the review engine used to write by hand. Which items get their own verifier agent is unchanged, and an item whose verifier delivers nothing is still recorded as inconclusive. (#823)
A cloud run whose runner dies abruptly can now still yield its execution transcript. A host-level runner termination runs none of a job’s post-steps, so the transcript upload never fired and the run left no transcript. The new opt-in prflow.execution_transcript_job_log_enabled streams every agent message into the /prflow:implement job’s log as it happens and, when execution_transcript_artifact_enabled is also on, a downstream recovery job rebuilds the transcript from that log and uploads it under the usual artifact name. Default off: the job log is neither scrubbed nor masked, so it can carry credentials such as refreshed App tokens. The setting is applied only when GitHub reports the repository as private; in a public repository, or when the visibility is not reported, streaming stays off and the run logs a warning saying why. The log also grows to the transcript’s own size. (#799)
Review passes spend less time assembling the verification checklist. The review engine used to paste each checklist batch into the deduper’s prompt and then re-type the finished checklist into its artifact file. Now each checklist generator writes its own batch file, the deduper reads that file and returns only the groups of items it judges to be duplicates, and a bundled helper applies the merge, numbering, 100-item cap and carry-forward rules and writes the checklist. Before writing, the helper traces each generated item by id into the items it keeps, merges or caps, and refuses to write a checklist when an id is unaccounted for; the review then reports that the checklist was not generated instead of approving cleanly. The helper also leaves a duplicate group unmerged when its items share no claim signature, no nearby location in the same file and category, and no convention check; deciding whether two items that do share one are the same claim remains the deduper’s judgment. The checklist-generator agent gains the Write tool for that one scratch file under .prflow/tmp/; if its write is refused it returns the checklist inline as before.
/prflow:init can now be invoked by the model, not only explicitly by you. The disable-model-invocation guard has been removed so Claude can run the setup command when a repo needs its PRFlow config scaffolded or backfilled, instead of waiting for you to type the slash command.
The test-first gate now runs the changed file itself, never a re-typed copy of its logic. The RED/GREEN check that guards a fix (and Phase 2’s implementation) must invoke the changed artifact as it ships, not a transcribed copy of its rule pasted into a one-off command — a copy establishes nothing and is never recorded as a passing check. When no permitted way to run the file exists, the fix loop records an honest unrunnable result and Phase 2 treats the check as unestablished, whether or not a permission denial was seen first, so a RED-confirmed record now means the shipped code actually ran. (#682)
Added /prflow:challenge to stress-test ideas, issues, approaches, and approved PRs against evidence, risks, priority, and simpler alternatives.

September 18, 2026

The review’s coverage reviewer now flags a new gating branch nothing tests. When a diff adds a branch to a helper whose result decides a fail-open/fail-closed outcome, a verdict, or a gate, the reviewer checks that one assertion actually drives that branch instead of reading it as covered because its siblings are tested, and reports the gap by name. The check is scoped to those helpers, so an ordinary added conditional is unaffected. (#384)
PRFlow commands now run their bundled helpers in a worktree-isolated session. Such a session refuses any command whose program name is computed by a shell expansion, and every skill’s portable helper-anchor rule told the agent to invoke helpers with that expansion left in place — so workpad updates, label writes and the consumer prompt-extension load were all refused there. The rule now has the agent fill in the resolved directory before it runs the command. (#684)
A pull request opened by an automatically resumed implement run is now assigned to the person who started it. When a stalled or interrupted cloud run was resumed automatically, the resume comment’s author was the PRFlow bot, so the run tried to assign the new pull request to that bot — which GitHub refuses — and the pull request was left unassigned. Each automatic resume now carries the originating person forward, however many resumes intervene, and re-posting the trigger yourself makes you the new owner. If that identity ever cannot be read, the run records a named reason and leaves the pull request unassigned instead of failing the assignment. (#512)
A cloud review-and-fix run now clears its cached diff between engine passes instead of losing one call to a permission refusal. The re-entrant cache delete used a shell wildcard and a zsh guard, both of which the cloud permission layer refuses, so stale review slices from an earlier commit could survive into the next review pass. It now lists the files first and deletes them by name. (#564)
Neutral wording for non-blocking issue references in the issue template. The issue template now routes advisory or conditional cross-issue references to Technical Context with neutral Related work: #N wording. Because the preflight reads dependency phrasing (depends on, blocked by, a line-leading After #N) as a real prerequisite wherever it appears — not only inside ## Dependencies — an advisory reference must use the neutral wording so a related ticket mentioned for context no longer accidentally becomes an execution prerequisite. (#382)
The execution-transcript and denied-command scrubber now redacts more credential shapes. In addition to GitHub tokens, Anthropic keys and Authorization headers, it now removes AWS access key IDs, npm/Slack/GitLab tokens, connection-string passwords, Password=/Pwd= values, and PEM private keys before a transcript artifact or denied-command record is stored. The Observability and Privacy page now also states who can download a transcript artifact, the seven-day retention the workflows request, which credential shapes stay unrecognized, and that the scrub only ever replaces matched credential spans. (#638)
Review and finalize steps now state their progress-row labels inline instead of reading scripts/workpad.py source. skills/review/SKILL.md renders the review-boundary Blueprint rows and states their --tick-progress substrings, skills/review-and-fix/references/loop-exit.md names the final review row and its substring, and implement’s Phase 4.3 finalize states the terminal PR marked ready row instead of naming workpad.py as its owner. Implement’s root skill still points at the row constants for the whole ## Progress inventory, which this change leaves alone. Phase 4’s validation step also drops its pointer to the finalization validator’s module header, which the parent never needed. (#671)
A finished review is no longer thrown away when the last iteration was a shadow-promoted one. The fix loop’s terminal verdict stamp now selects which review to grade instead of always grading the primary entry: it grades the primary review at the final iteration when one exists, and otherwise — for an iteration the shadow review promoted, where the primary engine never ran — grades the shadow review that actually covered the final diff. A run that ends after such an iteration is now graded on that review’s own evidence and stamps its verdict marker when that evidence passes, instead of refusing with evidence-missing because the primary entry is absent. (#676)
The fix loop’s review engine now runs as a dedicated prflow:review-engine agent that reads one shared engine-entry procedure — the single home of the steps the primary and shadow entries both follow — and must write its checklist, verification, per-item verifier and return files before returning. The loop no longer hand-composes the engine’s instructions into each dispatch prompt. A review that skips those evidence files is still not silently accepted: the loop grades each entry’s own evidence before consuming its verdict, then recovers or blocks rather than losing a good, completed run. A runner that cannot dispatch agents still falls back to running the engine inline. (#676)
The prflow:review-engine agent no longer requests an edit-in-place tool. The engine authors its checklist, verification, verifier and return files outright and makes every other change through its helpers, so the grant was never exercised. Dropping it keeps the reviewing agent to the tools it actually uses. (#676)
An implement run no longer stops over an ordinary branch or working-tree problem. Setup used to end the run and wait for a human on about a dozen conditions that say nothing about the issue being implemented — history it could not vouch for, a dirty tree, a branch live in another worktree, a failed base merge, a rejected push. Each of those now takes a recovery action and continues, with what it did recorded on the workpad: setup either carries on with the branch it found or cuts a fresh one from the base, leaving the old branch’s commits untouched. Setup still stops for two reasons only — its worker failed, or no working branch could be established at all. In particular, a run interrupted after its work was committed but before its pull request opened now resumes on its own instead of stranding. (#687)
Installed cloud workflows no longer drift from your setup. The implement job now installs ruff only through the setup action’s manifest provisioning — the duplicate pip install step is gone — so linting uses the version your lint manifest pins. The three workflows that upload artifacts now use actions/upload-artifact@v7 (Node 24), which needs a self-hosted Actions Runner of 2.327.1 or later. When the implement tier ignores your setup.git_dir_pin, and when a committed vendored plugin copy is a different version than your configured prflow_version, the run summary now carries a visible warning or notice instead of a silent log line. (#624)
An implementation run now opens its workpad with one read instead of five. Phase 1 used to ask GitHub separately for the workpad’s comment id, its live Status, its body and its recorded prior status — then fetch the body a second time when resuming. A new workpad.py intake-triage subcommand returns all of it as one JSON object from a single comment scan, so a one-page workpad costs two GitHub requests where it used to cost ten, and the run spends less of its context on setup. The intake procedure now spells out that call and its result in full, so a normal run no longer loads the helper’s --help text at all. The new read never writes: status updates keep their own live re-fetch, precondition checks and verification, and a workpad that is present but unreadable — a duplicated workpad comment, an unrecognized Status, or conflicting prior-status markers — stops the run with a clear cause instead of guessing. (#436)
/prflow:implement no longer loads the combined documentation pass when your configuration has already disabled both of its synchronization steps. With docs.internal_enabled and docs.external_enabled both set to false, no documentation deliverable named in the issue, no deferred “relocate to docs” note, and no docs prompt extension of your own, Phase 4 now dispatches the release-notes step directly instead of the combined router. Release notes and changelog reconciliation still run every time, a documentation file the issue names still reaches its owning step even when that step’s toggle is false, and anything the run cannot establish — an unreadable toggle, an unplaced relocation, a docs extension it cannot read — keeps the full combined pass. (#440)
/prflow:docs-sync-internal no longer starts an internal documentation tree as a side effect. When the configured internal root holds no tracked Markdown page — it is missing, or contains only a .gitkeep placeholder — the step now changes nothing and reports that the repository needs /prflow:docs-bootstrap-internal first; an implement run stops as Blocked with that remedy and the root named. A root that already has a Markdown page but no index.md is still repaired in place. (#440)
A workpad that hits GitHub’s comment size limit can now be shrunk without losing anything. A run whose workpad reached the limit had no supported way to recover, so it improvised — and one run cut the tails off over-length progress bullets, destroying the record its own completion gate reads. workpad.py compact <issue> now moves the oldest ordinary progress and notes bullets, whole lines only and never one carrying a machine-read marker, byte-for-byte into a single overflow comment on the same issue, posting that comment before it rewrites the workpad so no failure can drop the text from both places. Every workpad write also reports its remaining headroom, warning and naming the new command once the body passes 57,344 bytes. (#755)
An implement run no longer files a follow-up issue for a review finding it is about to fix itself. Deferred-review filing runs before the documentation pass, so a parked finding against a file the issue’s own **Documentation Needed** block already names produced a permanent Deferred ticket minutes before the run edited that very file — leaving a human to read it, check it against the branch and close it by hand. scripts/file-deferrals.py now resolves the run’s deliverable path set once, through scripts/extract-doc-needed-paths.sh over the source issue’s body, and partitions out every manifest entry whose file matches one exactly: no issue is created, the entry stays in the rewritten aggregate under the new category scheduled-in-run with no follow_up, and one scheduled-in-run id=… file=… deliverable=… record per skip goes to the run’s workpad. (#758)
A scheduled-in-run finding renders nothing in the pull request description. /prflow:pr-description treats the category as deliberately non-renderable — no Scope-Acknowledged Findings row, no hidden machine-payload entry — and removes a row an earlier pass rendered for the same finding rather than carrying it forward, so the table never contradicts the branch it describes. A settled-by-disclosure foreclosure row is untouched by that arm and is still carried forward. (#758)
The new partition fails open. An unreadable issue body or a non-zero extractor leaves the deliverable set unknown rather than empty: every entry files exactly as it did before, after a single scheduled-in-run result=unavailable cause=… record naming the failed read. The value is written only on the aggregate the filer rewrites; the review-and-fix loop’s own deferrals.json and its skip_category set are unchanged. (#758)

September 17, 2026

/prflow:implement no longer runs your test suite twice while finalizing. The PR-description step now audits the PR body’s test claims by reading the tests in the diff instead of launching a run of its own, leaving the final-tree run that follows it as the run’s only whole-suite execution. Repositories with slow suites see the largest saving. (#618)
The independent shadow review can no longer be signed off with the fix loop’s own evidence. The shadow pass and the loop’s last iteration write to the same checklist, verification and verifier-file paths, so a shadow that did not finish its own verification could previously be graded against what the loop had already produced. The evidence check now refuses a shadow whose checklist or verification file is still the loop’s, ignores verifier files the loop wrote, and refuses leftover verifier files that belong to no checked claim — each of which sends the shadow into its existing one-attempt recovery instead of a clean merge verdict. Where the check cannot read what it needs to compare against, the shadow is likewise sent into recovery rather than passed. Re-running the shadow also replaces its recorded verifier files rather than adding to them. (#621)
A switched-off base-update checkpoint and a switched-off Spot watcher now read as disabled. With prflow_implement.update_branch_checkpoints set to false, the final implement workpad row called the skipped checkpoint “clean” even though the branch was never compared with its base; it now says base-update checkpoints are disabled by config, that the branch was not reconciled with its base, and how far behind branch setup measured it. With prflow_implement.spot_interruption_watcher.enabled set to false, the run log reported a wrong value type; it now reports the watcher as disabled by config. Every other unaccepted value keeps its existing wrong-type message. (#623)
/prflow:implement no longer forbids Phase 3 from writing a documentation page an acceptance criterion requires. The skill told Phase 2 and Phase 3 to leave a docs/… criterion for the Phase 4.1 documentation pass, while the shared review engine that Phase 3.3 runs REJECTs an unmet decided criterion — so the fix loop had to author the page the prose forbade it to touch. Phase 3.3 is now a permitted author, Phase 4.1 is the deadline and backstop that writes any page Phase 3.3 did not and then ticks the criterion, and Phase 2 still does not author it. The review engine is unchanged: a standalone /prflow:review still REJECTs an unmet documentation criterion. (#571)
/prflow:implement starts with about 21% less orchestrator prose in context. The root skill was trimmed to its operative rules — every helper fence, gate, and contract is unchanged — so each run begins with more context headroom before Phase 1. (#570)
Reviews no longer spend an extra round recovering verifier evidence they should have produced. A fanned-out review that checked claims by reading source in its own context left no per-item verifier file, so the loop’s evidence gate failed the first grade and burned its one recovery attempt re-running the checks. Phase 2 now confirms every fresh agent-mode checklist item has its verifier file before the results are written, and re-dispatches the real verifier for any that is missing; the recovery attempt stays available for a genuine miss. (#572)
An implement run’s status labels, resume run-link refresh, stopped-run notes and cost record now reach its PR even when GitHub creates no closing link. A PR targeting a non-default branch, or an adopted PR with no closing keyword, is found from the run’s own **PR:** binding on the workpad. On adoption, a failed closes-issue check now warns that merging will not close the issue and that a person must link or close it. (#626)
PRFlow’s helpers now read and write text the same way on Windows as on Linux. On a Windows runner with native Python, helpers decoded text with the locale code page and translated newlines, so labels lost their configured fallback, composed plugin and marketplace lists carried a stray carriage return, PR body notes came back with garbled punctuation, verifier paths mixed / and \, and the changed-file lint never ran. Every helper now states its own UTF-8 codec, writes LF-only machine output, emits forward-slash paths, and takes its receipt lock through the Windows locking primitive. (#631)
Review fix loops stop re-verifying claims nothing changed, and re-check acceptance criteria at every head. From the second iteration on, a review-and-fix run now carries forward the checklist claims whose files the previous fix left alone, keeping each claim’s identity so a prior PASS is reused instead of dispatching another verifier. Acceptance-criteria items are never carried: they are regenerated and re-checked at every iteration, so a criterion can no longer be approved on a verdict taken before a base merge. When the run cannot establish which files changed — a shallow checkout, for instance — it carries nothing and says so rather than reusing a stale verdict. (#644)
A review no longer stalls on review-artifact-malformed because the engine wrapped its checklist in an object. Phase 1.6 and Phase 2.2 now state that checklist-iter-<N>.json and verification-iter-<N>.json are JSON arrays at the file root, distinct from the object-rooted coverage-shortfall and engine-return artifacts; the evidence gate still rejects an object at those paths, and recovery re-runs the writers instead of reshaping the file. (#579)
A workpad checklist item that is already ticked no longer counts as a failure. Repeating a tick — on a resumed run, or twice in the same run — now succeeds quietly instead of reporting an error and re-printing the whole workpad comment, so runs spend fewer steps on bookkeeping. A tick that matches nothing, or that is ambiguous between several rows, is still reported, and the message now says which of the two it was. (#635)
Re-planning keeps the plan steps you already completed. When a run rewrites its ## Plan, every step whose wording is unchanged keeps its tick, so a resumed run sees accurate progress instead of an all-unchecked plan. A step whose wording was edited starts unchecked, as before. (#635)
PR marked ready is ticked only when the pull request is actually published. A run configured to leave its PR as a draft — or whose publish step fails — now finishes with that row unticked beside the note explaining why, so a draft delivery is distinguishable from a published one at a glance. (#635)
Cloud implementation runs no longer stop for a dirty tree before intake. The run inspects the tracked changes, restores those setup produced, keeps its own uncommitted work, notes the decision and continues; a local run still never touches your tree. A stop before intake is now recorded as 👎 Blocked on an existing workpad, so the stall backstop no longer spends a resume on a stop that would repeat. A step your implement extension requires but the run cannot perform — its tool, MCP server or skill is not loaded, not permitted or not authenticated — is recorded once as a reflection and skipped instead of being retried. The cloud setup page now lists which project plugins cloud runs load. (#646)
The implement workpad reads more cleanly. Its title is now just # PRFlow Workpad — it is a comment on the issue, so it no longer repeats the issue number — and the Setup row drops its — branch & workpad tail. Each extension row now names the file it loaded (Skill extension resolved: implement.md in place of prompt extension resolved: implement), so a glance at the row tells you which .prflow/skill-extensions/ file the run resolved, and the fix-loop gate row reads Review-and-fix loop. Every row, note and reflection starts with a capital letter unless it opens with a literal a reader matches, such as /prflow:implement run started. Two Phase 1 startup rows became one: agent entered Phase 1 setup; workpad triage passed is gone — the hydration row that follows it already records that triage passed — which also saves a write against the GitHub API on every cloud run. The branch-setup agent’s fresh-create arm writes the branch-qualified resume verdict alone instead of that plus a record line whose fields all read n/a, and the issue-claim auditor folds every pass that found nothing into one line rather than one line per silent pass. A workpad mid-run when you update keeps its existing rows and resumes normally; both spellings of the resume verdict are read.
/prflow:implement records its Phase 2 sweep results in one workpad update instead of one per sweep. The sweep receipts and the operand-ledger entry they accompany now share a single call, so a run spends fewer turns and the workpad comment is rewritten once per boundary rather than once per sweep. (#692)
Implement no longer stalls at branch setup over the handoff operand. Phase 1.4 listed HANDOFF among path operands, so a run could pass the intake handoff file and be blocked with invalid-handoff-operand. The operand list now names the accepted provenance words. (#683)

September 16, 2026

Cloud implement recovery now reports the real cause of a lost runner instead of calling every loss a Spot reclaim. When the claude job of a cloud implement run dies, the spot_recovery job’s resume comments, terminalize comments, and Cancelled workpad notes now carry a cause line naming the job’s conclusion, its capacity token (the runner label’s spot=<value> segment, verbatim), its runner name, and GitHub’s failure annotation — and only claim a Spot reclaim on the path that holds a valid reclaim marker. A proven reclaim whose resume is refused at the cap or for a missing App token now ends the workpad in a terminal 💥 Failed state instead of leaving it indefinitely in progress, and every terminal flip the recovery job makes records whether the run’s branch is empty.

Deferred review findings are now grouped into follow-up issues by their shared deferral reason, not by source file. When an /implement run files follow-up issues for deferred review findings, scripts/file-deferrals.py in manifest mode now groups findings that agree on category, explanation (compared after trimming) and kind into one follow-up issue — however many files they span — and titles it from that shared reason (<area>: deferred review findings — <kind> (<category>) (carried from #<n>), with <area> derived from the group’s longest shared path prefix). A finding that cannot supply all three reason fields falls back to per-file grouping exactly as before. Fewer near-duplicate tickets for one piece of deferred work. (#602)
A re-triggered issue resumes on its own — Re-running /prflow:implement on an issue an earlier run left blocked picks the work back up and re-runs the step that stopped, so a fixed blocker clears without any extra prompt. Implement runs stay hands-off from start to finish on both the local and cloud tiers; when a decision the issue does not settle comes up, the run records it as a block to settle by editing the issue and re-triggering. You get this through the normal plugin update. (#596)
A failed CI verification round now reports which jobs failed and why. When ci-verification-request.py wait sees a failed run, it now prints the name of each failed job and every identifier from the Failure recap in those jobs’ logs, after its existing FAILED line, so the failure list is in the command’s own output without opening the logs by hand; the exit status is unchanged. (#603)
preflight.py lint-changed now flags a ruff version skew. Each ruff invocation receipt, and the command’s summary line, now records whether the ruff that ran matches the version the lint manifest pins (match, skew, or unestablished). The comparison is advisory and changes no exit status. (#603)
Cloud /prflow:implement runs one agent per issue at a time. The claude job in devflow-implement.yml now has a per-issue concurrency group that queues and never cancels. A stall-backstop auto-resume, or a re-trigger that gets past dedupe, waits for the in-progress run for that issue to finish, so two agents can no longer write the same workpad and branch at once. If GitHub cancels a queued job before it starts because a newer one replaced it, the recovery job does nothing, so it cannot flip the live run’s workpad to Cancelled. (#471)
Branch setup now rejects an invalid provenance value instead of blocking on provenance. If /prflow:implement passed anything other than created-current-run, adopted-existing or unknown to branch setup, the run used to stop with a misleading “provenance not established” decision, and the stop message sent people to the wrong fix. Branch setup now refuses the value before doing any work, and the stop reason names the value it got and the values it accepts. (#595)
An implement run fixing a failed final CI check no longer shows as Stuck. When the final verification fails and your repository’s implement prompt extension sends that failure back to be fixed, the issue keeps its in-progress status (no PRFlow:Stuck label, no 👎) while the run makes the fix. It shows Blocked only if the failure can’t be fixed. (#562)
A resumed cloud implement run now reuses a CI run a prior attempt already passed for the same head, instead of re-dispatching. ci-verification-request.py request records live on the runner’s local disk, so a resume on a fresh runner held no record for an earlier attempt’s green workflow_dispatch CI run and had to re-dispatch and wait a full CI cycle. request now adopts a completed-successful same-head dispatch run whose run title carries a request-id token, reconstructing the request record under that identity; collect-evidence still re-binds the downloaded shard provenance to the adopted run before building any evidence, so adoption grants no new trust. Adoption is best-effort — an ambiguous match, a tokenless run, a non-green run, or a run-list transport failure falls through to a normal dispatch. (#545)
Cloud runs no longer preinstall the code-review and claude-md-management plugins. The PRFlow cloud workflows now install only PRFlow itself, plus any plugins your repository enables in .claude/settings.json. PRFlow never depended on either plugin. If you use their /code-review or /revise-claude-md commands in cloud runs, enable code-review@claude-plugins-official or claude-md-management@claude-plugins-official in your committed .claude/settings.json, and the cloud runs will install them again.
Long cloud runs on self-hosted Windows runners no longer fail with GitHub 401 Bad credentials after about an hour. With a GitHub App configured, PRFlow’s Python helpers on a native-Windows Python kept using the token minted when the job started, even though the credential refresher was renewing it. Once that token expired, the helpers could no longer write the workpad, and the run looked like a stall until the stall backstop gave up. These helpers now use the refreshed token, as the shell helpers already did.
Re-running /prflow:implement no longer repeats planning and review that are still valid. When a run is started again after an earlier attempt failed or finished, it now reuses the earlier plan if the issue text has not changed. It also reuses the earlier review when that review passed with full coverage and the branch, its base and the issue text are all unchanged. Otherwise the run plans and reviews as before. A new commit, a change to the base branch, an edited issue, or a correction asking for a fresh review still triggers a full review. (#616)
The implement cleanup review now sees the issue’s acceptance criteria. The /prflow:implement cleanup reviewer received only the diff, so it could recommend deleting tests an acceptance criterion required and call them scope creep. It now receives the current criteria and treats the behavior and tests they require as fixed scope, while still flagging genuinely redundant tests and stale references. Its report format now lives in the reviewer’s own definition instead of a tool-denial note in the dispatch. The finalization handoff check also rejects an extension-load record with unknown fields, or one that claims the whole extension was read without the digest the full load ends with. (#622)
Cloud implementation and command runs can run git grep, and agents stop retrying refused commands. Re-run the PRFlow installer to receive the new grant. (#629)
The self-hosted runner docs now state PRFlow’s Windows trust boundary. PRFlow cannot make its job credential files owner-only on Windows. The Windows Runners section now says to run each runner service under its own account and restrict its work directory to that account and administrators, with the icacls commands that set and show that access. It also notes that runner services sharing one account share its Claude settings and can read each other’s credentials. The documentation page for /prflow:docs-verify --report-only now names the report’s Doc verdict and location field correctly. (#633, #594)

September 15, 2026

Reconcile fulfilled documentation obligations in the final workpad. A documentation obligation a run first recorded as friction under Action required can now be moved to the Notes section with its checked completion evidence — scripts/workpad.py update --resolve-doc-reflection TARGET EVIDENCE — so the final workpad no longer shows the same deliverable as both done and unresolved. The moved bullet keeps its original failure glyph and kind, so it still contributes to retrospective friction; an absent or ambiguous target refuses the resolution without changing another reflection, and replaying the same resolution is idempotent. (#508)

Lint-tool provisioning now retries transient download failures. provision-lint-tools.sh downloaded each pinned tool with a single-shot curl, so an intermittent HTTP 500 or blip from the release CDN failed the whole provisioning run on the first error. The download now uses curl’s bounded retry, riding out the transient before failing closed; the pinned-digest check still refuses any bytes a retry brings back. (#550)
Issue premise checks no longer reject a quoted sentence over its final punctuation. When an issue’s Verified: bullet quotes a sentence that still exists in the cited file but now ends with different punctuation (for example a colon instead of a period), implement treats the premise as still holding instead of discarding it and recording a false issue-accuracy note. A changed word or a removed sentence is still reported as no longer present. (#523)
/prflow:spec no longer re-audits an unrevised draft after a REVISE round. When an audit returns must-revise findings, the drafting command now applies the confirmed findings and re-shows the revised draft before offering another audit round: record-offer --accepted refuses (leaving the user-round counter untouched) while the last completed REVISE round’s findings are unrevised or their count is unestablished, a new query-offer surfaces that withhold so the Step 4 approval question omits the audit-round option, and the withhold releases once a revision postdates the round that raised the findings. Operators stop spending audit rounds and tokens on unchanged bytes. (#548) Restore same-branch tracked checkout changes left by a review-engine return. The review-and-fix loop now snapshots the working tree before every engine Step 1 dispatch and every shadow Step 2.6 dispatch and, when the branch name still matches on return, restores previously-clean tracked paths the return dirtied — so engine and shadow leftovers no longer ship silently into a later fix commit. Preexisting dirty work, .prflow/tmp scratch, and rename/copy records are left untouched; the helper restores only previously-clean tracked paths to HEAD, so residuals it cannot restore — untracked files and staged additions not in HEAD — are left in place rather than restored (a path that becomes a staged addition during the window is flagged), and the implement Phase 3.3 residual-porcelain flush no longer names those helper-unrestorable residuals as review-feedback fixes.
The review-and-fix shadow pass now derives its “no prompt additions” attestation from the prompts it actually sent. Before each dispatch a shadow pass issues, it now persists the exact prompt to the run root and reads those files back to compute the attestation, so a shadow whose launch prompt was steered is reported as not independently verified instead of clean. Previously the attestation was written from memory and the launched prompt was recorded nowhere, so a steering clause could sit beside a clean attestation with nothing able to show the contradiction. (#534) Stop the install.sh dry-run preview from crashing on a file it cannot open. The preview no longer copies or diffs the tmp/ scratch directory of either state directory (.prflow/tmp/ and the superseded .devflow/tmp/), so a scratch file, a dangling symlink, or a path too long to open under it can no longer abort the upgrade preview. The preview also excludes the vendor/ tree of both state directories (.prflow/vendor/ and the superseded .devflow/vendor/), matching what the sandbox copy omits, so an un-migrated .devflow/vendor tree is no longer reported as a page of false DELETE rows. When the diff step cannot open a file inside the paths it compares, it now prints one UNREADABLE <path> (<reason>) row for it, keeps going, does not count that path as a changed file, and — when at least one path could not be compared — prints devflow-install: N file(s) could not be compared (listed above as UNREADABLE). after the usual devflow-install: N file(s) would change. line, then reports DRY RUN — nothing in this repository was written. and exits 0. A file the diff step cannot open is no longer mislabelled binary.
Cloud implement runs now provision lint tools from a fresh, digest-checked download every run instead of trusting a cached binary. The lint-tool directory is emptied at the start of each /prflow:implement run and is no longer backed by the Actions cache, so a file planted in that cache (or written into the directory earlier in the job) can no longer be executed or placed on PATH before the model starts. Each tool is either reused from a version-matching copy already on the runner’s PATH or downloaded from its pinned archive and verified against the manifest’s sha256. (#575)
Upgrades no longer silently apply a stale installer to a newer release. When you re-run a saved install.sh against a different release, the installer now compares itself against that release’s install.sh (ignoring line-ending differences) and, in apply mode, stops before writing anything — printing the command that downloads the matching installer and the DEVFLOW_ALLOW_INSTALLER_DRIFT=1 escape hatch to install with the old one anyway. A dry run prints the same warning and still shows the plan. A curl … | bash run, or a release that ships no install.sh, prints a one-line note that the self-check was skipped and continues. Running the scaffolder — via the installer or /prflow:init — also warns when a stale installer copy (install.sh, devflow-install.sh, or prflow-install.sh) sits committed at your repo root. Prompt-extension .md.example files are now refreshed when their content is out of date instead of kept forever, and a thin upgrade over a repository that commits the plugin tree (.prflow/vendor/prflow/) now refreshes that committed tree so CI stops running the old plugin. (#576) Fix the Phase 3.4 acceptance-criteria gate in a repository whose .prflow/tmp/ is not gitignored: ac-verifier-artifacts.py prepare now writes the attempt root’s own .gitignore (holding *) and captures the checkout-drift baseline only after it exists, so the helper’s own attempt files no longer read as checkout drift and falsely block the gate. Its untracked offender list now comes from git ls-files -o --exclude-standard, so a stray file inside an untracked directory is named individually rather than collapsed to the directory.

On a clean checkout check now prints one compact routing line of JSON and writes the full bounded per-criterion dispositions record to ac-dispositions.md in the attempt directory, instead of printing the whole reconciliation record, so the orchestrator carries far fewer tokens through the gate.

Windows Git Bash telemetry-branch migration now migrates every record. On Windows Git Bash (MSYS), an argument that joined a full ref name to a path (refs/heads/<branch>:<path>) was rewritten before git saw it, so the telemetry-branch migration copied zero records while still printing success, and PRFlow’s telemetry record lookups treated persisted records as missing. Both the migration helper and the record lookups now resolve each ref to its commit ID before building the lookup argument, so the migration copies every readable record on Windows exactly as it does on Linux and macOS, and the “already persisted” checks find records that exist. The migration also now warns once for each listed record it cannot read and prints how many were unreadable — keeping the source branch for a manual retry — instead of reporting success when nothing could be read. You get this through the normal plugin update. (#578)
/prflow:docs-verify now takes --lead docs|code instead of --search-space. The report-only mode drops the --search-space <pathspec> flag and adds --lead docs|code, which chooses whether the agent leads from the documentation or from the code while both search the whole repository. A run with no --lead keeps today’s behaviour — documentation first, then code — and returns the documentation verdict. Running the command by hand with --search-space in the leading flags now reports it as an unrecognized flag and refuses the run. The report-only output is a compact set of fields kept under 1,000 words. (#588)

September 14, 2026

The /prflow:implement terminal fences now run in a worktree-isolated Claude Code session. The Phase 4.3 finalize call and the outcome-reaction call carried the bare word complete (--status Complete, --outcome complete), which such a session refuses as a shell builtin — silently dropping the 🎉 reaction on the triggering comment. Both fences now pass the value =-joined (--status=Complete, --outcome=complete), and react-to-trigger.sh accepts the =-joined spelling for every value flag (and, under --report-failure, exits non-zero on an unparseable argument so the fence’s fallback note fires). A repository whose vendored plugin tree predates this change keeps losing the local-tier reaction until it re-runs the installer to re-vendor the updated fences. (#431)
The weekly retrospective now names its state branch and pull request after PRFlow. The state branch is prflow/learnings-<date> and the state pull request’s title and commit subjects read chore(prflow): … instead of the superseded DevFlow spelling. Both readers of the branch prefix — the state-PR guard and the pull-request classifier — accept the old devflow/learnings-* spelling as well until the superseded prefix is retired, so a repository whose plugin auto-updates while last week’s devflow/learnings-* state pull request is still open is still reminded to merge it and does not re-process that week. Because a plugin can auto-update ahead of the pinned engine the scheduled workflow vendors, bump prflow_version (re-run install.sh) in the same upgrade as the plugin; a plugin updated well ahead of the pin can re-process one week once. (#496)
Isolate implementation finalization in a dedicated worker. The main agent receives compact evidence before publishing the pull request, while documentation and final verification procedures stay in the worker. (#501)
Review verdicts and finding counts now read the reviewed commit from the review’s own verdict marker, not the GitHub reviews-API commit_id. GitHub moves a live review’s commit_id to the current head when a branch is updated, so a pull request updated after review could have its review misread — the verdict deriver reported an unhelpful “keys disagree” state, and the experiment records showed a blank finding count. Both readers now select and join on the marker’s head=, which records the tree that was actually reviewed, so an updated branch reports the real verdict and count. (#433)
Resumed runs keep unfinished review work. When /prflow:implement resumes an interrupted run, intake now reconciles a historical completion claim against later corrective evidence and any interrupted review worker before describing review as done, carrying an outstanding review-evidence obligation forward through its existing handoff fields. A resumed run no longer reduces remaining work to PR-ready when review still owes work for the current candidate. (#521) The documentation gate now recognizes a plain - Documentation Needed — bullet under ## Implementation Notes, alongside the existing bold and ### Documentation Needed heading forms. An issue that names its documentation deliverables without bold formatting is enforced during /prflow:implement instead of being silently treated as naming no documentation. The next same-level plain peer still closes the block, existing section, peer and fence boundaries and the documentation-path allowlist continue to govern extraction, and an out-of-allowlist path remains refused. (#506)
A /prflow:review-and-fix run no longer loses the fix loop’s per-iteration continuation record to the review engine’s own telemetry. When efficiency telemetry was enabled, an engine invocation driven by the fix loop still ran the standalone review Phase 4.5 recipe and overwrote the loop-owned iter-<N>.json with a source: "review" object that dropped the loop’s continuation fields, so an interrupted run could resume from a clobbered record. The engine’s Phase 4.5 write is now bound to the caller’s requested phase range: a review-and-fix entry requests Phases 0 through 4.3 and passes phase_range_max = 4.3 on its primary, shadow, and inline-fallback engine entries, so the engine skips Phase 4.5 and the loop stays the sole writer of its iteration record. Standalone /prflow:review passes no such bound and still produces its configured telemetry and trace when the flag is enabled. (#517)
A rate-limit or provider failure now resumes instead of terminalizing. Earlier releases classified a failed claude step and, for a provider rate limit whose reset was still in the future, marked the workpad 💥 Failed rather than resuming — the run then waited for a human to re-trigger it. The stall backstop and the Spot recovery job now resume such a failure through the normal capped-resume path like any other interim stall, so max_resume_attempts alone bounds the retries. The defer_to_runner_retry opt-in continues to govern whether a failure is deferred to your runner’s own retry instead of resumed. This reverses the September 12 provider rate-limit terminalize behavior.

September 13, 2026

Run implementation setup intake in a dedicated agent while preserving requirements, resume decisions, dependency checks and branch ordering. The orchestrator receives a compact evidence-backed handoff instead of the intake transcript. (#463)
The implement run’s advisory changed-file lint now covers GitHub Actions workflow files and shipped lib/test shell scripts. Editing a workflow file now runs actionlint over it in-session, and editing a lib/test shell script now runs ShellCheck over it, so a lint problem CI would reject surfaces during the run instead of after a separate fix-up commit. The lint toolchain gains a pinned, digest-verified actionlint that is provisioned automatically alongside ShellCheck and Ruff. (#375)
Implement runs stop relaunching a long test command just to read a different slice of its output. When an implement run verifies acceptance criteria, it now runs each test command whose result it reads from a summary line once, keeps that run’s full output, and reads every later slice it needs — an assertion line, a failure detail, the summary line — from the kept output instead of running the whole command again. A run against a large test file now spends a single launch where it previously spent several, so verification finishes sooner and costs less. (#347) Move deterministic implement branch setup, draft pull-request opening, and deferred follow-up filing behind tested helper modes, reducing prompt overhead while preserving model-owned merge-conflict resolution. (#437)

September 12, 2026

A provider rate-limit failure now terminalizes even with defer_to_runner_retry off. The implement stall backstop’s provider-failure classification is armed on every failed job, not only when defer_to_runner_retry is enabled. A run that fails on a provider rate limit whose reset is still in the future is now terminalized (💥 Failed, naming the reset time) instead of being auto-resumed back into the exhausted limit — so a repository running the default (defer_to_runner_retry: false) gains the protection it previously only had with the flag on. The flag continues to govern only whether an unclassified interim failure is deferred to a runner retry or resumed by the backstop. (#401)
The review engine now reads prflow_review.agent_overrides on native-Windows Python hosts. On a Windows runner, resolve-review-overrides.py could not run config-get.sh (a .sh shebang is not directly executable on Windows), so every configured per-agent model/effort override was silently dropped and the review fell back to defaults. It now invokes config-get.sh under bash — the DEVFLOW_BASH interpreter when set, otherwise bash — with a forward-slash path, so overrides resolve on Windows exactly as they do on Linux and macOS. (#365)
The /prflow:implement cleanup self-review now runs through a PRFlow-owned code-reviewer dispatch instead of the built-in /simplify. Phase 3.2 reviews the branch diff for reuse, simplification, efficiency and altitude cleanups through one first-party review agent whose contract PRFlow ships and versions, applies the findings itself, and records a cleanup agent whose return is unusable as a visible workpad reflection rather than silently reading it as a clean pass. (#358)
Point the cloud implement job at its own runner. The cloud /prflow:implement job now resolves a DEVFLOW_IMPLEMENT_RUNNER repository variable when you set it, falling back to DEVFLOW_RUNNER and then ubuntu-latest, so you can give implement runs a distinct runner without touching the runner the review and retrospective tiers use. Repositories that set neither variable, or only DEVFLOW_RUNNER, run exactly as before. You get this through the normal plugin update. (#402)
The pre-implementation audit now checks unmarked sweeping claims about your code. When an issue asserts a falsifiable universal or completeness claim about existing code — “no X does Y”, “every X is Z”, or “a named surface carries none of a thing” — without a verification marker, /prflow:implement’s Phase 1.6 audit now reads the source the claim names and either confirms it, corrects the run’s understanding when the source refutes it, or records it unverified when no concrete source is named — and when a refuted claim is prescribed word-for-word by an acceptance criterion, it stops the run over that conflict rather than shipping the false wording — so such a claim is adjudicated at planning time, or recorded unverified when it cannot be, rather than taken at face value. (#392)
The merge-gating review now rejects a pull request when a finding shows a decided acceptance criterion is unmet. The shared review engine gains a threshold-independent, non-demotable unmet-decided-criterion carve-out: a Phase-3 review finding that establishes the shipped code does not satisfy a decided (resolved, non-post-merge) acceptance criterion of the linked issue drives REJECT at every threshold and regardless of the severity grade the agent assigned — reaching the same outcome a FAILed issue_acceptance checklist item already produces, and closing the agent-path leak that let such findings through as APPROVE-with-notes. A self-disclosed limitation in the shipped artifact that contradicts a decided criterion is recorded as that criterion being unmet, never credited as honest disclosure that clears the finding. When a linked issue’s decided-criterion count exceeds the rank-1 issue_acceptance sub-cap, the criteria dropped from the checklist are surfaced as a coverage shortfall the verdict rejects on, so a criterion the rank-1 sub-cap drops is never silently lost from the merge gate while the sub-cap keeps its size discipline for the other checklist categories. A general quality or test-coverage finding that establishes no unmet decided criterion is unaffected and stays weighed against the configured threshold. (#389)
Issue drafting now rejects acceptance criteria a single implement run cannot satisfy. When you draft an issue with /prflow:spec, drafting checks each acceptance criterion whose subject is an existing file, path, or subsystem against the current tree and refuses one whose target is already gone, while keeping a criterion about a target the change itself will create. (#388) Add an opt-in cloud-CI verification mode for PRFlow’s own cloud /prflow:implement runs (issue #403).

A new prflow_implement.ci_verification.enabled config key (default false) lets a cloud implement run offload a full-suite verification boundary to the repository’s existing CI workflow instead of running the suite on its implementation host. scripts/ci-verification-request.py owns the request/wait/collect-evidence lifecycle — persisting a candidate-bound request before dispatch, polling the run inside one bounded foreground call, and building a versioned cloud_ci_evidence record from the run’s shard tallies and job conclusions — and scripts/check-completion-evidence.py validates that record (exact shard population, zero failed/skipped/exit tallies, required-check coverage, and a clean current candidate) before scripts/workpad.py accepts it as completion evidence in its own marker family. ci.yml gains optional workflow_dispatch request_id/expected_head_sha inputs and a worker-checkout validation step. The mode is fail-closed and default-OFF: an incomplete deployment refuses CI mode with an actionable explanation, and every consumer, local, and standalone review/fix path keeps its existing verification semantics unchanged.

September 11, 2026

When a configured label is turned off, the run’s log now names the config key instead of blaming a caller mistake. With a label channel disabled by a present-but-empty docs.labels/deferred.labels, apply-labels.sh in config mode now warns that the named config key resolved to no labels and that no substitute label is owed, rather than reporting a caller-passed empty list. A maintainer reading a run’s log or a filed issue sees that their off-switch was honored, not a phantom helper defect. The positional call form keeps its existing wording. (#339) Make the /prflow:implement Phase 3.4 acceptance-criteria gate refuse a satisfied verdict the evidence verifier reached without running anything. An evidence-side satisfied whose command-run disposition is no is now reconciled to unestablished (reason unexecuted) before the two verifier votes are compared, so a run blocks and says so rather than shipping a review-ready pull request on evidence nobody observed. A refused or silent Phase 1.6 audit-record validator is now recorded on the workpad as unvalidated instead of proceeding silently.
Cancelled and signal-terminated cloud runs now preserve their execution transcript. When transcript publication is enabled and a run’s Claude step is cancelled or interrupted before the action writes its execution file, the workflow now scrubs and uploads the CLI’s own session transcript for that run instead of losing it, under the usual artifact name and retention. A cancelled attempt’s artifact holds the CLI’s session files, which carry more than the action’s message stream — treat it as sensitive. (#342)
Workpad comments now stay their real size on Windows hosts. workpad.py normalizes a comment body to LF: a run of one or more carriage returns before a newline is collapsed to that newline when it reads a body from GitHub or from a body file, and it writes bodies as bytes, so a native-Windows Python’s text-mode newline translation can no longer add a carriage return on each write. A workpad already inflated by earlier Windows runs shrinks back to its clean form on its next update, with no separate compaction step. The 65,536-byte comment-size guard is unchanged, now measured on the canonical body — so a body that was over the limit only because of accumulated carriage returns is written rather than refused. Consumers on other hosts get workpads that stop carrying mixed line endings after a web-UI edit. workpad.py patch no longer echoes the returned body to stdout on success (matching update), and workpad.py prior-status now writes one stderr line on its exit-1 arm so a silent exit is never mistaken for a hang. (#349)
Old telemetry history is migrated onto the current telemetry branch automatically after a rename upgrade. A new bundled helper (scripts/migrate-telemetry-branch.sh) moves the cost-and-effectiveness records from a pre-rename devflow-telemetry branch onto the branch PRFlow now writes to, restaging each record from its old .devflow/logs/ path to the current .prflow/logs/ path and handing the staging root to the writer’s own persist function. It runs from /prflow:init and install.sh --apply, and as a backstop before the first append on the writer’s next authorized persist, so a consumer whose plugin auto-updated ahead of init is healed on their next writable run. The retrospective’s stranded-record warning now points the maintainer at /prflow:init instead of a manual branch-rename push. Use the configured base branch throughout an implement run, and resume on the workpad’s recorded branch.

The branch-setup agent now looks up the configured base_branch on every arm (not only when it reuses or creates a branch), prints it, uses it in every base-consuming command and in the preflight.py branch-state state file, and returns it as a base: line in its record; the orchestrator takes the base from that record wherever a later Phase 1–4 instruction needs it. A resume that adopts no open pull request now checks out and continues the feature branch its workpad recorded — when the recorded name matches the issue’s branch shape, the branch exists on the remote, and it never had a pull request — instead of forking a date-suffixed duplicate. workpad.py’s skipped-intentional review-coverage size check now measures against the configured base (origin/main when unset) rather than the repository’s default branch, so it records a real verdict on cloud checkouts and for consumers whose base differs from the default branch.

Cloud implement recovery no longer defers a provider/API failure to a runner retry that will never happen. With prflow_implement.stall_backstop.defer_to_runner_retry enabled, PRFlow previously deferred every failed claude step to the runner’s retry — even a provider 429 that RunsOn’s retry=when-interrupted never re-runs — leaving the issue stuck on an interim workpad with no PR. The stall backstop and the Spot recovery job now positively classify the failure from the execution diagnostics (terminal_reason=api_error with a numeric api_error_status) and, on that classification, converge the run through PRFlow’s own bounded path — a capped /prflow:implement resume, or a terminal 💥 Failed disposition naming the reset time for a rate-limit rejection whose reset is still in the future — instead of deferring. An unclassifiable or unavailable failure (including an unobservable Spot reclaim) still defers, so the two recovery mechanisms never drive one issue at once. (#362)
The weekly retrospective no longer loses its credentials partway through a long run. devflow-retrospective.yml was the only agent-running workflow without the long-run credential refresher, but a weekly run routinely outlives the GitHub App installation token’s 60-minute lifetime and does all of its writing at the very end — so the state-PR push and every issue-filing call failed with 401 Bad credentials while the run still reported success, discarding the whole week’s analysis. The retrospective job now starts the detached refresher and the fresh-gh wrapper after checkout and retires them in an always() step, exactly as the implement and command jobs do. Gated on the same vars.DEVFLOW_APP_ID != '' condition as the existing token mint, so a repository with no App configured is unaffected. (#374)
Cloud runs no longer silently deny the plugin’s own helper scripts when your installed workflow predates the plugin. The Resolve allowed-tools step in both cloud workflows now unions every plugin-helper grant the vendored capability-profiles.json names into the allowlist your run executes under, so a workflow whose baked list lags a newer plugin (a hand-edited or un-refreshed .github/workflows/ copy) stops dropping helper-produced work without a trace. When a plugin helper is still refused, the run records the denial and reports the missing artifact instead of fabricating a result. (#352)

September 10, 2026

Add the opt-in prflow_implement.stall_backstop.defer_to_runner_retry key (default false) for a runner that retries a failed agent job on its own, such as RunsOn retry=when-interrupted on EC2 Spot (issue #305). When true, an interim workpad after a failure agent step is no longer auto-resumed by PRFlow: the stall backstop and the Spot recovery job leave the workpad in progress, post one short informational comment, and let the runner’s retry resume the run, so two recovery mechanisms never drive one issue at once. A cancelled job keeps its existing recovery path, since no runner retries a cancel. Without the key every existing behavior is unchanged.
The weekly retrospective workflow now ships in the public release. The installer already copied devflow-retrospective.yml when present, but the public-release package omitted the file, so a repository installed from the public release silently received only two of the three consumer workflows. The release package now includes it, so a public-release install gets the retrospective workflow the installer promises. (#318) Add self-install guards so PRFlow’s own setup entry points refuse to mutate the engine repository. install.sh now refuses an apply request (--apply or DEVFLOW_APPLY=1, even when a later --dry-run wins mode resolution) when the target repo is PRFlow’s own checkout, and /prflow:init refuses the whole run at the top in the same case — both printing a self-install breadcrumb, writing nothing, and both lifted by setting DEVFLOW_ALLOW_SELF_INSTALL to a non-empty value. scripts/provision-local-settings.sh now skips writing its extraKnownMarketplaces entry (still enabling the plugin, printing a conflict breadcrumb, exiting 0) when the user-scope settings file already registers the marketplace against a different source, so a project-scope write can no longer silently shadow-downgrade it.
Long cloud runs on Windows self-hosted runners no longer die with Bad credentials (HTTP 401). The background credential refresher now locates the git-push config file by reading git’s NUL-terminated origin output, so a temporary-directory path containing backslashes (which git otherwise prints quoted) is found and refreshed, and it writes the git-push credential and the gh token file as two independent surfaces so a failure of one no longer starves the other. Runs longer than an hour stay authenticated. (#332)
Verified-premise checks accept quotations that contain inline code. The verified-premise checker that runs during issue drafting and during an implementing run’s pre-checks treats a backtick span inside a quoted sentence as part of that sentence, so a true premise whose quotation contains a backticked word or path grades as holding and searches the whole quoted sentence in the cited file. Drafters keep the full sentence they quoted, code term included. You get this through the normal plugin update. (#326)

September 9, 2026

The docs.labels off-switch now works in cloud implement runs. Setting docs.labels to an empty string suppresses the “Documented” pull-request label on your pull requests; previously a cloud run could still attach it when the config presence probe did not answer definitively. Consumers who have never set docs.labels are unaffected and keep the default “Documented” label. (#286)
The installed plugin no longer ships PRFlow’s own Claude Code hooks or its maintainer-only tooling. The Stop-hook guard, run-marker writer, Stop-hook probe and PreToolUse guard (with their render and probe helpers) are deleted, and the artifact generators and workflow-flight-recorder analysis tools move out of the shipped slice, so a consumer install carries only files that do something in its own repository. The branch-checkpoint helper now registers git merge drivers from a consumer-generic prflow_implement.merge_drivers config map instead of a hardcoded development-tree path. A consumer that had hand-wired the removed stop-guard hook script as a Stop hook should remove that hook entry, which otherwise logs No such file at every Stop.
/prflow:spec now flags over-engineering in drafts. The audit that shapes a new spec catches mechanism, acceptance criteria, or dependencies specified beyond what the stated problem needs — including a safeguard against a case an existing check already covers — so a spec ships the smallest mechanism that solves the problem instead of accreting unnecessary machinery, with no per-run hand-prompting. (#312)

September 8, 2026

The PRFlow:Implementing label now reaches a pull request the moment its implement run links it. When the status-label mirror is enabled, scripts/workpad.py update reconciles the managed status label onto the pull request as soon as the run records the PR link — taking the PR number from the link, not from a lookup GitHub can leave lagging just after creation — so a mid-run pull request is distinguishable from an abandoned one directly in the pull-request list instead of only once the run reaches its next status write. (#252) Review runs now update the PR progress comment at every phase boundary — the checklist row and the live findings change as Phase 1, Phase 2 and each Phase 3 agent complete, instead of the comment sitting unchanged from run start until the verdict. A new workpad.py progress subcommand ticks one ## Blueprint row and/or appends to ## Findings (live) by comment id in a single PATCH, and the review’s Phase 1, Phase 2 and Phase 3 files each own their own boundary update.
Route the implement skill’s two Phase 3 commit fences through the durability-checkpoint helper instead of a whole-tree git add -A. The /simplify commit (Phase 3.2) and the review-and-fix residual flush (Phase 3.3) previously staged the entire working tree except .prflow/tmp/, committing any unrelated leftover file into the pull request and contradicting the explicit-path staging rule the rest of the skill enforces. Each step now captures a git status --porcelain listing before and after the step, hands only the paths whose status row changed to scripts/phase2-durability-checkpoint.sh (which stages exactly those, commits, pushes, and confirms the push landed), and skips the commit when nothing changed — so a pre-existing unrelated file stays uncommitted for the Phase 4.3 clean-tree check. (#256)
Recover /prflow:implement runs interrupted by an EC2 Spot reclaim. With prflow_implement.spot_interruption_watcher.enabled set to true on a supported Linux EC2 Spot runner, a watcher detects the interruption while the runner is still alive, records a durable reclaim marker, and ends the run cleanly so its cleanup can finish. A downstream recovery job then reconciles the outcome: a genuine reclaim is resumed once (subject to the existing attempt cap), while an intentional cancellation stays final and is never resumed. The watcher is opt-in and off by default. (#261)
Each /prflow:implement run now keeps its temporary files in a per-issue folder that clears itself when the run succeeds. A run working on an issue writes its scratch files under .prflow/tmp/implement/<issue>/, clears any folder a killed earlier run on the same issue left behind, sweeps the flat leftovers older versions wrote, and removes its own folder on a successful finish. Your working copy no longer fills up with untraceable scratch leftovers, and a later run on a different issue can no longer inherit or overwrite an earlier run’s fixed-name scratch state. (#240)

September 7, 2026

The shipped review engine and retrospective no longer apply rules written for PRFlow’s own source tree. The engine_self_modifying review-engine flag — which forced the full checklist, an early shadow pass, and disabled the documentation-only carve-out whenever a changed path started with skills/, agents/ or lib/, was a prompt extension under the state directory, or was named CLAUDE.md — is removed from the shipped plugin, so a consumer’s pull request now gets the review profile its diff size and file types earn. scripts/workpad.py grades a skipped-intentional review-coverage claim against the line ceiling, file ceiling and config-only extension set in every repository and reads no .claude-plugin/plugin.json, so the offline evidence gate and its verdict-marker consumer agree with the shipped prose everywhere. The retrospective and issue-drafting steelman no longer name PRFlow-owned paths as intervention targets: a plugin-caused pattern is recorded for upstream forwarding, and the steelman resolves the running plugin’s own root. PRFlow’s own repository keeps this behavior through its repo-local review, retrospective and retrospective-audit prompt extensions. (#229) Vendor the plugin through the fetch branch with a configurable repository and a job credential. The vendor step’s self branch, which copied the checkout, is removed: an already-committed vendored tree is used as-is, and any other checkout is fetched. A new optional prflow_repo config key (owner/name, default empty meaning the public repository) names the repository the fetch branch clones, and the vendor-plugin action gains a token input that supplies a one-shot git credential helper so a fork or private repository can be fetched; a consumer supplies the credential through the PRFLOW_REPO_TOKEN repository secret. No workflow or shipped helper falls back to the checkout’s scripts/ directory any more; a missing vendored helper fails the job with the existing incomplete-vendor error, and a desk lint keeps such a fallback line from reappearing. A consumer on the default configuration is unchanged.
Renamed the issue-drafting command to /prflow:spec. The command that turns a rough user story, bug report, or idea into a spec’d-out GitHub issue is now /prflow:spec — one canonical name that the code, the tests, the docs, and the run-measurement tools all share. /prflow:create-issue and /devflow:create-issue keep working unchanged as permanent aliases. The old plural /prflow:specs spelling no longer resolves as a command; a run started with it gets the runner’s unknown-command response, so retype /prflow:spec. A consumer who customized the command through .prflow/skill-extensions/create-issue.md keeps that customization applied (it is read through under the old filename) and is told by a breadcrumb to run /prflow:init to rename the file. A consumer who set the create_issue.investigation_record_enabled config key is told the key moved, but the setting is not read through: until /prflow:init migrates it the key resolves as unset (the investigation record is published), so /prflow:init is the remedy the breadcrumb names. (#216)
Shipped skills and agents no longer reference PRFlow-only files, commands, or conventions. Every skills/ and agents/ body now names only files, commands, and conventions a consumer repository actually has: the docs skills resolve the configured base branch instead of a hardcoded origin/main, the release-notes reconciliation reads the project’s own release convention, the review prohibitions cover the project’s own test runners, and the weekly retrospective’s suite-profiling steps moved into a repo-local prompt extension. A consumer no longer sees a step silently skip, read a file that is not there, or apply a rule written for PRFlow’s own repository. (#230)
A {0} in DEVFLOW_RUNNER or DEVFLOW_LIGHT_RUNNER is now replaced with the workflow run id. Every shipped workflow’s bare-label runs-on arm goes through format(vars.<NAME>, github.run_id), so a RunsOn-style label (runs-on={0}/cpu=8/...) namespaces its runner per run instead of arriving with a literal {0}. A placeholder-free value passes through unchanged; a literal { in the value must be written {{. (#240 probe groundwork)
Multi-line workpad Progress notes now render as indented continuation lines. A note passed with embedded line breaks renders as one Progress bullet whose non-blank continuation lines are indented under it (blank lines dropped), instead of landing verbatim inside the nested list where blank and column-0 lines broke the list and spent the comment’s size budget. The failed-write replay recognizes a note by its rendered form. (#246)

September 6, 2026

/prflow:init now turns on Claude Code’s task-tracking tools for your future sessions. Since Claude Code v2.1.233 the task tools (TaskCreate, TaskGet, TaskUpdate, TaskList, TodoWrite) are off by default on newer models unless you opt in, which silently degraded PRFlow’s task-tracking skills to a non-persisted checklist. Init now deep-merges env.CLAUDE_CODE_ENABLE_TODO_TOOLS = "1" into your user-scope ~/.claude/settings.json when the opt-in is set in neither the environment nor that file, preserving every value you already set, and prints a notice that the setting takes effect only in a newly launched session. A pre-existing value or an environment override is left untouched. (#207)
Clearer review status-label names. When the config-gated review status-label mirror (review_status_labels.enabled, off by default) is on, a completed review whose verdict is reject is now labelled PRFlow:ReviewRejected, and a review that did not complete (no verdict, dead run, evidence-gate failure, or finalizer catch) is now labelled PRFlow:ReviewStuck. PRFlow:Reviewing and PRFlow:Approved are unchanged, as are all four labels’ colors. The two states remain distinct — this renames the labels for readability, and does not merge them. Any older-named label already applied to an issue or PR is left in place and can be deleted manually. (#214)
/prflow:review-and-fix now finds the review engine that ships with the running plugin. On a thin install the fix loop’s engine lookup previously checked only three repository-root-anchored directories — none of which exists on a consumer’s own machine — and halted before reviewing anything, naming a /prflow:init remedy that creates no such directory. The lookup now appends one last candidate, the running plugin’s own review sibling of the loop’s skill directory, so a thin-install consumer regains the local fix loop and the local /prflow:implement lifecycle. The three repository-anchored candidates keep their order and win when present, so committed-vendor consumers, cloud runs, and this repository’s own runs are unchanged; a stale leftover vendored tree is now reported with a version-mismatch note instead of being run silently. (#213)
Code review now flags references a change breaks outside the PR diff. When a diff removes or renames a distinctive string literal or identifier, the code-reviewer agent searches the whole checked-out repository for surviving references to the old value and reports the ones that live outside the diff and stay keyed on it, so a rename that silently breaks an unmodified file is caught at review time instead of shipping green. (#212)
Acceptance-criteria verifier reports now reach reconciliation directly, guarded against unrelated checkout changes. During an implement run’s acceptance-criteria gate, the two verifiers now write their JSON reports straight to per-attempt destinations instead of having the orchestrator copy them, so criterion statuses, evidence and reasons can no longer be lost in transcription. A new checkout-fingerprint guard compares the checkout before and after the verifiers run and blocks the gate if anything unrelated changed, naming the drifted fields and offending paths so the change can be investigated. (#219)
The final documentation pass now refuses Documentation Needed deliverables outside documentation locations. /prflow:implement’s documentation step accepts a deliverable named in an issue’s Documentation Needed block only when its path sits inside a documentation location — the configured internal or external documentation root, the release-notes file, the changelog file, or README.md. A deliverable naming any other path is skipped and recorded, and the run finishes normally, so the pass can no longer commit an unreviewed edit to a non-documentation file it was handed as a deliverable after code review has finished. /prflow:create-issue also stops writing such paths into that block. (#222)

September 5, 2026

Rename the consumer-facing per-skill extension directory from .prflow/prompt-extensions/ to .prflow/skill-extensions/. /prflow:init migrates an existing .prflow/prompt-extensions/ directory in place (renaming nothing when both directories already exist and reporting a conflict to reconcile by hand), and every reader resolves .prflow/skill-extensions/ first and falls back to a present .prflow/prompt-extensions/ with a migrate breadcrumb during the transition, so an un-migrated consumer keeps working. The DEVFLOW_PROMPT_EXTENSION_ROOT environment variable and the helper filenames are unchanged.

Outcome reactions find the latest implement trigger on long-running issues. PRFlow checks every issue-comment page before choosing the triggering comment, so completion and blocked reactions reach the current request even after an issue has accumulated more than 100 comments. (#191)
Harden the /prflow:create-issue (/prflow:specs) run helpers. The run’s slug is now keyed on a run-directory registry (run-meta.json) instead of a session id, so a continued session recovers its own run, cleanup no longer leaves orphaned issue-run-slug.<session-id> pointer files behind, and concurrent runs and linked worktrees are told apart by topic and start time. A new scripts/check-draft-provenance.py checker, run in the draft bootstrap beside the existing two, catches a provenance signature that landed mid-body before the draft is presented. (#198)
An explicit empty docs.labels / deferred.labels value now applies no labels instead of falling back to the default. Previously a present-but-empty value ("") was coerced to the caller’s fallback, so /prflow:implement still labelled its PRs Documented (and its deferred follow-up issues PRFlow,Deferred) even when the config set the key to "" to turn labels off; the only working off-switch was the non-obvious ",". scripts/apply-labels.sh config mode now gates the fallback on a new opt-in config-get.sh --presence probe, so a key that is present-but-empty means “apply no labels” while the default applies only when the key is genuinely absent (a JSON null counts as absent). A whitespace- or separators-only value still applies none, and a non-empty value still applies exactly those labels — both unchanged. The shared config-get.sh resolver’s default read is untouched for every other key. (#208)
/prflow:specs now applies the same customization file as /prflow:create-issue, and create-issue’s helper fences run in a worktree-isolated session. The create-issue pipeline reads one prompt-extension file, .prflow/skill-extensions/create-issue.md, on both command names; the /prflow:specs alias no longer loads a separate specs.md, and /prflow:init no longer scaffolds a specs.md.example (removing a stale one on its next run). When a stray specs.md sits beside create-issue.md, the loader prints one line naming it and pointing at create-issue.md, and the create-issue run surfaces that line to you rather than silently ignoring the file. The create-issue skill’s per-finding audit ledger now reaches the state owner from a file rather than a stdin heredoc, and the create-issue command fences no longer use the shell shapes a worktree-isolated Claude Code session refuses. (#200)

September 4, 2026

Fix the implement skill’s end-of-run reaction so it posts the correct outcome on both tiers. scripts/react-to-trigger.sh now accepts --outcome complete|blocked with --issue, choosing the reaction itself (🎉 hooray for a completed run, 👎 -1 for a blocked one) and resolving the triggering comment itself — from the event file, else the newest non-workpad implement-trigger comment. The implement skill’s outcome-reaction fence becomes a single leading-token call with a prefix-removed/anchor fallback ladder, so the correct reaction now posts on both the local and cloud tiers instead of re-posting the pickup 🚀.

Closed fail-open and security-shaped defects in the implement helper scripts. The checkout-fingerprint helper now hashes untracked files without writing them to the git object store, so a verification step no longer copies an untracked secret into .git/objects. The acceptance-criteria parser tags only unambiguous live-environment phrases, so a code-verifiable criterion is no longer dropped from the merge gate on a loose phrase match. The verification flight honours its DEVFLOW_FLIGHT_NOW clock override only behind a companion test-clock gate and marks any handle written under it, so the override is inert in production. A dispatched-but-lost review-coverage disposition is now admitted only over a measured roster with a recorded dispatched reviewer, so a run cannot finalize on a lost-dispatch claim with no dispatch on record. (#181)
Trimmed every shipped agent description to a short trigger line and dropped the unused web tools from the discovery agents. Each agents/*.md description is now a single ≤120-byte trigger statement, so every enabled session carries several kilobytes less system-prompt text on every turn; the worked scenarios and secondary triggers moved into each agent’s body, which loads only when the agent runs. The code-explorer and code-architect discovery agents no longer grant WebFetch or WebSearch — an autonomous implement run’s discovery agents cannot reach the web. A new byte ceiling in the frontmatter validator keeps the descriptions from growing back. (#179)
/prflow:implement Phase 1 now stops with a Blocked status on a failed push or uncommitted tracked changes instead of continuing. A failed branch push is reported as a Blocked run naming the cause, rather than silently leaving an unpushed branch; uncommitted tracked changes stop the run for you to commit or stash, rather than gaining a stray commit on the base branch; and the setup file’s agent-file fallbacks now resolve in a consumer checkout. (#178) Make the implement Phase 2 sweep prose decidable and consumer-safe (issue #180). Comment relocation now has one owner: a non-preventing comment is deleted or shortened in Phase 2, and an explanation worth keeping is recorded through a relocate to docs: workpad note that Phase 4.1 hands to the docs pass. The §2.5 workflow-edit guard keys on the durability helper’s observable stderr token rather than a run-facts field that is never produced. The §2.2 complexity assessment routes by one rule (Path B when any Complex bullet holds or the touched-file count exceeds five; otherwise Path A). The test-first gate is runner-neutral — it confirms the runner collected and reported the new test and extracts a branch-selecting snippet into a unit the repository’s test runner can drive, with a no-runner arm for repositories that have none. PRFlow-internal names are removed from the shipped Phase 2 bodies.
/prflow:implement’s review phase now stays predictable when a tool is missing or refused, and never commits its own run scratch. The pull request an implement run opens no longer carries PRFlow’s working files, even in a repository whose ignore rules predate them. When the /simplify step is unavailable on your runner, the workpad records it as unavailable instead of an empty result that reads like a clean pass. When the review-and-fix step cannot be loaded, the run stops as Blocked and names the refusal, instead of attempting an unbounded review by hand. The review phase’s guidance now reads correctly in any repository, not only PRFlow’s own. (#182)

September 3, 2026

Key the create-issue run-slug pointer by session. scripts/cleanup-create-issue-run.sh now owns the pointer through --record-slug and --resolve-slug modes and writes it to .prflow/tmp/create-issue/issue-run-slug.<session-id>, so concurrent /prflow:create-issue runs in one checkout no longer overwrite each other’s slug and no run adopts another session’s identity after context compaction. On a harness that exposes no session identity the helper reports that plainly and the run takes the existing title-derived fallback.

Trust a GitHub App as a configured bot login everywhere by normalizing logins through one shared rule (issue #157). A new lib/login_normalize.py trims whitespace, strips a leading app/ and a trailing [bot], and lowercases both a login and each configured comparand before comparing, so an allowed_bots (or watched_authors) entry written as the bare slug, <slug>[bot], app/<slug>, or in mixed case all match the same App. The deferral matcher, the lint-adjudication allowlist arm, the workflow authorization gate, the CI review trigger, and the retrospective scanner now decide login trust and identity through this rule instead of their own strip-and-compare, so a GitHub App author’s Scope-Acknowledged deferrals are honored rather than rejected as untrusted-filer. The allowed_bots and watched_authors config-schema descriptions now state the accepted entry forms. (#157)
Dead cloud runs now name why they died, and their comments are shorter. When a cloud /prflow:implement or /prflow:review run ends in error, the run log, the step-summary diagnostics block, and the comment it posts now carry the engine’s failure cause — the result subtype and terminal reason, an API-retry error, or a rejected rate-limit event — so a usage-limit rejection reads differently from a genuine stall without downloading the transcript. Each standalone failure comment is trimmed to a headline, the cause, and the run link (plus the trigger line on the auto-resume arms), and the review stall backstop headline now reads PRFlow. (#158)
Renamed the /prflow:receiving-code-review skill to /prflow:fix. The skill that checks review feedback before applying it is now invoked as /prflow:fix; its description still contains the text receiving-code-review so a search by the old name still finds it. The old command name stops resolving in this release — there is no forwarding shim. A consumer who customized the extension keeps it working: the extension loader, asked for fix, reads a still-present .prflow/prompt-extensions/receiving-code-review.md when fix.md is absent and prints a breadcrumb telling you to rename the file, and /prflow:init (and install.sh) rename it to fix.md on an existing repository. Rolling the plugin back to a pre-rename version after init has renamed the file leaves the old skill reading an empty extension until you rename the file back. This release does not migrate consumer-side references to the old command that live outside the plugin — permission rules, hooks, scheduled commands, and any text in your own CLAUDE.md that names /prflow:receiving-code-review should be updated to /prflow:fix by hand. (#152)

September 2, 2026

Warn at install time when a preserved guarded workflow’s sidecar merge would strand the cloud implement gate. When install.sh --apply preserves a locally-modified guarded artifact (the lint manifest, the setup-project-env action, or .github/workflows/devflow-implement.yml), the PRESERVED line now states that .prflow/install-state.json is bound to the kept bytes and that the installer must be re-run in apply mode after the sidecar is merged or adopted, and the apply prints one summary line naming every such sidecar and the exact re-run command. The cloud provisioning readiness refusal for a guarded digest-mismatch now names a merged or adopted .prflow-new sidecar as a cause, and the install and cloud-run docs carry the re-run-in-apply-mode step. (#92) Reconcile the create-issue fresh-context audit’s criterion-shape dimension with the issue template, and bring out-of-scope and Quiet Killer observations into the audit ledger.

The audit prompt’s criterion-shape dimension no longer flags a qualifier that a drafter correctly wrote inside a criterion: a statement narrowing, bounding, quantifying, defining a term for, or naming a verification route for a criterion is never a finding when it repeats across criteria or when an identical copy also sits in the grounding block, and the dimension’s flag toward the block is limited to pure framing whose deletion changes no criterion’s truth value. A block statement that disagrees with the inline qualifier stays a finding. The authoring-discipline RESTATEMENT shape excludes those inline copies, the issue template is the single canonical statement of the rule, and the steelman reference points at it rather than restating it. The auditor now reports every out-of-scope observation on a targeted round, and a qualifying Quiet Killer on any round, as an ordinary numbered finding under the per-finding bar; an out-of-scope finding carries an out-of-scope tag and changes no per-claim verdict, and Quiet Killer: none stays a non-finding. The per-round --findings-count tally is now defined as the number of findings the auditor returned, checked at adjudication to equal must-revise plus advisory plus invalid: record-return refuses an accepted return that omits the tally (findings-count-required), record-adjudication refuses a round whose recorded tally disagrees with the adjudicated class total (findings-count-mismatch) and emits a tally-unrecorded breadcrumb for a round returned before this change, and the audit summary renders findings_count as none when any completed round carries no recorded tally rather than presenting a partial sum as the total.

Finished the DevFlow→PRFlow rename for the remaining visible names. The implement workpad’s reflection section now reads ## PRFlow Reflections and shows its bullets directly, with no collapsed <details> control. The shipped command workflows now display as PRFlow and PRFlow (implement) in the Actions tab (the reusable runner workflow’s display name is likewise renamed to PRFlow Runner (reusable), though it is retained rather than shipped). The cloud review check-run’s rename to PRFlow Review is reader-side: the in-tree readers and self-exclusion filters now accept both PRFlow Review and the historical Devflow Review, so telemetry on older pull requests keeps working — the workflow that would post the check remains withheld from this release, so no in-tree job emits it today. Records written before the rename keep working: the workpad reader and updater accept both the new heading and the old ## Devflow Reflection. Environment variables, workflow filenames, and command aliases are unchanged. (#112) The context-cost instruments now read the cloud execution-transcript shape, and each cloud implement run records its peak main-thread context and per-phase file-read counts on its telemetry record. A single shared transcript reader in scripts/context_eval_shared.py strips the scrubbed artifact’s leading # DEVFLOW SCRUB CAVEAT line and parses a whole-file JSON array, a whole-file object, or JSONL; the corpus collector now accepts .json files alongside .jsonl and tallies every other suffix. scripts/extract-execution-cost.py adds two harness_cost fields, peak_main_thread_context and phase_file_reads, which flow through the telemetry record into scripts/implement-run-report.py --retro, so the weekly retrospective’s “Implement runtime trends” section reports the trailing-window median and maximum peak context and total phase-file reads. Records written before this change lack the two fields and are excluded from those aggregates (recorded as unestablished, never zero). These are instrument outputs only — no threshold, ceiling, regression rule or gate reads them.
New opt-in weekly scheduled retrospective workflow. A new shipped workflow, devflow-retrospective.yml, runs /prflow:retrospective-weekly automatically every Sunday at 05:23 UTC and on manual dispatch from the Actions tab, so the self-improvement loop keeps running without anyone remembering to start it. It is gated by a new per-workflow config key, workflows["prflow-retrospective"], read from the default branch’s .prflow/config.json: only the JSON boolean true enables it, so repositories are opted out by default and pay no Actions or Claude cost until they opt in. When an unmerged devflow/learnings-* state PR is still open, the run skips the retrospective and files a single reminder issue to merge it first. (#93)
/prflow:init now installs the cloud-tier workflows, not just the config. After scaffolding .prflow/config.json, init runs the installer to place the .github/workflows/ files whenever the config enables a workflow tier, so a repository whose config says the cloud tier is on no longer ends up with no workflows on disk. When no tier is enabled it asks first, and whenever it installs it points you at the .github/ diff to review before committing. (#124) Finish the DevFlow→PRFlow brand rename by sweeping the remaining “DevFlow” brand prose in comments, docs, skill bodies, prompt extensions, and test files to “PRFlow”, draining lib/test/brand-devflow-buckets.json’s pending_sweep_baseline to empty. Occurrences that must stay “DevFlow” — the superseded provenance-label value that selectors still match, and the brand-sweep lint’s own fixtures — are recorded in their frozen buckets. Remove every $? from the shipped bash fences under skills/ and agents/ — the cloud permission matcher refuses any command carrying a parameter expansion, so a status trailer such as ; echo "seed-rc=$?" was silently refused and burned a round trip. Each status-trailer site now ends in a constant trailer ; echo "<name>-done" (a measured-permitted ;-joined sequence with no expansion) and its prose routes on the tool result; each VAR=$? capture becomes the bare command routed on its own output, or an if/then/else block where control flow needs it. The worktree-fence lint (lib/test/lint-worktree-fence-shapes.py) now applies its $? rule to every tracked skills//agents/ file, enumerated from git ls-files with no baseline of tolerated hits, so a reintroduced $? fence turns the suite red. The cloud grounding block gains a refused-shape row naming the argument-position simple_expansion refusal and a 2> stderr-redirect row, and no longer attributes simple_expansion to a leading assignment.
Route the light cloud jobs onto a cheaper runner with the new optional DEVFLOW_LIGHT_RUNNER variable. The comment-driven workflows previously ran every job — including one-core helpers and the model-API-bound standalone review — on the single runner named by DEVFLOW_RUNNER. Set DEVFLOW_LIGHT_RUNNER (a bare label or a JSON label array, same shapes as DEVFLOW_RUNNER) and the light jobs move to it: config, review_dedupe, gate, review_finalize, and the command job on a standalone /prflow:review in the review workflow, plus config and gate in the implement workflow. A review-and-fix run and the implement claude job keep DEVFLOW_RUNNER’s 8-core capacity for the test suite. Leave DEVFLOW_LIGHT_RUNNER unset and every job stays exactly where it is today. (#134)
A resumed /prflow:implement run now clears a stale PRFlow:Stuck label and terminal status at the earliest resume hook. When a run resumes an issue whose workpad status is terminal (any of Failed/Cancelled/Blocked/Complete — the stall backstop writes Failed/Cancelled), a shared reset routine resets the status to an in-progress word and — through the existing status-to-label mirror — swaps the managed status label (PRFlow:Stuck, or PRFlow:Complete) for PRFlow:Implementing on the issue and its open pull request. On the cloud tier this happens on the config/gate resume branch before the agent job starts; on the local/interactive tier at the start of Phase 1. The resume-kind classification stays correct by reading the prior terminal status from a durable workpad marker. (#137)

September 1, 2026

/prflow:create-issue now names the recovery when the post-approval create path refuses on a run with completed audit rounds. After the user elected Create it as-is, the state owner could refuse with no stated remedy: the unaudited-revision eligibility answer wrote nothing to stderr, and record-creation-epoch --round 0 refused without naming which round to pass. Both refusals now name their own recovery — the unaudited-revision refusal points at the user’s own record-override --kind user-decline --surface step4-offer filing election (and a fresh clean audit round as the alternative), and the --round 0 refusal on a completed-round state names the newest completed round as --round <M> for the caller to re-issue. The shipped create-issue references state the rules these recoveries follow, so a run that trusts the references files the issue instead of stalling. (#82) Trust established docs-verify results in /prflow:create-issue Step 1, and gate guard claims behind a machine-graded Verified: bullet.

The Step 1 shallow→deep escalation predicate no longer escalates on an ABSENT doc-reliability verdict: ABSENT is an established absence the shallow arm has already produced, so the trigger set is now exactly UNRELIABLE, an unestablished duty, and a judged-not-engaged duty whose bearing observation is anything other than none-observed. The docs-verify duty-status contract now states that a duty carried out with an empty result is discharged (not judged-not-engaged, which is reserved for a duty not carried out), and its Search space surveyed report field now states the resolved internal-doc location beside the --search-space operand so Step 1 can escalate an exact operand and population identity duty when the peer surveyed a location differing from the orchestrator’s own .docs.internal resolution. An acceptance criterion resting on an authorization-guard, permission-key, or gate-condition claim about existing code must now carry a Verified: bullet that scripts/check-verified-premises.py grades handle=path-quote state=holds, so a solo peer’s guard claim cannot become a requirement unverified.

The /prflow:create-issue audit summary now names which round its per-class counts describe. The audit state tool emits a new counts_round token — the round number of the latest completed whole-draft round the class counts (must_revise, advisory, invalid, unresolved-at-close) are read from — on both its summary-block and query-summary lines, and the Step 4 audit summary line labels those counts with that round and says when a targeted re-check also ran. A two-round run that ran a targeted re-check no longer reads as one that lost its second round. Selection is unchanged: the counts still describe the latest whole-draft round, and a targeted round is still skipped. (#73) check-verified-premises.py now grades the Verified:-bullet shapes the issue templates actually produce. A bullet that cites a repository path and carries a backticked code literal (with no double-quoted sentence) is graded on that literal — a hit reports holds, a miss unestablished and never refuted. An absent weak span no longer short-circuits a bullet that also cites a present path; the resolving quotation is adjudicated and the absent span is disclosed. A `Verified:` label (backtick after the colon) is now consumed whole and grades like the bare label. The premises quality group and the Step 3.5 handle-repair table name a prose form for the two shapes the checker cannot grade — an externally verified fact (Per <URL>, checked <YYYY-MM-DD>: <fact>) and a documentation-absence claim — so authors write them correctly from the start instead of demoting a verified fact mid-gate, and the implement-side audit re-fetches those Per <URL> sentences rather than re-litigating them as unverified. Enforce the title-heading and staged-path contracts of the create-issue staged canonical-draft write (issue #79).

stage-draft-write.py stage now refuses stdin whose first two non-blank lines are both # title headings with a duplicate-title breadcrumb, so a re-stage that doubles the draft title can no longer reach a created issue, and it resolves a relative --path base to an absolute path (refusing a rooted drive-less base on a Windows-style module with staged-base-driveless) so the printed path= is accepted by record-staged-write --path unmodified. The stage --help, emit-body --help, and the Step 3.6 staged-write procedure and posting-recipe prose now state these contracts.

August 30, 2026

/prflow:specs now works as a spelling of the issue-drafting command. It runs the same pipeline as /prflow:create-issue, which keeps working unchanged — no existing invocation breaks, and nothing needs updating in a repository that already uses the older spelling.
An interrupted /prflow:implement run resumes from its own pushed work. A fresh run interrupted during implementation — after its checkpoints had pushed, but before the draft pull request opened — used to stall when re-triggered, because it could not tell its own branch from an unrelated one. It now recognizes that branch and continues where it left off. The guard that refuses a branch carrying foreign history is unchanged.
/prflow:implement works again in an isolated worktree. Two commands were refused by Claude Code’s worktree-isolation classifier, which left the run’s marker file empty and its session guard blocking every session in that checkout. Both now run through bundled helpers that read what they need from their own environment rather than from a shell variable.
Fix-loop subagents can no longer land a commit on the wrong branch. They are barred from switching the checkout, and the branch is verified after each one returns — a mismatch stops the loop instead of committing.
A cloud implement run records the branch it is working on. The workpad’s branch line could silently stay at its placeholder, because the command that filled it in was refused before it ran. It is now resolved directly, and reports a named reason instead of writing nothing when it cannot be determined.
Reviews finish faster. Review subagents no longer launch the project’s test suite — a verifier settles a claim about a test by reading that test’s source, and says so explicitly when reading cannot settle it, leaving suite evidence to the run itself. Separately, later fix-loop iterations reuse the verification checklist from earlier ones instead of re-deriving it. Review coverage is unchanged by both.
A complete review is no longer reported as “Review failed” over a missing bookkeeping line. The evidence gate now reads the artifacts each review actually writes, so a review that did its work keeps its verdict even if the reviewing agent omitted a progress line.
Four shipped tools report a clean not-applicable result in a consumer repository. They each detect that a required development-tree input is absent, print one message naming it, and exit successfully — instead of a raw traceback or a misreported integrity failure. Behavior inside a PRFlow development tree is unchanged.
Comment traffic that can never start a command no longer starts a workflow run. Both shipped command-listener workflows now decide this before any job spins up, so unrelated comments on issues and pull requests stop consuming Actions minutes.
The auto-mode provisioning step was removed from /prflow:init. The optional, consent-gated step that made the auto permission mode selectable in the Shift+Tab cycle is retired. It only ever affected the third-party model providers (Bedrock, Vertex, Foundry) and was already a no-op on the Anthropic API. If you previously opted in, your existing ~/.claude/settings.json value is left untouched.

August 29, 2026

/prflow:create-issue asks one fixed decision question, and tells you how the last audit went before offering another round. The pre-approval question now has fixed options — run an audit round, print the full draft in chat, create it as-is (or file anyway, its own option, when unresolved audit findings stand against the draft), or change something first — asked through your runner’s question tool. A re-offered audit round states the previous round’s verdict, findings by class and what remains unresolved, so the choice is informed. Clarification questions never offer “let the implementer choose” as an answer, and the no-options gate no longer flags an “or” inside a negation or a list.
A pull request from a fork can pass the release verification check. Artifact verification is skipped for an ordinary pull request, because the digest manifest describes the published release and any edit is a mismatch. That exemption was gated on the pull request coming from the repository itself, so a contribution from a fork was verified against the manifest instead and failed on every file it changed — an outside contributor saw a red required check they could do nothing about. Origin no longer decides it. A release candidate is still verified whatever its origin, and a fork that touches the verifier is still refused.
A published tree carrying no provenance is refused. The guard that rejects a missing .release/source.json keyed on the branch name alone, and a push carries the branch name main rather than a release branch name — so deleting that one file reported the whole check as passing, on the published branch as well as on the pull request that removed it. A push without provenance, and a pull request that deletes provenance the branch it targets carries, are both refused now.
/prflow:create-issue now prints the drafted issue in chat only on request, keeping the saved-file path as the default presentation. Step 4 writes the draft file and shows its path, the audit summary, the disclosures and the investigation record first — without the body — and the combined decision question carries a new print the full draft in chat answer that renders the title and body verbatim on demand. A write-failed run, an unbound draft, and a non-interactive run still print the body as before. Approval stays explicit and about the exact saved bytes. (#2122)
PRFlow’s public repository is now a generated distribution tree. Development moved to a private canonical repository, and every file published here is produced by a deterministic exporter and verified before release. Nothing about installing or using PRFlow changes: the install commands, marketplace name, plugin name, command names and repository URL are all unchanged, and existing installations and version pins keep working. The published tree is smaller and easier to review, and each release now carries its own provenance under .release/ — a source-commit record and a SHA-256 for every published file, so any published tree can be checked against the digests it ships with.
Installer and documentation links now point at the public documentation site. Messages from install.sh and SECURITY.md that previously referenced maintainer-only documentation paths now link to the equivalent pages on the documentation site, so a reader can always reach them.
The documentation site deploys again. The frozen-DEVFLOW_* advisory moved into the published cloud-setup page, and it carried its generated region’s HTML comment delimiters with it. The documentation site parses those pages as MDX, which rejects an HTML comment outright, so the deployment failed and the site kept serving its previous build. The region’s markers are now MDX comments and the docs build validates clean.
Release verification covers two surfaces it previously skipped. SVG files are text and can carry anything, but were absent from the scanned set, so images shipped unexamined. The documentation navigation manifest is JSON, so the markdown link checker never read it — a navigation entry pointing at a page that no longer ships would have published a broken site. Both are now checked on every release, each proven against a planted defect.
The release verification check could be bypassed by a pull request from a fork. The exemption that lets a maintainer change the verifier keyed on the branch name, and a fork chooses its own branch names — so a fork branch named policy-update/… skipped both the judge-comparison and the artifact verification, and reported the required check green on a tree that had never been verified. The judge-comparison step’s exemptions are now gated on the pull request coming from the repository itself, so a fork can never introduce or edit the verifier that judges it.
The shipped workflows now declare a least-privilege floor. They carried no top-level permissions:, so in a repository whose default workflow permission is read-and-write, every job received a full read-write token whether it needed one or not. They now default to contents: read, and the jobs that genuinely need more continue to declare it.
The implement workflow’s gate job pins its checkout to the default branch, matching its sibling. Without the pin, actions/checkout falls back to GITHUB_REF silently, leaving the trusted-tree property inferred from the trigger rather than stated in the file.

August 28, 2026

Catch vacuous preservation tests and documentation-scope leaks earlier. Implement runs now require distinguishable preservation fixtures, classify cleanup failures, and stop plain label-and-em-dash issue peers from becoming mandatory documentation. (#2110)
Mirror the implement run’s status onto issue and pull-request labels. Every /prflow:implement run now keeps a managed status label in sync on its issue, and on its pull request once one exists, so a maintainer sees a stalled or finished run from the issue and PR lists without opening the workpad comment. Three labels track the workpad Status: PRFlow:Implementing (a run is in progress), PRFlow:Stuck (a run stopped and needs attention), and PRFlow:Complete (a run finished). The labels follow the workpad status automatically — applied even on the statuses written after the agent has already stopped — and a repository turns the whole feature off with the status_labels.enabled config key (on by default). (#2117)

August 27, 2026

Implement runs author tests in proportion to the change. On a small change, an /prflow:implement run can now skip extra test ceremony that would be out of proportion to the change, while still writing a covering test for each behavior change and recording what it waived on a Test authoring waived: line in the pull request’s Test Plan. The coverage reviewer honors a recorded waiver — lowering only lesser-severity findings on the named surfaces while keeping its most serious findings at full strength — and a fresh install runs that reviewer only on the first fix-loop iteration. You get this through the normal plugin update. #2031
Improvement: /prflow:implement runs reach the coding phase sooner. The pre-coding issue-claim audit now delivers all of its per-pass records to the run’s workpad in one batched update at the end of the audit (plus one further call in the uncommon case where the records span more than one reflection kind), instead of a separate network write as each pass completes. Runs spend less time in the pre-coding phase and cloud runs hold their Actions slot for less time, with the recorded workpad content unchanged. You get this through the normal plugin update. #2018
Cloud review jobs fail when a review skips its own checks. A cloud /prflow:review or /prflow:review-and-fix run that posts a merge-gating verdict without evidence that the review engine ran its verification phases now turns the job red, dismisses the unbacked review, and leaves a comment naming what is missing. A review that legitimately skips the checklist stays green, and a compliant run behaves exactly as before. You get this by re-running the installer to refresh your workflows. #2075

August 25, 2026

Improvement: Issue-implementation runs start with verified lint tools already installed. The installer now ships a lint manifest and publishes a digest-bound compatibility marker to your repository, and /prflow:implement cloud runs install the pinned ShellCheck and Ruff set — run-local and digest- and version-verified — before the agent starts, so runs no longer spend paid turns rediscovering and installing those tools. The change also hardens the cloud review job so it can never execute the environment-setup action edited in the pull request under review. You get this by re-running the installer to refresh your workflows. #1963
A completed /prflow:implement run can no longer silently leave a prompt-extension record unwritten. Each run keeps one prompt extension resolved: … row per extension it consumes, and an unticked row is meant to be the run’s deliberate record that it could not establish that extension’s state. But ticking the row was a voluntary bookkeeping step, so a run that resolved an extension and simply forgot to record it produced the exact same unticked row as one that genuinely skipped it — and nothing caught the difference. Finalizing a run as Complete is now refused (naming each offending row) while any such row is both unticked and missing its state not established note, mirroring the existing refusal on an unticked acceptance criterion. A ticked row, an unticked row with that note, and an older workpad that predates these rows all still finish normally, and Blocked/Failed outcomes are unchanged. The effect is that an unticked extension row on a completed run is now trustworthy as a deliberate record rather than a possible oversight. You get this through the normal plugin update. #1943
Fix: a review no longer runs against a partly loaded review engine. /prflow:review-and-fix — and the review step inside /prflow:implement, which drives it — reads PRFlow’s review engine from your repository as a file, and it used to accept whatever came back as long as it was readable. A file delivered in part was therefore indistinguishable from a whole one, so a run could assess your pull request against review stages that never arrived and still report a result. The run now confirms it reached the end of that file before acting on it, and where it cannot it stops with engine-root: incomplete and the path it read, having applied no fixes and produced no verdict. The shadow pass reads the engine the same way and reports the condition as a coverage gap rather than stopping; a review started with /prflow:review loads the engine through your client instead of reading it as a file and is unaffected. You get this through the normal plugin update. #1603

August 19, 2026

Fix: two Windows-only failures in PRFlow’s Python helpers are closed. On a Windows host whose default codec is not UTF-8, a first-party helper that printed an em-dash or emoji used to crash with an encoding error; every tracked helper now forces its output to UTF-8 on startup, so that output prints cleanly. Separately, the issue-audit step rejected a Windows drive-letter path (C:/Users/… or C:\Users\…), blocking /prflow:create-issue’s audit on Windows; the path check now accepts the absolute path forms the host actually uses — a leading / on Linux and macOS, or a drive-letter (C:/…, C:\…) or network-share root on Windows — and uses it unchanged. Linux and macOS are unaffected. You get this through the normal plugin update. #1762

August 14, 2026

/prflow:create-issue now writes a minimum-sufficient implementation brief. The issue body carries the decisions an implementer cannot safely derive on their own and keeps material only when removing it could change what gets built; the investigation behind those decisions — supporting evidence, audit history and detail the repository would rediscover during implementation — is recorded separately instead of being mixed into the body. So an approver reviews the implementation contract rather than the whole investigation, and an implementer spends less effort separating decisions from derivation. A Verified: premise stays in the body when the implementation relies on it and moves to the record when it is only confirmatory, and the over-retention audit flags a repeated claim only when no consumer or check needs that copy — it never touches the required projections or machine-read sections. No length, size or criterion-count limit decides what survives, and no load-bearing detail is dropped to make the body shorter. You get this through the normal plugin update. #1676
Fix: /prflow:create-issue no longer dies when your client lacks its first-choice task-tracking tool. The workflow tracks its own progress through a seven-step checklist, and it used to reach for one particular tracking tool and stop dead if your client did not offer it — reporting an error such as No such tool available after it had already told you the checklist was set up. It now tries the tracking tools it knows in order, moving to the next one whenever the one it tried is unavailable, and asks your client for tools it has not yet offered before giving up. If none of them work, it keeps the same checklist inline in the conversation instead, so the run continues either way. It also announces the checklist only once it genuinely has one, and reports any tool it could not use just after that first line rather than in place of it. Clients that already offered the first tool behave exactly as before. You get this through the normal plugin update. #1689
Fix: /prflow:implement reliably records its cleanup gate on Windows Git Bash and MSYS2. During implementation, /prflow:implement ticks a Progress row when its code-cleanup gate finishes. On Windows Git Bash and MSYS2 hosts, the value it passed to do that looked like a Unix path, so those shells silently rewrote it into a Windows path before it reached Python — the row stayed unticked and the run reported a spurious miss. The gate now passes a plain, non-path value that those shells leave alone, so the Progress row is ticked as expected. Nothing about the row’s familiar label changes, and other platforms were never affected. You get this through the normal plugin update. #1679

August 13, 2026

An issue can now say “no documentation is needed” without turning a page it mentions into required work. When you write an issue, its Documentation Needed block can list files that the change must update, and /prflow:implement treats every file named there as a mandatory deliverable. Previously, if you wrote that no documentation was needed and then named a file to explain why it was already fine, that mentioned file was still demanded — so the honest, informative phrasing was punished and an otherwise-finished run stalled asking you to edit a page that needed no change. You can now open the block with the standalone word none (case-insensitive, optionally followed by a single , . ; or :), and the block promises nothing — you can still add a sentence and name the page that explains the decision. The word must stand alone as the block’s opener: an ordinary sentence such as None of these pages may be skipped: still names its files as required. The routine documentation pass runs and updates whatever the change warrants regardless. #1663
Fix: Implement review progress stays on the issue workpad — An inline review-and-fix pass no longer opens a separate progress comment on the draft pull request during /prflow:implement; its review stages update the existing issue workpad instead. A standalone pull-request review still maintains its own live progress comment. #1668

August 12, 2026

Improvement: Acceptance Criteria Now Cover Every Desired Outcome — PRFlow now checks that every independently testable outcome in an issue’s Desired Behavior is represented by its acceptance criteria before implementation begins. If an outcome is uncovered, issue creation revises the draft and implementation stops for refinement instead of silently omitting the requirement or inventing a criterion. #1662
Weekly retrospectives no longer treat a cancelled CI run as a failure, and no longer miss failures on large CI matrices. The retrospective decides whether a merged pull request needs a full model analysis partly from how its CI went. A run that was cancelled or superseded — which is what happens to the in-flight run every time you push again — was being counted as a CI failure, so ordinary iteration pushed healthy pull requests into paid analysis. In the other direction, only the first page of check results was being read, so a repository with a large CI matrix could have real failures go uncounted. Cancelled and superseded results are now excluded, all pages are read, and any result the check does not recognize still counts as a failure rather than as a pass. When the check results cannot be read at all, the pull request is still analyzed rather than assumed clean, and the reason is now named in the output. You get this through the normal plugin update. #1441
/prflow:implement now looks for reusable code by what it does, not by how you were about to write it. Before writing new code, /prflow:implement searches your codebase for something that already does the job, so it can reuse it instead of reinventing it. But once a run had settled on how it was going to write the code, it naturally searched for that exact shape — a search that could only ever confirm the choice it had already made. An existing helper that did the same job in a different style matched none of those terms and stayed invisible, and the run recorded the empty result as if it had proven nothing existed. The reuse search is now keyed on the job itself — the operation it performs, the kind of data it handles, the thing it works on — and before running it the run checks that the search would actually match a different-looking implementation of the same job, re-keying it if it would not. An empty result is now recorded as “nothing matched what I searched for” rather than as a bare claim that nothing exists. The practical effect is fewer near-duplicate helpers introduced by a run. You get this through the normal plugin update. #1635
/prflow:implement and /prflow:review now start reliably on runners that refuse a routine command. Both commands locate their own skill files at the very start of a run. They did that by running a small shell command that prints a directory path — and on some runners (for example Copilot CLI, and one hosted configuration) the permission layer refuses that exact command shape, even when the command itself is allowed. The old rule only described what to do when the command ran, so a flat refusal fell through the cracks: depending on how it was read, the run either stopped at its first step or quietly carried on having skipped it. Both commands now take the skill directory from the location the runner already reports in context first, and only fall back to that shell command when the runner reports no such location. A refusal of the fallback is now handled as its own distinct outcome — the run either finds the directory another way or stops and says the anchor could not be resolved, never skipping the step silently. You get this through the normal plugin update, with no workflow file to re-copy and no permission to add. #1594

August 11, 2026

Your prompt extensions now survive a long run rather than being lost partway through. PRFlow fetches .prflow/prompt-extensions/<skill>.md at the start of a run, but on a long run that fetch is delivered as ordinary command output that can be dropped from the agent’s context, leaving the rest of the run applying none of your policy — a run has completed and reported success with the extension absent throughout. The skills that re-enter their own stages now re-fetch your extension at each of those boundaries as well as at run start: /prflow:implement at every phase entry and mid-phase re-anchor, /prflow:review at every phase and shadow entry, and /prflow:review-and-fix once per fix iteration (for both its own extension and receiving-code-review.md). A run that loses your policy to context eviction now recovers it instead of continuing without it, and a re-fetch that is refused or fails is reported at that point rather than passed over. /prflow:pr-description is a single-pass command and is unchanged. This is a reliability recovery, not a change to how you author extensions. #1574
An acceptance criterion is no longer ticked on the word of a check that was never fully carried out. Before /prflow:implement ticks a criterion, two independent checkers look at it in fresh context and their two answers are reconciled — but each one reported only its conclusion, so a checker that skipped part of its own procedure and still answered “satisfied” was indistinguishable from one that did the whole thing, and the criterion was ticked. Each checker now also states, step by step, what it actually did: for every named step of its own procedure it records yes or no with a one-clause reason. A stated no is a perfectly acceptable answer and changes nothing on its own — what is not acceptable is saying nothing. A criterion where either checker left a step unstated is now treated as unverified and blocks, even when both checkers said “satisfied”. The statements are recorded on the workpad alongside the verdict, so after the run you can see which steps were performed rather than only what was concluded. The practical effect is that a run is more likely to stop and tell you a criterion was not properly verified, instead of quietly ticking it. #1580

August 10, 2026

A review no longer downgrades a real coverage gap because the gap was described in a comment. Before a review computes its verdict, it caps a finding whose only effect is on wording that cannot change what the program does, so a cosmetic wording nit never blocks a merge. That test read as if it were about the kind of line the finding pointed at, so a finding that a check audits too small a population, that a guard misses an exception or that a validation misses a type could be capped at Suggestion whenever the gap happened to be described in a comment or docstring — a real defect reported as a minor note. The cap is now decided by what the finding is about: if the finding disputes what a mechanism covers, it is graded on that functional gap and never capped, whether or not the change touched the line. A genuinely cosmetic wording nit is still capped exactly as before. #1455
A rewritten progress comment no longer loses the hidden lines that identify it. PRFlow’s review progress comment and implementation workpad each begin with hidden marker lines: one identifying which run owns the comment, and, on a review, one recording the verdict and the commit it was issued against. A step that rewrote the whole comment body composed those bytes from what it was holding, so a step that did not retype the markers dropped them — and nothing reported an error, because a later reader looking for a marker found none and read that as “there was no such comment”. The visible effect was a review that appeared not to have happened, or a second workpad opened beside the first. A whole-body rewrite now re-inserts any leading marker line it omits, keeping the live comment’s order while letting a marker the step does supply win, so a re-stamped verdict still lands. When PRFlow cannot read the live comment to establish which markers it carries, it proceeds only if the new body already carries its own leading marker, and otherwise refuses the write rather than risk dropping one. #1508
An issue’s Documentation Needed files are now actually enforced by /prflow:implement. When an issue names files that must be documented, the run is supposed to name them to its documentation pass and then check each one against the pull request’s diff before ticking Documentation. Both checks read the file list from a shell variable that does not survive between the run’s commands, so the list arrived empty: the documentation pass was never told which files were mandatory, and the diff check compared against nothing. The read is now a single command that prints the file list, so the run reads it from the command’s output and both checks see the files the issue named. A read that fails — the issue body could not be fetched, or the list could not be extracted — now stops the run with a recorded reason instead of being treated as “no files were named”. Cloud installations should re-run the installer with the new tag rather than bumping prflow_version alone; taking only one half stops the documentation gate rather than silently skipping it — see Cloud Updates. #1554

August 9, 2026

Your prompt extensions are now fetched unconditionally, and an implementation run records what it resolved. The August 5 change delivered .prflow/prompt-extensions/<skill>.md as prompt text prepared before the run starts, and demoted the older in-run load to a fallback taken only when that preparation had not delivered. On hosted runs the preparation is refused silently, and a run could then skip the fallback and complete having applied none of your policy — reporting success with nothing to distinguish it from a run that had applied all of it. Both channels now run every time, at all four skills that consume an extension: /prflow:review, /prflow:review-and-fix (its own extension and receiving-code-review.md), /prflow:implement and /prflow:pr-description. There is no longer a condition a run can decline to evaluate, and where both channels deliver they carry the same content. A /prflow:implement workpad’s Progress checklist also gains one prompt extension resolved: … row per extension the run consumes, written whether or not the run cooperates; an unticked row is that run’s own record that it did not establish that extension’s state. A workpad created before this change has the rows repaired in on the next run that resumes it. #1462

August 8, 2026

/prflow:create-issue no longer stumbles through its pre-filing audit. The audit step follows a documented order of operations, and that order left out two steps the audit itself requires: reading the round’s kind that the dispatch will not accept without, and recording the staged draft write the dispatch depends on. A run following the written order was therefore turned away — twice per round on the file arm a clean run takes — and had to recover before it could continue, which showed up as wasted turns and stray error output during issue creation. The written order now names those steps, and presents the final review-and-create steps in the order they actually run. No behavior of the audit changed — only the instructions the run follows, which now match it. #1466

August 7, 2026

/prflow:review-and-fix no longer re-raises a finding the previous pass already recorded. Before it approves, the fix loop runs one more independent review and compares those findings against the pass before it. A finding that names a whole file rather than a specific line range — the form used when a defect has no single location, such as a missing test file — was compared under a narrower rule than the review engine’s own, so it read as brand new even when the previous pass had already recorded it. That spent an extra fix iteration, and at the iteration cap it could reach you as APPROVE WITH UNRESOLVED SHADOW FINDINGS on a finding that was not new. The comparison now applies the engine’s own matching rule instead of a restatement of it. The same change repairs a pointer in the loop’s severity-calibration gate that named the wrong file for the definition it cites. #1406

August 6, 2026

A review’s progress checklist now shows whether the run actually delivered its verdict. The checklist gains a final item, Run complete — everything this run owed. On /prflow:review it is ticked only after the verdict reaches a durable channel — the formal GitHub review, or a marked comment when the review could not be posted. Previously a run could finish aggregating a verdict, tick its last item, show a finished status, and then deliver nothing, leaving a checklist that read complete either way. Such a run now leaves that item unticked and states why, and it makes one bounded attempt to complete the missing delivery before it ends. On /prflow:review-and-fix, which posts no verdict to GitHub, the item is ticked when the fix loop reaches its terminal work. A ticked item means a durable verdict exists; it does not by itself mean the pull request carries an approve or request-changes merge signal. #1367

August 5, 2026

Your prompt extensions now reach review and implementation runs every time. .prflow/prompt-extensions/review.md, review-and-fix.md, receiving-code-review.md and implement.md are delivered to the agent as prompt text prepared before the run starts, instead of depending on the agent choosing to load them mid-run. Previously the extension reached the agent in only 8 of 18 sampled review runs and 1 of 4 sampled implementation runs, and a run that never loaded your policy still posted an ordinary verdict, so nothing distinguished it from one that had. If an extension cannot be delivered, the run now says so explicitly rather than proceeding as though you had configured none. An absent or empty extension is still a silent no-op. Cloud installations should re-run the installer with the new tag rather than bumping prflow_version alone — see Cloud Updates. #1264
/prflow:create-issue now writes a short implementer brief and keeps the investigation detail in a separate comment. The issue body carries only what an implementer needs to build the change — what is broken, what “done” looks like, which files to start in, which hazards matter. Rejected designs, supporting evidence, deliberation and lower-severity notes are posted as a separate investigation-record comment on the same issue (with any workflow-trigger tokens neutralized so it cannot start a run). Set the new create_issue.investigation_record_enabled config key to false to skip posting that comment; the brief-versus-record sorting is unchanged either way. #1331
Cloud review comments now use a safer event boundary. Post /prflow:review on the pull-request conversation tab. Commands entered in the review-submission box or an inline diff comment no longer start a run. Cloud jobs also check out the repository’s default branch before they read trusted configuration. #1163

August 3, 2026

Numerical acceptance criteria now name their measurement. PRFlow records the exact command or counting rule behind a threshold. If it cannot establish that measurement, it labels the criterion as unestablished instead of presenting an ambiguous number. #1223

Older Releases

Entries from July 2026 are in the release notes archive.

​Release Notes

​October 26, 2026

​October 25, 2026

​October 24, 2026

​October 23, 2026

​October 22, 2026

​October 21, 2026

​October 20, 2026

​October 19, 2026

​October 18, 2026

​October 17, 2026

​October 16, 2026

​October 15, 2026

​October 14, 2026

​October 13, 2026

​October 12, 2026

​October 11, 2026

​October 10, 2026

​October 9, 2026

​October 8, 2026

​October 7, 2026

​October 6, 2026

​October 5, 2026

​October 4, 2026

​October 2, 2026

​October 1, 2026

​September 30, 2026

​September 29, 2026

​September 28, 2026

​September 27, 2026

​September 26, 2026

​September 25, 2026

​September 24, 2026

​September 23, 2026

​September 22, 2026

​September 21, 2026

​September 20, 2026

​September 19, 2026

​September 18, 2026

​September 17, 2026

​September 16, 2026

​September 15, 2026

​September 14, 2026

​September 13, 2026

​September 12, 2026

​September 11, 2026

​September 10, 2026

​September 9, 2026

​September 8, 2026

​September 7, 2026

​September 6, 2026

​September 5, 2026

​September 4, 2026

​September 3, 2026

​September 2, 2026

​September 1, 2026

​August 30, 2026

​August 29, 2026

​August 28, 2026

​August 27, 2026

​August 25, 2026

​August 19, 2026

​August 14, 2026

​August 13, 2026

​August 12, 2026

​August 11, 2026

​August 10, 2026

​August 9, 2026

​August 8, 2026

​August 7, 2026

​August 6, 2026

​August 5, 2026

​August 3, 2026

​Older Releases