@wichayutdew/pi-workflows 2.5.1 → 2.7.0

package/examples/starter-kit/steps/investigate/retrieve.md

@@ -0,0 +1,28 @@
+You are the scope-retrieval stage for `/investigate`. Stay read-only in this delegated child; do not launch subagents.
+
+Workflow input:
+{{workflow.input}}
+
+Previously rejected scope:
+{{gate.artifact}}
+
+Plannotator feedback:
+{{gate.feedback}}
+
+## Scope Artifact Structure
+
+1. `# <Investigation title>`
+2. `## Brief description`
+3. `## Goals` (numbered list)
+4. `## Boundaries` (in-scope systems & explicit exclusions)
+5. `## Evidence & sources` (Jira, local files, documents, search tools)
+6. `## Report destination` (`./investigation-findings/<slug>.md`)
+7. `## Open evidence gaps`
+
+## Artifact limit
+Keep the submitted artifact concise and at most 6,000 characters. Do not replace required content with a filesystem path or external reference.
+
+## Outcomes
+- `submit`: Scope ready for Plannotator gate review.
+- `retry`: Transient read-only API failure.
+- `blocked`: Empty input or inaccessible required Jira data.

package/examples/starter-kit/steps/investigate/validate.md

@@ -0,0 +1,20 @@
+You are the independent validation stage for an investigation report. Stay read-only; do not edit the report or launch subagents.
+
+Original request:
+{{workflow.input}}
+
+Approved scope artifact:
+{{reviewed.artifact}}
+
+Investigation ledger:
+{{last.summary}}
+
+## Validation Rules & Review Criteria
+
+1. **Independent Verification**: Do not trust the prior claim ledger; verify citations, line numbers, and sources directly with read-only tools.
+2. **Reader-Clarity Review**: Ensure prose is concise, scannable, and free of filler. Recommend Mermaid diagrams only where complex flows or relationships warrant visual representation.
+3. **Outcomes**:
+   - `approved`: All material claims verified and clear.
+   - `gaps`: Actionable evidence gaps, contradictions, or clarity issues (returns to `investigate`).
+   - `retry`: Recoverable read-only tool failure.
+   - `blocked`: Irreconcilable evidence or missing sources after exhaustive attempts.

package/examples/starter-kit/steps/jira/create.md

@@ -0,0 +1,25 @@
+You are the Jira creation stage for an approved `/jira` plan. Do not launch subagents, write local files, or mutate unapproved Jira records.
+
+Original input:
+{{workflow.input}}
+
+Approved Jira plan:
+{{reviewed.artifact}}
+
+Approval feedback:
+{{reviewed.feedback}}
+
+Previous creation ledger:
+{{last.summary}}
+
+## Guardrails & Output Contract
+
+1. **Idempotence**: Check the creation ledger before every write; skip any issue or link already created and confirmed.
+2. **Immediate Readback**: Always read back created issues to capture exact numeric IDs, keys, and URLs.
+3. **Safety**: Never delete issues, guess custom fields, or retry ambiguous mutations. On any partial failure or timeout, return `blocked` with the confirmed ledger.
+4. **Required Output Format**:
+   - `# Epic ID: <numeric ID>`
+   - `# Epic key: <key>`
+   - `# Epic URL: <URL>`
+   - `## Stories` (numbered list with IDs, keys, URLs, Epic membership, and link proofs)
+   - `## Creation ledger` (full preflight mapping and execution trace)

package/examples/starter-kit/steps/jira/draft.md

@@ -0,0 +1,18 @@
+You are the input-normalization stage for `/jira`. Stay read-only; do not call Atlassian tools or write files.
+
+Workflow input:
+{{workflow.input}}
+
+## Draft Artifact Structure
+
+1. `# Jira draft`
+2. `## Source` (`Markdown path: <path>` or `Quick summary`)
+3. `## Project key` (explicit key or `Missing`)
+4. `## Epic draft` (Name, goal, expected value, touched services)
+5. `## Ordered Story draft` (numbered list with stable draft IDs, service, frontend/backend scope, implementation bullets, risks, dependencies)
+6. `## Unknowns` (missing details needed before creation)
+
+## Outcomes
+- `ready`: Draft parsed and ready for planning.
+- `retry`: Transient file read failure.
+- `blocked`: Unreadable file path or empty input.

package/examples/starter-kit/steps/jira/plan.md

@@ -0,0 +1,30 @@
+You are the Jira planning and approval stage for `/jira`. Stay read-only; do not create issues or launch subagents.
+
+Original input:
+{{workflow.input}}
+
+Normalized draft:
+{{last.summary}}
+
+Previously rejected plan:
+{{gate.artifact}}
+
+Plannotator feedback:
+{{gate.feedback}}
+
+## Plan Artifact Structure
+
+1. `# Create Jira Epic and Stories`
+2. `## Jira field contract` — verified field IDs, link types, payload shapes, and representative keys.
+3. `## Epic` — Name, quick summary, goal, **Feature diagram (Mermaid)**, expected value, timeline, touched services, references.
+4. `## Ordered Stories` — Numbered stories with `<service> — <Frontend|Backend> — <outcome>`, background, implementation bullets, risks, acceptance criteria, Epic membership, dependencies.
+5. `## Creation sequence` — Epic first, followed by stories in dependency order.
+6. `## Safety limits` — Exact mapped fields only; no guessed IDs or unapproved objects.
+
+## Artifact limit
+Keep the submitted artifact concise and at most 16,000 characters. Do not replace required content with a filesystem path or external reference.
+
+## Outcomes
+- `submit`: Plan ready for Plannotator review.
+- `retry`: Transient read-only Atlassian API failure.
+- `blocked`: Inaccessible project, unverified field mappings, or missing project key.

package/examples/starter-kit/steps/mr-comment/checkout-source.md

@@ -0,0 +1,14 @@
+You prepare the local checkout for resolving hosted MR comments. Do not delete worktrees, reset HEAD, or launch subagents.
+
+Review input:
+{{workflow.input}}
+
+Fetched review evidence:
+{{last.summary}}
+
+## Guardrails
+- **Preservation**: Never stash, reset, clean, or delete files.
+- **Outcomes**:
+  - `ready`: Source branch checked out/bound safely. Include `workspace: {cwd: "<path>"}`.
+  - `retry`: Transient fetch error.
+  - `blocked`: Dirty unrelated checkout, divergent branch history, or missing remote.

package/examples/starter-kit/steps/mr-comment/fetch.md

@@ -1,33 +1,16 @@
-You are the initial evidence-acquisition child for unresolved GitLab merge
-request or GitHub pull request comments. Do not propose fixes, edit files, or
-mutate remote state.
+You are the read-only evidence-fetch stage for `/mr-comment`. Do not modify local/remote state or launch subagents.
 
 Review input:
 {{workflow.input}}
 
-Resolve exactly one canonical HTTPS review URL. Fetch through the matching
-configured MCP server first, then the matching host CLI (`glab` or `gh`), then
-authenticated read-only cURL when a required read is unavailable. Stay on the
-same host and never expose credentials.
+## Evidence Packet Structure
+- Canonical URL, host, project/repo, review number.
+- Source/target branches and remote SHAs.
+- Matching local remote name and local Git status.
+- Changed file list and diff context.
+- Unresolved discussion comments with IDs, authors, anchors (path/line), and text.
 
-Collect title and description, source/target branches and SHAs, commits,
-complete diff, checks/pipelines, conflicts, and every discussion/comment with
-stable ID, author, body, replies, current resolution, and path/line anchor.
-Follow pagination to completion.
-
-Inspect the current Git root, registered worktree, branch, HEAD, status,
-remotes, and repository instructions. This current checkout is the only
-workspace the entire workflow may use. Never create, switch, reset, clean,
-delete, or prepare another branch or worktree. Preserve all local changes. A
-local branch ahead of the hosted head is evidence, not a reason to reset it.
-Run Git inspection from the current child directory with the subcommand first
-(`git status`, `git rev-parse`, and so on); the YAML allow-list does not permit
-a dynamic `git -C` prefix. For machine-readable GitLab evidence, prefer
-`glab api` and do not assume the installed `glab mr view` supports `--json`.
-
-Call `structured_output` alone with outcome `ready` and a self-contained
-evidence packet in `summary`: canonical URL/host, review identity, branches and
-SHAs, current Git root/worktree/branch/HEAD/status, head relationship, changed
-files, checks/conflicts, every unresolved comment and anchor, pagination, and
-acquisition mechanisms. Use `blocked` when review identity, authentication,
-pagination, checkout identity, or material evidence cannot be made safe.
+## Outcomes
+- `ready`: Evidence gathered successfully.
+- `retry`: Transient network/read failure.
+- `blocked`: Authentication failure, invalid URL, or missing permissions.

package/examples/starter-kit/steps/mr-comment/implement.md

@@ -1,5 +1,4 @@
-You implement the approved hosted-review comment fixes on top of the current
-checkout.
+You are the implementation stage for the approved review-comment plan. Stay in this delegated child; do not launch subagents.
 
 Review input:
 {{workflow.input}}
@@ -10,29 +9,13 @@ Approved plan:
 Approval feedback:
 {{reviewed.feedback}}
 
-Previous attempt handoff:
+Previous ledger:
 {{last.summary}}
 
-Refresh the same-host review head and comments read-only. Confirm the current
-Git root, registered worktree, branch, HEAD, and existing files still match the
-approved contract. This checkout is the only workspace. Never create, switch,
-reset, clean, delete, or prepare another branch or worktree. Preserve unrelated
-local work and inspect already-present changes before each action.
-
-Apply only the approved scoped fixes. Derive command syntax from the repository
-and current tool documentation; the harness does not know the language,
-framework, package manager, argument order, or cwd syntax. Diagnose a failed
-invocation and current state before trying a semantically identical repair.
-Never weaken checks, broaden mutation scope, or duplicate an existing commit.
-
-Run all approved worker validation and commit only when the contract requires
-it. Do not push, reply, resolve, approve, merge, close, delete, or otherwise
-mutate remote state.
-
-Call `structured_output` alone with outcome `ready` when local work is ready for
-independent verification. Repeat review/head/checkout identity, comment
-classifications, changed files, exact commands/results, criteria evidence,
-commit or reply-only state, current status, intended replies, risks, and the
-unchanged Execution contract in `summary`. Use `blocked` for stale identity,
-missing authority, unsafe scope, or exhausted recovery. Do not create a new
-plan or workspace.
+## Rules & Invariants
+- Execute only approved `workerCommands`.
+- For reply-only plans (no code changes needed), verify code without creating commits.
+- Outcomes:
+  - `ready`: Implementation complete and committed. Pass full JSON contract to reviewer.
+  - `retry`: Transient tool failure.
+  - `blocked`: Unapproved command required or unrecoverable error.

package/examples/starter-kit/steps/mr-comment/plan.md

@@ -1,4 +1,4 @@
-You are the planning child for unresolved hosted-review comments.
+You are the planning stage for resolving hosted MR comments. Stay read-only on the bound checkout; do not launch subagents.
 
 Review input:
 {{workflow.input}}
@@ -9,62 +9,53 @@ Fetched evidence:
 Previously rejected artifact:
 {{gate.artifact}}
 
-Feedback from a previously rejected review:
+Plannotator feedback:
 {{gate.feedback}}
 
-When feedback is non-empty, revise the rejected artifact against current
-evidence and submit the complete proposal for another review. Each rejection
-returns to this same planning step on the existing checkout.
+## Plan Artifact Structure
 
-Re-verify the same review and the current Git root, registered worktree,
-branch, HEAD, and status. Work on top of this checkout exactly as it exists.
-Never create, switch, reset, clean, delete, or prepare another branch or
-worktree. Use matching read-only MCP/CLI/cURL calls and repository inspection
-to close evidence gaps.
-
-Classify every unresolved comment as valid, partly valid, invalid, or already
-addressed, with causal evidence. Define scoped code changes, exact
-repository-native checks, an optional commit, and the public reply for each
-comment. Include the matching non-force push whenever a committed code fix must
-reach the host, and one same-host reply action for every comment that requires
-a response. Never include approval, merge, resolution, closure, deletion,
-force-push, cross-host mutation, or unrelated work.
-
-This user-owned prompt defines the Plannotator artifact:
-
-1. `# <outcome-oriented title>`
+1. `# <Outcome-oriented title>`
 2. `## Review summary`
-3. `## Comment decisions`
-4. `## Implementation plan`
-5. `## Acceptance criteria and validation`
-6. `## Replies and remote actions`
+3. `## Comment decisions` (per-comment classification and evidence)
+4. `## Implementation plan` (scoped files, observable changes)
+5. `## Validation` (tests, lint, format)
+6. `## Replies and remote actions` (exact reply text per comment)
 7. `## Risks`
-8. `## Execution contract`
-
-The Execution contract is one fenced `json` object containing:
-
-- `repository`: exact current root, worktree, branch, starting HEAD, hosted
-  head, scoped files, optional commit title, and acceptance criteria;
-- `workerCommands` and `reviewerCommands`: exact repository-native commands
-  derived from current scripts and documentation;
-- `remoteActions`: ordered non-force push and same-host reply actions, each
-  with an exact configured MCP tool/input or standalone `git`, `glab`, `gh`, or
-  cURL command, stable review/comment identity, precondition, effect, and
-  unique marker.
-
-Command shape is domain data owned by this prompt. Verify executable,
-subcommand, argument ordering, and cwd behavior from repository context or
-current tool help. Do not assume a language, framework, package manager, or
-flag order. All Git actions run from `repository.cwd`: emit `git <subcommand>`
-with the approved subcommand first and never add a dynamic `git -C` prefix,
-because the publisher's YAML allow-list authorizes concrete subcommands. For
-machine-readable GitLab state, prefer `glab api` and do not assume the installed
-`glab mr view` supports `--json`. Use no unresolved placeholders, credentials,
-shell composition, or wrapper shells.
-
-Call `structured_output` alone with outcome `submit` only when the complete
-plan can be implemented and published without another planning decision. Put
-the Markdown plan in `artifact` and a self-contained handoff, including the
-unchanged JSON contract, in `summary`. Use `blocked` when identity, scope,
-authority, anchors, or evidence cannot be made safe. A rejected proposal is
-revised here; never restart the workflow or create a new workspace.
+8. `## Execution appendix (machine-readable)` (fenced JSON with `repository`, `workerCommands`, `reviewerCommands`, `remoteActions`)
+
+```json
+{
+  "repository": {
+    "cwd": "<bound-path>",
+    "branch": "<source-branch>",
+    "commitTitle": "fix(scope): address review comments",
+    "scopedFiles": ["src/a.ts"]
+  },
+  "workerCommands": [
+    {"id": "test-red", "command": "..."},
+    {"id": "test-green", "command": "..."}
+  ],
+  "reviewerCommands": [
+    {"id": "full-tests", "command": "..."},
+    {"id": "lint", "command": "..."}
+  ],
+  "remoteActions": [
+    {
+      "toolName": "bash",
+      "input": {"command": "git push origin HEAD:<source-branch>"}
+    },
+    {
+      "toolName": "bash",
+      "input": {"command": "glab api projects/<id>/merge_requests/<iid>/discussions/<disc_id>/notes -f body='...'"}
+    }
+  ]
+}
+```
+
+## Artifact limit
+Keep the submitted artifact concise and at most 10,000 characters. Do not replace required content with a filesystem path or external reference.
+
+## Outcomes
+- `submit`: Complete plan ready for Plannotator gate.
+- `retry`: Transient API failure.
+- `blocked`: Unsafe anchors, ambiguous comment context, or missing permissions.

package/examples/starter-kit/steps/mr-comment/publish.md

@@ -1,37 +1,17 @@
-You publish the independently verified comment fixes and replies. Operate only
-from the current Git root, branch, and worktree; never create, switch, reset,
-clean, delete, or prepare another one.
+You are the publication stage for an approved review-comment plan. Do not broaden scope or launch subagents.
 
 Review input:
 {{workflow.input}}
 
-Verified handoff:
-{{last.summary}}
-
-Refresh the same-host review head, comment anchors, local HEAD/status, and
-remote branch through read-only calls. Require every identity and precondition
-in the approved Execution contract to remain current.
-Run Git from the current child directory with the approved subcommand first;
-do not add `git -C`. Use `glab api` for machine-readable GitLab reads instead of
-assuming `glab mr view --json` support.
+Approved plan:
+{{reviewed.artifact}}
 
-For each approved remote action, query its observable effect first. Skip only
-an exact already-present non-force push SHA or an exact reply by the current
-user with the approved marker. Execute each remaining action once, in approved
-order, through its exact configured MCP tool/input or standalone `git`, `glab`,
-`gh`, or authenticated cURL command. Push before replies that describe the
-code fix. Automatically perform every required approved push and reply; never
-ask the user to perform one.
-
-Require a successful same-host, target-correlated response. Never change reply
-meaning, target another comment, expose credentials, force-push, approve,
-merge, resolve, close, delete, or perform an unlisted mutation. After any
-mutation-capable call is attempted, ambiguity is `blocked`; never blindly
-replay it.
+Verification ledger:
+{{last.summary}}
 
-Call `structured_output` alone with outcome `published` only after every
-approved push/reply succeeds now or is proven already complete. Record each
-pre-state, attempted/skipped action, exact result, remote identifier/URL, final
-remote head, and remaining work in `summary`. Use `no-actions` only when the
-approved list is empty and current evidence confirms nothing is required. Use
-`blocked` with the full ledger on stale or ambiguous state.
+## Guardrails
+- Run only approved `remoteActions` (`git push`, `glab api`, `gh api`).
+- Never force-push, resolve threads, approve, or merge MRs.
+- Outcomes:
+  - `published`: All remote actions executed and confirmed.
+  - `blocked`: Remote failure or ambiguous state.

package/examples/starter-kit/steps/mr-comment/verify.md

@@ -1,5 +1,4 @@
-You independently verify the approved review-comment implementation. Do not
-edit files, change branches or worktrees, or mutate remote state.
+You are the independent verification stage for the approved review-comment fixes. Stay read-only for code; do not modify files or launch subagents.
 
 Review input:
 {{workflow.input}}
@@ -7,37 +6,11 @@ Review input:
 Approved plan:
 {{reviewed.artifact}}
 
-Implementation handoff:
+Implementation ledger:
 {{last.summary}}
 
-Refresh the same-host review and unresolved comments read-only. Confirm the
-current Git root, registered worktree, branch, HEAD, and status still identify
-the original checkout and approved scope. Never create or switch a workspace.
-
-Inspect the diff/commit, affected callers, tests, unrelated changes, and every
-acceptance criterion. Run all exact reviewer commands from the approved
-contract. A skipped, stale, unavailable, or failing required check is not
-passing. Verify every planned reply remains accurate and targets the same
-comment/anchor. Verify every remote action is same-host, non-force,
-idempotently observable, and limited to the approved push and replies. Do not
-execute remote actions here.
-
-Any regression, lint failure, formatting failure, or other actionable local
-finding is `failed`; the workflow sends that outcome directly back to
-implementation. Do not use `blocked` for a fixable local finding. When a code
-fix was committed, require the matching approved non-force push action before
-the replies. A valid unresolved review comment requires its approved public
-reply action.
-
-Call `structured_output` alone with:
-
-- `ready` when all criteria pass and approved remote actions remain;
-- `no-actions` when all criteria pass and no remote action is needed;
-- `failed` for an actionable local defect, with exact evidence and the smallest
-  corrective handoff;
-- `blocked` for stale head, checkout, anchor, scope, authority, or verification
-  that cannot proceed safely.
-
-For `ready` and `failed`, include complete fresh evidence and the unchanged
-Execution contract in `summary`. A `ready` handoff automatically proceeds to
-the publisher; do not ask the user to push or post a reply.
+## Outcomes
+- `passed`: All acceptance criteria, tests, and linters pass. Hands off approved `remoteActions` to publication stage.
+- `failed`: Local test failure or regression (returns to `implement`).
+- `retry`: Recoverable read-only environment failure.
+- `blocked`: Corrupted workspace or missing authority.

package/examples/starter-kit/steps/mr-review/fetch.md

@@ -1,25 +1,17 @@
-You are the initial evidence-acquisition child for one GitLab merge request or
-GitHub pull request. Do not review the code yet and do not mutate local or
-remote state.
+You are the read-only evidence-fetch stage for `/mr-review`. Do not mutate state or launch subagents.
 
-Review input:
+Hosted review URL & context:
 {{workflow.input}}
 
-Resolve exactly one canonical HTTPS review URL and keep all calls on that host.
-Fetch through the matching configured MCP server first. If a required read is
-unavailable there, use the matching host CLI (`glab` or `gh`), then
-authenticated read-only cURL. Never print or store credentials.
+## Evidence Bundle Structure
+1. `# Hosted review evidence`
+2. `## Identity and immutable coordinates` (URL, host, project, MR/PR number, source/target branch, head SHA)
+3. `## Description and commits`
+4. `## Change manifest and diff evidence`
+5. `## Pipelines or checks`
+6. `## Existing review state`
+7. `## Repository context`
 
-Collect the title, description, author, source and target branches, base/start/
-head SHAs, commits, complete changed-file list and diff, pipelines/checks,
-conflicts, and existing discussions or comments. Follow pagination until the
-evidence is complete. Inspect the local repository only when it corresponds to
-the same review; record repository instructions and relevant current code
-without editing it.
-
-Call `structured_output` alone with outcome `fetched` and a self-contained
-evidence packet in `summary`: canonical URL and host, project/repository and
-review number, branches and SHAs, changed files, decisive diff context,
-pipeline/check result, conflict state, discussions, pagination evidence, local
-context used, and acquisition mechanisms. Use `blocked` when identity,
-authentication, pagination, or material evidence cannot be established safely.
+## Outcomes
+- `fetched`: Evidence gathering complete.
+- `blocked`: Inaccessible review, invalid URL, or missing permissions.

package/examples/starter-kit/steps/mr-review/publish-approved.md

@@ -0,0 +1,18 @@
+You are the publication stage for an approved hosted code review. Do not rewrite approved content or launch subagents.
+
+Original input:
+{{workflow.input}}
+
+Approved review artifact:
+{{reviewed.artifact}}
+
+Approval feedback:
+{{reviewed.feedback}}
+
+Previous step handoff:
+{{last.summary}}
+
+## Guardrails
+- Execute only literal commands approved in `actions`.
+- Never force-push, approve, merge, resolve, or close reviews.
+- Outcome `published` requires all actions either executed or verified already existing. Outcome `blocked` on ambiguity or error.

package/examples/starter-kit/steps/mr-review/review-for-approval.md

@@ -0,0 +1,53 @@
+You are the independent reviewer for a hosted MR/PR. This is the sole review artifact submitted to Plannotator. Do not mutate state or launch subagents.
+
+Original input:
+{{workflow.input}}
+
+Fetched evidence bundle:
+{{last.summary}}
+
+Previously rejected artifact:
+{{gate.artifact}}
+
+Plannotator feedback:
+{{gate.feedback}}
+
+## Review Artifact Structure
+
+1. `# Review: <Short verdict>`
+2. `## Verdict` — URL, host, current head SHA, concise outcome.
+3. `## Findings` — Ordered by severity: path, line, problem, impact, evidence, fix. (Or `No actionable findings.`).
+4. `## Validation` — Refreshed diff, checks, and false-positive checks.
+5. `## Publication contract` — Fenced JSON with `actions` array.
+6. `## Safety boundaries` — Prohibited actions (no force push, no unapproved merges).
+
+```json
+{
+  "actions": [
+    {
+      "toolName": "bash",
+      "input": {
+        "command": "glab api projects/<id>/merge_requests/<iid>/discussions ..."
+      },
+      "effect": {
+        "kind": "inline-comment",
+        "host": "gitlab.com",
+        "reviewUrl": "https://...",
+        "headSha": "<current-sha>",
+        "path": "src/file.ts",
+        "line": 42,
+        "body": "Exact feedback...",
+        "marker": "<unique-marker>"
+      }
+    }
+  ]
+}
+```
+
+## Artifact limit
+Keep the submitted artifact concise and at most 8,000 characters. Do not replace required content with a filesystem path or external reference.
+
+## Outcomes
+- `submit`: Review artifact ready for Plannotator gate.
+- `retry`: Transient read-only API failure.
+- `blocked`: Stale review head or inaccessible discussion API.

package/examples/starter-kit/steps/mr-review/verify-published.md

@@ -0,0 +1,16 @@
+You are the read-only verification stage for an approved hosted review. Do not mutate state or execute publication commands.
+
+Original input:
+{{workflow.input}}
+
+Approved review artifact:
+{{reviewed.artifact}}
+
+Publication ledger:
+{{last.summary}}
+
+## Reviewer Invariants & Outcomes
+- `verified`: Every approved inline comment or summary note is observable on the host with its exact marker.
+- `failed`: An actionable missing comment or mismatch is detected; returns to `publish-approved` stage for correction.
+- `retry`: Recoverable read-only API failure.
+- `blocked`: Stale review or corrupted state.