@thebackstoryis/engineering-with-ai 0.3.4-beta.6 → 0.3.5-beta.1

package/Docs/README.md

@@ -8,7 +8,7 @@ For feature delivery, **`ewai-deliver` coordinates the full fourteen-stage workf
 
 If you want EWAI to act on an approved, exact pool of registered intents, read [governed autonomous intent delivery](autonomous-intent-delivery.md). It starts off, needs a named and bounded grant, and leaves human Build approval and Manual QA separate.
 
-Read how [EWAI now supports Jev and the OpenAI Decisions API](releases/0.3.4-beta.6.md) in the latest beta.
+Read [what's new in beta 0.3.5-beta.1](releases/0.3.5-beta.1.md), the [stable 0.3.4 release notes](releases/0.3.4.md), or the [earlier Jev and OpenAI Decisions beta notes](releases/0.3.4-beta.6.md).
 
 ## New to EWAI?
 

package/Docs/autonomous-intent-delivery.md

@@ -35,3 +35,23 @@ Answering an autonomy question records a private owner response for the run. It
 Use `ewai autonomy status --project . --run RUN_ID --json` to inspect a run. `ewai autonomy pause|resume|cancel|recover --project . --run RUN_ID --expected-revision N --yes --json` applies a revision-bound control; a stale revision must be inspected again. For a human question, use the dashboard's guarded answer form or `ewai autonomy answer --project . --input PROJECT_RELATIVE_JSON --yes --json`, with a private project-local input file. Do not put private answers or credentials in chat or command arguments.
 
 The package tests exercise a tarball-installed consumer with preseeded offline dependencies; they do not prove a fresh registry dependency bootstrap or migration from every historical version. A controlled test simulates a lost response and verifies no repeated canonical effect. A separate installed-worker test substitutes only the provider boundary with a local child process; it does not establish live provider conformance. Human Manual QA, external acceptance, deployment and npm release remain separate decisions and evidence.
+
+## Continuing incomplete Build workers
+
+An approved task can opt into continuation through `ralph_loop.allowed: true` and `max_iterations` between 1 and 100; a usual starting limit is 3. Put this bound in the task graph before Build approval. Each iteration is a provider invocation and consumes the supervisor's existing provider-attempt budget when autonomy owns the run. No new grant or larger budget is inferred.
+
+If a worker exits successfully before its declared green check passes, the AFK conductor reads the actual result and starts another implementation turn in the same isolated worktree, with a reference to the captured failure output. It retains partial work and records each iteration. One task timeout covers the turns, verification, review and post-merge checks; it does not reset on each continuation. Disabled loops retain one implementation turn.
+
+A worker summary or completion promise cannot finish the task. Tests, file scope, conductor-owned commits, fresh-context review and integration checks still apply. The loop stops on an `EWAI_BLOCKED:` worker decision, provider failure or timeout, unknown termination, scope breach, changed authority or identity, failed review, or exhausted limits. Pause prevents another implementation turn while preserving the stopped task's worktree; explicit resume follows the existing recovery/revalidation route and can create a new task attempt. Cancellation never assumes a child has stopped.
+
+The ordinary interactive companion does not supervise individual chat-turn endings. Use the existing AFK executor for eligible approved Build work that should continue across worker turns. This capability does not autonomously complete every lifecycle phase: pre-Build drafts need review, and human approvals remain separate.
+
+## Lightweight delivery-claim validation
+
+The existing fresh-context reviewer assesses every named completion claim separately and supplies a specific source/test/check citation and pass/fail result. The conductor rejects omitted, duplicate, unknown, unsupported or failed results before integration; a generic verdict or green exit is insufficient. No additional model call is needed. New task evidence uses v3 and attaches each claim to hashed review evidence rather than automatically citing the same green output. New task contracts declare claim_validation.required=true so removing required claim metadata cannot satisfy them with legacy evidence. Historical v1/v2 remains readable. This is model-assisted semantic review, not proof of production deployment or human acceptance; those require their separate evidence and authority.
+
+## Challenge, observe and recover
+
+The existing reviewer tries to falsify every completion claim and records a concrete attempt/result, distinguishing source tracing from execution. v3 claim results include `challenge: {attempt, result}` and `observation: {evidence_type, expected, actual, evidence}`. Planned `completion_requirements` assign an evidence type to each exact completion name; behaviour is the default. A configured switch proves configuration, an executed command proves its own check, a reviewed artefact proves review, and delivered behaviour needs evidence of the claimed outcome. Missing, skipped or unavailable checks stay unverified. This remains model-assisted judgement with host-enforced structure and hashes. New contracts require claim_validation.version=3; historical v1/v2 evidence remains readable but cannot satisfy a v3 requirement.
+
+AFK status returns an evidence-derived checkpoint: repository integration branches, declared/actual task branches and worktrees, verified completed claim labels, concrete next action and open questions. The projection is persisted atomically with run.json and recomputed on status reads. It never grants authority or certifies human acceptance. Tampered evidence removes completion from the refreshed view; uncertain worker termination directs recovery before resume. Use the existing resume preflight and canonical phase gates.

package/Docs/explanation/delivery-workflow.md

@@ -46,3 +46,9 @@ EWAI saves the intent and phase evidence in SPECS. Ask it to show what's complet
 If the outcome changes materially, revisit the intent and plan. A new Build approval may be needed. If only an evidence reference needs a correction, follow the [amendment guide](../completed-phase-evidence-amendments.md), which explains the narrow permitted operations.
 
 Try the [first-delivery tutorial](../tutorials/first-delivery.md). For exact commands and evidence contracts, use the [developer delivery guide](../developer-delivery-guide.md).
+
+## A worker turn is not task completion
+
+The delivery workflow governs what may happen next. For eligible approved Build tasks, the AFK conductor also keeps execution moving between worker turns. A task can approve a finite continuation loop (`ralph_loop.allowed: true`, `max_iterations: 3`, for example). A normal worker exit followed by failing green verification then leads to another turn in the same worktree, within the original deadline and scope. Host verification decides when the task is ready for review. Failed reviews and genuine blockers require attention.
+
+This is distinct from merely instructing the interactive companion to keep going: EWAI cannot restart that host's conversation after a chat turn ends. The conductor supplies the persistent execution path for approved Build tasks, while canonical phase gates continue to govern the wider delivery.

package/Docs/releases/0.3.4.md

@@ -0,0 +1,7 @@
+# What's new in this version
+
+Version `0.3.4` adds optional **Jev and OpenAI Decisions** support to rank choices, compare AI recommendations, prioritise context and suggest personas or additional checks. Both start switched off. Configure them privately through the CLI or dashboard, compare advice in shadow mode or apply supported recommendations in active mode, and track usage, estimated cost and call limits.
+
+**Concise answers and Grok Build.** EWAI puts the result or recommendation first, with clearer choices and less repetition. Grok Build is available as a coding companion, with dashboard and CLI controls for choosing your primary assistant and independent reviewers.
+
+**Pick up the next ready piece of work.** Approve a list of work items and EWAI can select the next ready item using your recorded priorities. Set time and attempt limits, follow progress, and pause or recover a run. Build approval, required reviews, Manual QA and release decisions stay with you.

package/Docs/releases/0.3.5-beta.1.md

@@ -0,0 +1,7 @@
+## What's new in this version
+
+Version `0.3.5-beta.1` adds **bounded Build continuation**. When an approved autonomous Build worker finishes before its required checks pass, EWAI can give it the failed-check feedback and continue in the same isolated worktree. Continuation is opt-in, with configured iteration and time limits, and respects pause, cancellation and blocked-work signals.
+
+**Check the delivery claim.** The existing independent Build review now checks each declared completion claim against supporting evidence and attempts to challenge it. Reviews distinguish observed behaviour from configuration, command results and review results. Missing, failed or incomplete claim evidence prevents integration, without adding another review call.
+
+**Recover with a clearer checkpoint.** Saved runs record verified completed work, branches and worktrees, the next action and unresolved questions. Status checks revalidate the evidence before listing work as complete. These changes support continued execution within approved Build boundaries; Manual QA, acceptance and release decisions remain human checkpoints.

package/README.md

@@ -1,33 +1,18 @@
 # Engineering With AI
 
-## New in 0.3.4 Beta 6 release
-
-**EWAI now supports Jev and the OpenAI Decisions API.**
-
-- **Rank options and recommend a choice.** Evaluate available approaches and return an ordered list with a recommended answer.
-- **Check AI recommendations.** Compare supported options returned by a larger language model with a second recommendation.
-- **Recommend suitable personas.** Select from personas available to your project, including core, project, personal and installed premium personas.
-- **Reduce larger-model calls.** Evaluate supported choices through focused decision calls instead of sending the same options to a larger language model.
-- **Prioritise context.** Help order supporting context for coding and review tasks.
-- **Support additional checks.** Assess supplied claim evidence, classify sanitised failures and recommend supplementary impact reviews and tests.
-- **Choose your provider.** Select Jev, OpenAI Decisions or Automatic. Automatic prefers configured and authorised OpenAI access, then Jev.
-- **Configure through the CLI or dashboard.** Save API keys privately, enable either integration and select the uses you want.
-- **Choose shadow or active mode.** Shadow shows recommendations for comparison. Active can apply supported recommendations to context ordering and persona selection.
-- **Track usage and estimated cost.** View decision-call usage and set call and input-token limits.
+Engineering With AI (EWAI) helps you plan, build and review software with an AI assistant. It gives the assistant a shared record of the project, a delivery workflow and checks against your engineering standards. You keep control of the decisions and approve implementation before it starts.
 
-Both integrations are optional and start disabled. EWAI continues to work without either service.
+[![Intent Studio in the EWAI dashboard: describing a feature, agreeing its acceptance criteria and engaging specialist personas before any code is written](https://www.conversationalcoding.dev/wp-content/uploads/sites/5/2026/09/intent-studio-full-be7758ffd224-1536x704.webp)](https://www.conversationalcoding.dev/engineering-with-ai-harness/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
 
-Install or update from the npm beta channel:
+**Website, guides and books:** [conversationalcoding.dev](https://www.conversationalcoding.dev/engineering-with-ai-harness/?utm_source=readme&utm_medium=referral&utm_campaign=ewai) · [Online documentation](https://www.conversationalcoding.dev/engineering-with-ai-harness/docs/?utm_source=readme&utm_medium=referral&utm_campaign=ewai) · [Persona library](https://www.conversationalcoding.dev/personas/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
 
-```sh
-npm install --save-dev @thebackstoryis/engineering-with-ai@beta
-```
+## What's new in this version
 
-Engineering With AI (EWAI) helps you plan, build and review software with an AI assistant. It gives the assistant a shared record of the project, a delivery workflow and checks against your engineering standards. You keep control of the decisions and approve implementation before it starts.
+Version `0.3.5-beta.1` adds **bounded Build continuation**. When an approved autonomous Build worker finishes before its required checks pass, EWAI can give it the failed-check feedback and continue in the same isolated worktree. Continuation is opt-in, with configured iteration and time limits, and respects pause, cancellation and blocked-work signals.
 
-[![Intent Studio in the EWAI dashboard: describing a feature, agreeing its acceptance criteria and engaging specialist personas before any code is written](https://www.conversationalcoding.dev/wp-content/uploads/sites/5/2026/09/intent-studio-full-be7758ffd224-1536x704.webp)](https://www.conversationalcoding.dev/engineering-with-ai-harness/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
+**Check the delivery claim.** The existing independent Build review now checks each declared completion claim against supporting evidence and attempts to challenge it. Reviews distinguish observed behaviour from configuration, command results and review results. Missing, failed or incomplete claim evidence prevents integration, without adding another review call.
 
-**Website, guides and books:** [conversationalcoding.dev](https://www.conversationalcoding.dev/engineering-with-ai-harness/?utm_source=readme&utm_medium=referral&utm_campaign=ewai) · [Online documentation](https://www.conversationalcoding.dev/engineering-with-ai-harness/docs/?utm_source=readme&utm_medium=referral&utm_campaign=ewai) · [Persona library](https://www.conversationalcoding.dev/personas/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
+**Recover with a clearer checkpoint.** Saved runs record verified completed work, branches and worktrees, the next action and unresolved questions. Status checks revalidate the evidence before listing work as complete. These changes support continued execution within approved Build boundaries; Manual QA, acceptance and release decisions remain human checkpoints.
 
 ## Quick start
 
@@ -41,27 +26,7 @@ ewai
 
 `ewai` opens your assistant and walks you through setting up the project. See [Install and start](#install-and-start) for details.
 
-Versions `0.3.2` and `0.3.3` update the package's links and documentation. The features below arrived in `0.3.1`.
-
-## New in 0.3.1: concise answers and Grok Build
-
-Version `0.3.1` makes EWAI's guidance more concise and adds Grok Build as a coding provider.
-
-**Concise answers and guided decisions.** EWAI's managed instructions now prioritise correctness and usefulness, then brevity. Expect the result or recommendation first, with less repetition and routine narration. Decision requests explain the action, options and consequences, then give a recommendation with its reason and a suggested response when useful. When a request is unclear, EWAI leads with its recommended interpretation and states the assumptions that matter. The guidance is designed to cut unnecessary output; tool-result compaction is still planned, and token or cost savings haven't been measured yet. See [concise answers and guided decisions](Docs/context-management-and-token-efficiency.md#concise-answers-and-guided-decisions).
-
-**Grok Build and coding provider settings.** EWAI can open Grok Build as a native companion, install its skills and set up project MCP. **Configuration → Coding providers** in the dashboard, or `ewai providers` in a terminal, lets you choose a primary coding CLI, independent reviewers and an eligible pool for unattended work. Each CLI keeps its own model choice by default. Grok can run isolated coding, read-only review and restricted proposal workers. Each mode passes an offline conformance check before dispatch, and your xAI key is saved privately outside the project. Build approval, required review and Manual QA stay with you. See [provider settings](Docs/reference/cli-and-configuration.md#coding-provider-settings) and [Grok Build setup](Docs/operations/installation-updating-and-entitlements.md#grok-build).
-
-After updating, initialisation or the next check-in refreshes EWAI's managed instructions in `AGENTS.md` and `CLAUDE.md`, preserving project-authored guidance outside that block. Start a fresh host conversation after the refresh.
-
-## EWAI can now pick up the next ready piece of work
-
-If you’ve prepared several work items, you can choose which ones EWAI is allowed to take on. EWAI checks what’s ready, uses the priorities you’ve recorded to pick the next item, and starts its delivery workflow. Once you’ve separately approved the Build, it can run the approved build tasks, their tests and a fresh review.
-
-This `0.3.0` release brings the capability out of beta. It adds dashboard and command-line controls to preview the work, approve the exact list, set time and attempt limits, follow progress, and pause, cancel or recover a run. New work isn’t added to the list automatically. EWAI stops when it needs a decision from you.
-
-The final whole-delivery test stage, Manual QA and release preparation still happen through the normal EWAI workflow. EWAI doesn’t approve or complete those steps for you.
-
-To use the release in a project without replacing a global installation, run:
+To use EWAI in a project without replacing a global installation, run:
 
 ```bash
 npm install --save-dev @thebackstoryis/engineering-with-ai
@@ -70,7 +35,7 @@ npx ewai
 
 To install or update EWAI globally, run `npm install --global @thebackstoryis/engineering-with-ai`.
 
-## Install and start
+### Install and start
 
 You'll need Node.js 22.5 or newer, npm, and a supported AI command-line tool such as Codex or Claude Code, installed and signed in.
 
@@ -88,12 +53,12 @@ It first asks where to keep your project's SPECS records, then helps you describ
 
 To return to the project, run `ewai` in the same folder again. It picks up the saved project state rather than starting setup from scratch. Keep your normal Git workflow for your application's code; EWAI itself is installed and updated through npm.
 
-If npm returns `E404`, follow [installation troubleshooting](Docs/operations/installation-updating-and-entitlements.md). That's a package-acquisition failure, not a premium-persona licence error. Don't paste licence keys into npm commands or chat.
+If npm returns `E404`, follow [installation troubleshooting](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/operations/installation-updating-and-entitlements.md). That's a package-acquisition failure, not a premium-persona licence error. Don't paste licence keys into npm commands or chat.
 
-- [First session: set up a small project](Docs/tutorials/first-session.md)
-- [First delivery: work through a CSV export](Docs/tutorials/first-delivery.md)
-- [Already have a codebase?](Docs/existing-project-onboarding-guide.md) Archaeology can reconstruct missing documentation, but it's your choice whether to run it.
-- [Installation, updates and host options](Docs/operations/installation-updating-and-entitlements.md)
+- [First session: set up a small project](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/tutorials/first-session.md)
+- [First delivery: work through a CSV export](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/tutorials/first-delivery.md)
+- [Already have a codebase?](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/existing-project-onboarding-guide.md) Archaeology can reconstruct missing documentation, but it's your choice whether to run it.
+- [Installation, updates and host options](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/operations/installation-updating-and-entitlements.md)
 
 ## Start with a conversation
 
@@ -113,7 +78,7 @@ The supporting CLI commands are available for direct control, troubleshooting an
 
 **SPECS** means Scope, Purpose, Evidence, Constraints and Strategy. These readable project records hold the purpose, requirements, decisions and evidence the team has agreed. They remain useful outside an AI session.
 
-The dashboard runs locally and lets you inspect work and make supported choices. Its loopback address isn't a shared team website. The AI host does the guided work; the runtime records progress and checks the conditions for moving on. [How these parts fit together](Docs/explanation/core-concepts.md).
+The dashboard runs locally and lets you inspect work and make supported choices. Its loopback address isn't a shared team website. The AI host does the guided work; the runtime records progress and checks the conditions for moving on. [How these parts fit together](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/explanation/core-concepts.md).
 
 Human judgement remains essential. A persona isn't a real stakeholder, green tests aren't human acceptance, and a delivery handoff isn't permission to deploy.
 
@@ -127,21 +92,21 @@ The source is published for transparency and review, but EWAI is not open
 source. You may not modify, repackage, redistribute, rebrand or commercially
 exploit the EWAI core without separate written permission from Backstory Group.
 The licence does not restrict the project content or output you create by using
-EWAI. Read the [Backstory Group Source-Available Licence](LICENSE) for the full
+EWAI. Read the [Backstory Group Source-Available Licence](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/LICENSE) for the full
 terms.
 
 ## Choose what you need
 
 | When you want to… | Start here |
 | --- | --- |
-| Decide which work needs attention next | [Companion](Docs/context-aware-delivery-companion-user-guide.md) |
-| Describe a feature and agree its boundaries | [Intent Studio](Docs/guided-intent-workspace-guide.md) |
-| Understand how delivery moves through its stages | [The fourteen-stage workflow](Docs/explanation/delivery-workflow.md) |
-| Investigate dependencies before a change | [Source Map](Docs/repository-source-map-guide.md) and [Blast Radius](Docs/blast-radius-and-impact-routing-guide.md) |
-| Turn a meeting into reviewed project evidence | [Meeting evidence](Docs/meeting-evidence-user-guide.md) |
-| Check an implemented feature with a person | [Manual QA](Docs/quality/manual-qa-and-acceptance.md) |
-| Adapt the dashboard to your work | [Dashboard configuration](Docs/operations/dashboard-configuration.md) |
-| Use shared organisational guidance | [Blueprints](Docs/designing-organisation-blueprint-packs.md) and [rollout](Docs/organisation-rollout-guide.md) |
+| Decide which work needs attention next | [Companion](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/context-aware-delivery-companion-user-guide.md) |
+| Describe a feature and agree its boundaries | [Intent Studio](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/guided-intent-workspace-guide.md) |
+| Understand how delivery moves through its stages | [The fourteen-stage workflow](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/explanation/delivery-workflow.md) |
+| Investigate dependencies before a change | [Source Map](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/repository-source-map-guide.md) and [Blast Radius](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/blast-radius-and-impact-routing-guide.md) |
+| Turn a meeting into reviewed project evidence | [Meeting evidence](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/meeting-evidence-user-guide.md) |
+| Check an implemented feature with a person | [Manual QA](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/quality/manual-qa-and-acceptance.md) |
+| Adapt the dashboard to your work | [Dashboard configuration](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/operations/dashboard-configuration.md) |
+| Use shared organisational guidance | [Blueprints](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/designing-organisation-blueprint-packs.md) and [rollout](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/organisation-rollout-guide.md) |
 
 Start with the parts your project needs. Portfolio, Team Hub and other advanced dashboard views are optional; hiding a view doesn't disable mandatory project checks.
 
@@ -149,18 +114,18 @@ Start with the parts your project needs. Portfolio, Team Hub and other advanced
 
 The included personas support the normal workflow. You can also create project-specific personas and use your own personal library.
 
-Premium personas are optional specialist perspectives. If you have a subscription, [enter your key privately and install the pack](Docs/operations/premium-personas-setup.md) before the analysis you want it to support. Installing a persona doesn't give it authority to approve a requirement, bypass a check or speak for a real user.
+Premium personas are optional specialist perspectives. If you have a subscription, [enter your key privately and install the pack](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/operations/premium-personas-setup.md) before the analysis you want it to support. Installing a persona doesn't give it authority to approve a requirement, bypass a check or speak for a real user.
 
 ## Go deeper
 
-- [User guides and learning routes](Docs/README.md)
-- [Complete guide catalogue](Docs/guide-catalogue.md)
-- [Capabilities and project layout](Docs/reference/capabilities-and-project-layout.md)
-- [Commands and configuration](Docs/reference/cli-and-configuration.md)
-- [Troubleshooting and recovery](Docs/operations/troubleshooting-and-recovery.md)
+- [User guides and learning routes](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/README.md)
+- [Complete guide catalogue](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/guide-catalogue.md)
+- [Capabilities and project layout](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/reference/capabilities-and-project-layout.md)
+- [Commands and configuration](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/reference/cli-and-configuration.md)
+- [Troubleshooting and recovery](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/operations/troubleshooting-and-recovery.md)
 - [EWAI on the web: harness overview, online docs and changelog](https://www.conversationalcoding.dev/engineering-with-ai-harness/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
 - [Engineering With AI, the book behind the method](https://www.conversationalcoding.dev/books/?utm_source=readme&utm_medium=referral&utm_campaign=ewai)
 
 ## Contributing to EWAI
 
-If you're changing the harness itself, use the [contributor guide](Docs/maintainers/contributing.md) and [verification walkthroughs](Docs/maintainers/verification-walkthroughs.md). Those source-checkout and regression-test instructions aren't part of setting up your own application.
+If you're changing the harness itself, use the [contributor guide](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/maintainers/contributing.md) and [verification walkthroughs](https://github.com/TheBackstoryIs/EngineeringWithAIHarness/blob/main/Docs/maintainers/verification-walkthroughs.md). Those source-checkout and regression-test instructions aren't part of setting up your own application.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thebackstoryis/engineering-with-ai",
-  "version": "0.3.4-beta.6",
+  "version": "0.3.5-beta.1",
   "description": "A human-centred, AI-augmented engineering pipeline",
   "license": "SEE LICENSE IN LICENSE",
   "author": "The Backstory Is",

package/skills-src/ewai-deliver/SKILL.md

@@ -77,6 +77,8 @@ Use guarded operations only:
 
 Never mutate a raw phase or status. A phase completes only with its passing EWAI gate ledger and fresh, hashed project evidence. Record meaningful progress events for the dashboard.
 
+New task contracts must set `claim_validation.required=true` and `claim_validation.version=3`. Declare one `completion_requirements` entry per completion name with `evidence_type`: `behaviour`, `configuration`, `command-result` or `review-result`. Default evidence type for undeclared historical tasks is behaviour. Challenge every claim: try a counterexample and record `challenge.attempt` and `challenge.result`, stating whether executed or source-traced. Record `observation.evidence_type`, `expected`, `actual` and `evidence`; configuration does not establish delivered behaviour and a green command proves only its exercised assertions. Unknown/skipped outcomes cannot pass their obligation. During the existing fresh-context review, assess each `completion_evidence` claim individually against specific source, test assertions or observed check results. Emit one `COMPLETION_CHECK:` JSON line per exact name with `status` and `support`; do not infer all claims from a generic passing test. Unsupported, missing or failed claims block integration. New evidence uses `ewai.task-evidence/v3` and binds completion claims to captured review evidence. Historical v1/v2 evidence remains readable, but cannot satisfy a task requiring claim validation. This adds no separate model invocation; it is model-assisted evidence assessment, not Manual QA or release authority.
+
 Plan must produce `build-plan.md`, `destination.md`, the Claim Ledger, Plan Contract, and complete `task-graph.json`. The deterministic task-graph validator checks source records, claim and slice coverage, dependencies, cycles, write-set isolation, branch uniqueness, task contracts, waves, evidence paths, and review/merge ownership. Do not author its passing output manually.
 
 ## Persona-led test scenario integration
@@ -109,13 +111,15 @@ Start the intent-level active session with a stable `ownerId`. A different orche
 
 ## Unattended Build conductor
 
-When the user explicitly asks EWAI to continue approved Build work while they are away, use the AFK conductor instead of inventing a host-specific background loop:
+When the user explicitly asks EWAI to continue approved Build work to completion without repeated prompts, or while they are away, use the AFK conductor for eligible tasks instead of inventing a host-specific background loop:
 
 1. Call `ewai_afk_preflight` and explain every blocker. Never weaken the task graph to make preflight pass.
 2. Confirm the user has already approved Build and understands the bounded scope, provider choice, maximum parallel tasks, and timeout.
 3. Call `ewai_afk_start`. Report the durable run ID and how to pause, resume, cancel, and inspect it; do not expose lease tokens or raw prompts.
 4. Use `ewai_afk_status` for updates. Translate semantic run/task states into human language rather than streaming model internals.
-5. A blocked run requires attention; diagnose its preserved log/evidence before `ewai_afk_resume`. Never silently retry a stop condition, failed review, scope breach, merge conflict, or post-merge failure.
+5. For tasks expected to need several implementation turns, propose an explicit `ralph_loop.allowed: true` with a finite `max_iterations` from 1 to 100 (normally 3) before Build approval. Existing disabled contracts remain single-shot; never expand a recorded task or grant to obtain more attempts.
+6. The conductor can continue only a successfully exited, confirmed stopped implementation worker whose declared green check still fails. It keeps the same task worktree, captures each verification output, and rechecks provider/authority/control boundaries on every invocation. The task timeout is shared across its turns, verification, review and post-merge checks. A completion promise never replaces host verification.
+7. A blocked run requires attention; diagnose its preserved log/evidence before `ewai_afk_resume`. Never silently retry a worker-reported `EWAI_BLOCKED:` decision, provider error/timeout, unknown termination, stop condition, failed review, scope breach, merge conflict, or post-merge failure.
 
 The conductor is a local Build executor, not a replacement for the fourteen-stage harness. It detects simple and multi-repository topology from the configured `pipeline.yaml`; every task's `repo` must match a configured repository, and exactly one configured repository must contain the configured SPECS root to own durable evidence. The workspace root need not be a Git repository. It creates a missing integration branch from each selected repository's clean current branch, then creates a real task branch/worktree there, leases only ready AFK tasks, limits concurrency to the validated graph, requires a fresh-context review, merges into that repository's declared parent branch in graph order, and runs post-merge checks. It blocks detached heads and refuses to silently switch when the declared integration branch already exists elsewhere. Use `task-graph.json.repository_branches` when repositories have different parent branches. Completion means all eligible Build tasks were integrated; it does not complete the Build phase, Standards Sweep, Test Execute, external validation, Delivery, Manual QA, or Retro.
 
@@ -124,3 +128,15 @@ The conductor is a local Build executor, not a replacement for the fourteen-stag
 Translate control-plane work into warm, semantic progress such as “Validating the plan against project standards” or “Checking what changed since this work was shelved.” Do not make the user learn the command surface. Ask only decisions the evidence cannot answer.
 
 When blocked, retain the exact phase, evidence, questions, and recovery point. When complete, Retro must capture learning and route accepted improvements into project-owned SPECS assets.
+
+## Execution continuity
+
+After an authorised action completes, inspect the saved next action and continue all remaining permitted work. A successful tool call, completed task, progress summary or model turn is not delivery completion. Do not end the interaction just to offer to continue work the owner has already authorised.
+
+Stop for a real blocker, a required human decision, exhausted configured execution budget, cancellation, or the actual agreed completion boundary. Preserve the exact recovery point and explain the reason. Never interpret an earlier Build instruction as Manual QA, deployment, release or acceptance approval.
+
+For eligible approved Build tasks, the conductor provides execution continuity outside individual worker turns. These instructions improve interactive behaviour but cannot restart a native host conversation after its model ends a turn; do not advertise guaranteed unattended completion for the ordinary interactive companion. Phase preparation remains draft-only and stops for its required human review.
+
+## Evidence-derived recovery checkpoint
+
+Use the checkpoint returned by AFK status to present integration/task branches, evidence-validated completed claims, the exact next action and open questions. It is stored atomically in the run record and recomputed on status reads, so changed evidence is never accepted from a stale checkpoint. Reports and guarded action/preflight surfaces remain authoritative; checkpoint output never grants resume, Build, release or acceptance authority. Unknown worker termination requires recovery, and missing/tampered completion evidence requires diagnosis. Present the checkpoint at interruptions and handoffs rather than replaying raw logs.

package/src/runtime/afk-conductor.mjs

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import {
-  copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync,
+  copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync,
 } from 'node:fs';
 import { dirname, relative, resolve } from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { deliveryPaths, atomicJson, isWithin, sha256, now } from '../delivery-documents.mjs';
 import { projectPaths } from '../paths.mjs';
 import { loadProjectConfig, validationStatus } from '../project.mjs';
-import { validateTaskGraph, validateTaskReport } from '../task-graph.mjs';
+import { validateTaskGraph, validateTaskReport, parseCompletionClaimReview } from '../task-graph.mjs';
 import { syncIntentIndex } from './intents.mjs';
 import {
   abandonExecutionLeasesForRun,
@@ -74,6 +74,49 @@ function requireRun(projectRoot, runId) {
   return { paths, run };
 }
 
+export function deriveAfkCheckpoint(projectRoot, run) {
+  try { return deriveCheckpointFromEvidence(projectRoot,run); }
+  catch {
+    // A derived convenience view must never obstruct durable control writes.
+    return {schema:'ewai.afk-checkpoint/v1',runId:run.id,status:'unavailable',updatedAt:run.updatedAt,
+      repositories:[],tasks:[],done:[],openQuestions:['Recovery checkpoint unavailable: task or run evidence is malformed; inspect preserved records.'],
+      next:run.executionStopped!==true || run.unconfirmedExecution
+        ? {action:'confirm-worker-termination',instruction:'Establish owned worker termination before a human recovery decision.'}
+        : {action:'inspect-evidence',instruction:'Repair or reconcile malformed saved evidence through existing guarded operations.'}};
+  }
+}
+
+function deriveCheckpointFromEvidence(projectRoot, run) {
+  const checkpoint = {schema:'ewai.afk-checkpoint/v1',runId:run.id,status:run.status,updatedAt:run.updatedAt,
+    repositories:(run.topology?.repositories ?? []).map(repo=>({name:repo.name,integrationBranch:repo.parentBranch})),tasks:[],done:[],openQuestions:[],next:null};
+  let graph;
+  try { graph = readGraph(projectRoot,run.slug); if (!Array.isArray(graph.tasks)) throw new Error('Malformed task graph'); }
+  catch { graph=null; checkpoint.openQuestions.push('The task graph cannot be read; inspect saved delivery evidence.'); }
+  for (const task of graph?.tasks ?? []) {
+    const state=run.tasks?.[task.id] ?? {};
+    let report;
+    try { report=validateTaskReport(deliveryPaths(projectRoot,run.slug).deliveryRoot,task); }
+    catch { report={status:'incomplete'}; }
+    checkpoint.tasks.push({id:task.id,repository:task.repo,declaredBranch:task.branch,actualBranch:state.actualBranch ?? null,
+      worktree:state.worktree ?? null,status:state.status ?? 'pending',evidenceStatus:report.status});
+    if (report.status === 'complete') checkpoint.done.push({taskId:task.id,claims:task.completion_evidence ?? []});
+    else if (state.status === 'completed') checkpoint.openQuestions.push(`${task.id} recorded completion has missing or invalid evidence; inspect it before continuing.`);
+    if (state.error) checkpoint.openQuestions.push(`${task.id}: ${state.error}`);
+  }
+  if (['blocked','cancel-unknown'].includes(run.status)) for(const message of (run.messages ?? []).slice(-1)) checkpoint.openQuestions.push(message.message);
+  const stopped=run.executionStopped===true && !run.unconfirmedExecution && !(run.activeWorkers ?? []).length;
+  const orphaned = run.status==='running' && !processAlive(run.pid);
+  if (!stopped && (!['running','starting'].includes(run.status) || orphaned)) checkpoint.next={action:'confirm-worker-termination',instruction:'Establish that owned workers stopped; inspect preserved work before a human recovery decision.'};
+  else if (checkpoint.openQuestions.some(question=>question.includes('evidence') || question.includes('task graph'))) checkpoint.next={action:'inspect-evidence',instruction:'Resolve missing or changed task evidence before claiming completion or resuming.'};
+  else if (run.status==='cancelled') checkpoint.next={action:'cancelled',instruction:'Work is preserved; starting further work needs a new permitted action.'};
+  else if (run.status==='completed' && graph?.tasks?.length && checkpoint.done.length===graph.tasks.length) checkpoint.next={action:'complete-build-gate',instruction:'All task evidence validates; use the canonical Build gate and subsequent phases. Human acceptance is still separate.'};
+  else if (orphaned) checkpoint.next={action:'guarded-resume',instruction:'The saved conductor is no longer running; inspect preserved work and use the existing guarded recovery preflight.'};
+  else if (run.status==='paused') checkpoint.next={action:'guarded-resume',instruction:'Inspect the preserved checkpoint, then use the existing resume preflight; this checkpoint grants no authority.'};
+  else if (run.status==='blocked') checkpoint.next={action:'inspect-blocker',instruction:'Diagnose the recorded blocker and preserved logs; resume only through existing guarded recovery.'};
+  else checkpoint.next={action:'continue-bounded-work',instruction:'The conductor continues only permitted tasks under its saved controls; inspect status before any manual intervention.'};
+  return checkpoint;
+}
+
 function saveRun(paths, run, resumeFrom = null) {
   if (existsSync(paths.runPath)) {
     const current = JSON.parse(readFileSync(paths.runPath, 'utf8'));
@@ -84,6 +127,7 @@ function saveRun(paths, run, resumeFrom = null) {
     }
   }
   run.updatedAt = now();
+  run.checkpoint = deriveAfkCheckpoint(paths.projectRoot,run);
   atomicJson(paths.runPath, run);
   return run;
 }
@@ -420,7 +464,7 @@ export function afkRunStatus(projectRoot, runId = '') {
   const root = resolve(projectRoot);
   if (runId) {
     const { run } = requireRun(root, runId);
-    return { ...run, alive: processAlive(run.pid) };
+    return { ...run, checkpoint:deriveAfkCheckpoint(root,run), alive: processAlive(run.pid) };
   }
   const { runsRoot } = pathsFor(root);
   if (!existsSync(runsRoot)) return [];
@@ -428,7 +472,7 @@ export function afkRunStatus(projectRoot, runId = '') {
     .filter((entry) => entry.isDirectory() && existsSync(resolve(runsRoot, entry.name, 'run.json')))
     .map((entry) => JSON.parse(readFileSync(resolve(runsRoot, entry.name, 'run.json'), 'utf8')))
     .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
-    .map((run) => ({ ...run, alive: processAlive(run.pid) }));
+    .map((run) => ({ ...run, checkpoint:deriveAfkCheckpoint(root,run), alive: processAlive(run.pid) }));
 }
 
 export function pauseAfkRun(projectRoot, runId) {
@@ -509,7 +553,7 @@ export function prepareAfkContext(projectRoot, task, repository, options = {}) {
   const implementationCommit = String(options.implementationCommit ?? '').trim();
   const taskContent = JSON.stringify(task);
   let rules = review
-    ? `TESTS_FIRST Read tests before implementation. Read cited standards from ${specsRoot}. Review implementation commit ${implementationCommit}. Check the diff, exact task contract, write_set, desired outcome, stop conditions, test evidence, correctness, standards, security and scope. Do not edit files. End with exactly one line: VERDICT: PASS or VERDICT: FAIL.`
+    ? `TESTS_FIRST Read tests before implementation. Read cited standards from ${specsRoot}. Review implementation commit ${implementationCommit}. Check the diff, exact task contract, write_set, desired outcome, stop conditions, test evidence, correctness, standards, security and scope. Do not edit files. For EVERY completion_evidence name, assess whether the claimed result is actually delivered. Cite specific test assertions, source symbols or observed check results that support it; a generic green exit is insufficient. Never infer deployment, release or human acceptance from code/tests. Emit one line per name: COMPLETION_CHECK: followed by JSON with name (exact approved label), status (pass or fail), and support (specific evidence and reasoning), challenge (object with attempt and result), and observation (object with evidence_type, expected, actual and evidence). Try to falsify each claim using a concrete counterexample, boundary, missing input, retry or state sequence; report the attempt and what it showed, including if you could only trace source rather than execute it. Observation must describe what was actually observed, not an intention or a configured setting. Evidence type must match completion_requirements for that name; default is behaviour. Configuration proves only configuration; a command-result proves only its check; behaviour requires the claimed outcome; review-result proves only a completed review. Keep skipped or unavailable checks unverified, never invent human acceptance or deployment. Missing or unsupported delivery must be fail. End with exactly one line: VERDICT: PASS or VERDICT: FAIL.`
     : `You are an EWAI Build worker in an isolated Git worktree. Read standards from ${specsRoot} and tests before implementation. Repository ${repository.name} (${repository.role}). Work only inside write_set. Run only allowed_commands. Stop on every stop_condition. Make the smallest code and test change. Do not create SPECS records, commit, merge, change delivery state or update phase status. AUTHORITY_NONE. Finish with files changed and commands run.`;
   if(options.evidenceCandidates?.length)rules += ' For this isolated Grok worker, read the complete source-standard and recorded-check sections supplied in this context. Host paths and Git history are inaccessible. Use the supplied exact commit diff for review. Do not execute commands: the conductor runs approved checks and owns commits. Read tests from the declared file snapshot before implementation.';
   const ruleMarkers = review
@@ -712,7 +756,7 @@ async function executeCommand(command, cwd, outputPath, timeoutMs, projectRoot,
   const result = await invokeControlled(projectRoot, run, task, { provider: 'command', command: '/bin/sh',
     args: ['-lc', command], cwd, prompt: '', timeoutMs, logPath: outputPath });
   if (result.cancelled || result.timedOut || requireRun(projectRoot, run.id).run.desiredState === 'cancelled') throw new Error('AFK command stopped before completion.');
-  return { command, exitCode: result.exitCode, outputPath };
+  return { command, exitCode: result.exitCode, outputPath, outputSha256: sha256(readFileSync(outputPath)) };
 }
 
 function writeTaskEvidence(projectRoot, run, result, postMerge) {
@@ -722,14 +766,15 @@ function writeTaskEvidence(projectRoot, run, result, postMerge) {
   const delivery = deliveryPaths(projectRoot, run.slug);
   const evidencePath = resolve(delivery.deliveryRoot, task.evidence_path);
   const reportPath = resolve(delivery.deliveryRoot, task.report_path);
-  const reviewRelative = `tasks/${task.id}/evidence/fresh-context-review.md`;
+  const reviewRelative = `tasks/${task.id}/evidence/fresh-context-review.json`;
   const reviewPath = resolve(delivery.deliveryRoot, reviewRelative);
   mkdirSync(dirname(reviewPath), { recursive: true });
-  writeFileSync(reviewPath, `${review.output.trim()}\n`, 'utf8');
+  writeFileSync(reviewPath, JSON.stringify({schema:'ewai.claim-review/v1',reviews:review.reviewResults.map(item=>({reviewer:item.reviewer,output:item.output}))},null,2)+'\n', 'utf8');
   const commands = verifiedCommands.map((commandResult) => {
     const relativePath = `tasks/${task.id}/evidence/${commandResult.stage}.txt`;
     const destination = resolve(delivery.deliveryRoot, relativePath);
     mkdirSync(dirname(destination), { recursive: true });
+    if (sha256(readFileSync(commandResult.outputPath)) !== commandResult.outputSha256) throw new Error('Captured command output changed before acceptance.');
     copyFileSync(commandResult.outputPath, destination);
     return {
       stage: commandResult.stage,
@@ -740,9 +785,22 @@ function writeTaskEvidence(projectRoot, run, result, postMerge) {
       output_sha256: sha256(readFileSync(destination)),
     };
   });
-  const green = commands.find((command) => command.stage === 'green');
+  const continuation = result.continuation && {
+    enabled: result.continuation.enabled,
+    max_iterations: result.continuation.maxIterations,
+    iterations: result.continuation.iterations.map(entry => {
+      const verification = entry.verification;
+      if (!verification) return { iteration: entry.iteration, provider_exit_code: entry.providerExitCode, execution_stopped: entry.executionStopped };
+      const outputPath = `tasks/${task.id}/evidence/green-iteration-${entry.iteration}.txt`;
+      const destination = resolve(delivery.deliveryRoot, outputPath);
+      if (sha256(readFileSync(verification.outputPath)) !== verification.outputSha256) throw new Error('Continuation verification output changed before acceptance.');
+      copyFileSync(verification.outputPath, destination);
+      return { iteration: entry.iteration, provider_exit_code: entry.providerExitCode, execution_stopped: entry.executionStopped,
+        verification: { command: verification.command, exit_code: verification.exitCode, output_path: outputPath, output_sha256: sha256(readFileSync(destination)) } };
+    }),
+  };
   const evidence = {
-    schema: 'ewai.task-evidence/v1',
+    schema: 'ewai.task-evidence/v3',
     task_id: task.id,
     repository: repository.name,
     task_branch: task.branch,
@@ -751,19 +809,22 @@ function writeTaskEvidence(projectRoot, run, result, postMerge) {
     commit: implementationCommit,
     changed_files: changedFiles,
     commands,
+    ...(continuation ? { continuation } : {}),
     review: {
       fresh_context: true,
       tests_reviewed_first: true,
       status: 'pass',
       reviewer,
+      claim_results: review.claimResults,
       evidence_path: reviewRelative,
       evidence_sha256: sha256(readFileSync(reviewPath)),
     },
     completion_checks: (task.completion_evidence ?? []).map((name) => ({
       name,
       status: 'pass',
-      evidence_path: green.output_path,
-      evidence_sha256: green.output_sha256,
+      ...review.claimResults.find(result => result.name === name),
+      evidence_path: reviewRelative,
+      evidence_sha256: sha256(readFileSync(reviewPath)),
     })),
     post_merge_checks: postMerge,
   };
@@ -778,7 +839,7 @@ Implemented ${task.name} in repository ${repository.name} on branch \`${actualBr
 The declared red command failed as expected; the green and refactor verification commands passed. Exact outputs and hashes are recorded in the evidence sidecar.
 
 ## Feedback loops run
-The conductor ran the task's bounded verification commands, a fresh-context review, and ${postMerge.length} post-merge check(s).
+The conductor ran ${result.continuation?.iterations.length ?? 1} implementation turn(s), the task's bounded verification commands, a fresh-context review, and ${postMerge.length} post-merge check(s). Per-turn verification outputs are retained in the evidence sidecar.
 
 ## Files changed
 ${changedFiles.map((file) => `- ${file}`).join('\n')}
@@ -798,7 +859,24 @@ No declared stop condition occurred.
 Automated task and integration evidence passed. Human QA remains governed by the later EWAI delivery gate.
 `;
   writeFileSync(reportPath, report, 'utf8');
-  return [reportPath, evidencePath, reviewPath, ...commands.map(command => resolve(delivery.deliveryRoot, command.output_path))];
+  return [reportPath, evidencePath, reviewPath, ...commands.map(command => resolve(delivery.deliveryRoot, command.output_path)),
+    ...(continuation?.iterations ?? []).filter(entry => entry.verification).map(entry => resolve(delivery.deliveryRoot, entry.verification.output_path))];
+}
+
+// Only assistant/result messages can signal a blocker. Tool output may quote it.
+function workerReportedBlocker(output) {
+  const blocked = value => typeof value === 'string' && /^EWAI_BLOCKED:/m.test(value);
+  if (blocked(output)) return true;
+  for (const line of String(output ?? '').split('\n')) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    if (event?.type === 'item.completed' && event.item?.type === 'agent_message' && blocked(event.item.text)) return true;
+    if (event?.type === 'result' && blocked(event.result)) return true;
+    const message = event?.type === 'assistant' ? event.message : event?.role === 'assistant' ? event : null;
+    if (message && (blocked(message.content) || Array.isArray(message.content)
+      && message.content.some(part => part?.type === 'text' && blocked(part.text)))) return true;
+  }
+  return false;
 }
 
 async function implementTask(projectRoot, run, task, provider, dependencies = {}) {
@@ -806,9 +884,20 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
   const paths = pathsFor(projectRoot, run.id);
   const repository = repositoryForTask(run, task);
   const attempt = Number(run.tasks?.[task.id]?.attempt ?? 0) + 1;
+  const loop = task.ralph_loop?.allowed === true;
+  const maxIterations = loop ? task.ralph_loop.max_iterations : 1;
+  const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
+  const deadline = monotonicNow() + run.timeoutMs;
+  const remainingTaskMs = () => {
+    if (!loop) return run.timeoutMs;
+    const remaining = Math.floor(deadline - monotonicNow());
+    if (remaining < 1) throw new Error(`${task.id} exhausted its task deadline.`);
+    return remaining;
+  };
+  const continuation = { enabled: loop, maxIterations, iterations: [] };
   const worktree = resolve(paths.worktreesRoot, run.id, repository.name, `${task.id}-attempt-${attempt}`);
   const actualBranch = taskBranch(repository.root, run, task, attempt);
-  const logRoot = resolve(paths.runRoot, 'tasks', task.id);
+  const logRoot = resolve(paths.runRoot, 'tasks', task.id, `attempt-${attempt}`);
   let lease = null;
   try {
     lease = acquireExecutionLease(projectRoot, run.intentId, {
@@ -832,50 +921,65 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
       task.red_green_refactor.red_command,
       worktree,
       resolve(logRoot, 'red.txt'),
-      run.timeoutMs, projectRoot, run, task,
+      remainingTaskMs(), projectRoot, run, task,
     );
     red.stage = 'red';
     if (red.exitCode === 0) throw new Error(`${task.id} red command already passes; the task contract is stale and must be reconciled.`);
-    taskState(run, task, { status: 'implementing' });
-    saveRun(paths, run);
-    event(projectRoot, run, `Agent implementing ${task.id}.`, `${provider} · ${task.name}`);
-    const implementationEvidence=provider==='grok'?prepareGrokTaskEvidence(projectRoot,worktree,task,{mode:'implementation',commands:[red]}):null;
-    const invocation = buildProviderInvocation(provider, {
-      cwd: worktree,
-      prompt: taskPrompt(projectRoot, task, repository,implementationEvidence),
-      grokEvidence:implementationEvidence,
-      task,
-      timeoutMs: run.timeoutMs,
-      mode: 'implementation',
-      codingPolicy:run.codingPolicy,policyDigest:run.codingPolicyDigest,policyRoot:projectRoot,
-    });
-    invocation.logPath = resolve(logRoot, 'implementation.log');
-    const result = await invokeControlled(projectRoot, run, task, invocation, invoke);
-    if (requireRun(projectRoot, run.id).run.desiredState === 'cancelled') {
-      throw new Error('AFK run was cancelled while the task agent was active.');
-    }
-    if (git(worktree, ['rev-parse', 'HEAD']) !== baseHead) {
-      throw new Error(`${task.id} created a commit; commits and merges belong to the conductor.`);
+    let green;
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+      const control = requireRun(projectRoot, run.id).run;
+      if (control.desiredState === 'cancelled' || iteration > 1 && control.desiredState === 'paused') throw new Error(`AFK continuation stopped: ${control.desiredState}.`);
+      const timeoutMs = remainingTaskMs();
+      heartbeatExecutionLease(projectRoot, lease.id, {
+        token: lease.token, durationMs: Math.min(86_400_000, timeoutMs + 10 * 60 * 1000),
+      });
+      taskState(run, task, { status: 'implementing', continuation });
+      saveRun(paths, run);
+      event(projectRoot, run, `Agent implementing ${task.id}.`, `${provider} · iteration ${iteration}/${maxIterations}`);
+      const prior = continuation.iterations.at(-1)?.verification;
+      const feedback = prior
+        ? `\nCONTINUATION ${iteration}/${maxIterations}: the previous turn ended, but the task is incomplete. Continue from the files already in this worktree. The declared green command exited ${prior.exitCode}. Read its captured output at ${prior.outputPath}, repair only within write_set and recheck the declared tests. A summary or completion promise is not completion.`
+        : '';
+      if (prior && sha256(readFileSync(prior.outputPath)) !== prior.outputSha256) throw new Error('Continuation verification output changed; inspect preserved evidence.');
+      const continuationPrompt = (loop ? '\nWork to completion within this task. If a stop condition or owner decision prevents completion, end with EWAI_BLOCKED: followed by the reason.' : '') + feedback;
+      const implementationEvidence = provider === 'grok' ? prepareGrokTaskEvidence(projectRoot, worktree, task, { mode: 'implementation', commands: [red, ...(green ? [green] : [])] }) : null;
+      const invocation = buildProviderInvocation(provider, {
+        cwd: worktree, prompt: taskPrompt(projectRoot, task, repository, implementationEvidence) + continuationPrompt,
+        grokEvidence: implementationEvidence, task, timeoutMs: remainingTaskMs(), mode: 'implementation',
+        codingPolicy: run.codingPolicy, policyDigest: run.codingPolicyDigest, policyRoot: projectRoot,
+      });
+      invocation.logPath = resolve(logRoot, loop ? `implementation-iteration-${iteration}.log` : 'implementation.log');
+      const result = await invokeControlled(projectRoot, run, task, invocation, invoke);
+      const entry = { iteration, providerExitCode: result.exitCode, executionStopped: result.executionStopped === true };
+      continuation.iterations.push(entry);
+      taskState(run, task, { continuation });
+      atomicJson(resolve(logRoot, 'continuation.json'), continuation);
+      saveRun(paths, run);
+      if (requireRun(projectRoot, run.id).run.desiredState === 'cancelled' || result.cancelled) throw new Error('AFK run was cancelled while the task agent was active.');
+      if (git(worktree, ['rev-parse', 'HEAD']) !== baseHead) throw new Error(`${task.id} created a commit; commits and merges belong to the conductor.`);
+      if (result.timedOut) throw new Error(`${provider} exceeded the task timeout.`);
+      if (result.exitCode !== 0) throw new Error(`${provider} exited ${result.exitCode}; see ${relative(projectRoot, result.logPath)}.`);
+      // Check scope before running tests or giving another worker turn authority.
+      const outside = changedPaths(worktree).filter(path => !allowedPath(path, task));
+      if (outside.length) throw new Error(`${task.id} changed files outside its write_set: ${outside.join(', ')}.`);
+      if (loop && workerReportedBlocker(result.output)) throw new Error(`${task.id} worker reported a blocker; inspect its preserved log.`);
+      green = await executeCommand(task.red_green_refactor.green_command, worktree,
+        resolve(logRoot, loop ? `green-iteration-${iteration}.txt` : 'green.txt'), remainingTaskMs(), projectRoot, run, task);
+      green.stage = 'green';
+      entry.verification = green;
+      atomicJson(resolve(logRoot, 'continuation.json'), continuation);
+      taskState(run, task, { continuation });
+      saveRun(paths, run);
+      if (green.exitCode === 0) break;
+      if (!loop) throw new Error(`${task.id} green command failed after implementation.`);
+      if (iteration === maxIterations) throw new Error(`${task.id} reached its continuation iteration limit (${maxIterations}).`);
+      event(projectRoot, run, `Continuing incomplete task ${task.id}.`, `Green verification failed on iteration ${iteration}; remaining work stays in its isolated worktree.`);
     }
-    if (result.timedOut) throw new Error(`${provider} exceeded the ${run.timeoutMs}ms task timeout.`);
-    if (result.exitCode !== 0) throw new Error(`${provider} exited ${result.exitCode}; see ${relative(projectRoot, result.logPath)}.`);
-    heartbeatExecutionLease(projectRoot, lease.id, {
-      token: lease.token,
-      durationMs: Math.min(86_400_000, run.timeoutMs + 10 * 60 * 1000),
-    });
-    const green = await executeCommand(
-      task.red_green_refactor.green_command,
-      worktree,
-      resolve(logRoot, 'green.txt'),
-      run.timeoutMs, projectRoot, run, task,
-    );
-    green.stage = 'green';
-    if (green.exitCode !== 0) throw new Error(`${task.id} green command failed after implementation.`);
     const refactor = await executeCommand(
       task.red_green_refactor.green_command,
       worktree,
       resolve(logRoot, 'refactor.txt'),
-      run.timeoutMs, projectRoot, run, task,
+      remainingTaskMs(), projectRoot, run, task,
     );
     refactor.stage = 'refactor';
     if (refactor.exitCode !== 0) throw new Error(`${task.id} refactor verification failed.`);
@@ -903,7 +1007,7 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
       prompt: reviewPrompt(projectRoot, task, implementationCommit,reviewEvidence),
       grokEvidence:reviewEvidence,
       task,
-      timeoutMs: run.timeoutMs,
+      timeoutMs: remainingTaskMs(),
       mode: 'review',
       codingPolicy:run.codingPolicy,policyDigest:run.codingPolicyDigest,policyRoot:projectRoot,
     });
@@ -916,6 +1020,7 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
     if (review.timedOut || review.exitCode !== 0 || !/^VERDICT:\s*PASS\s*$/im.test(review.output)) {
       throw new Error(`Fresh-context review did not pass; see ${relative(projectRoot, review.logPath)}.`);
     }
+    review.claimResults = parseCompletionClaimReview(review.output, task.completion_evidence ?? [], {observed:true,requirements:task.completion_requirements ?? []});
     authorityChecks.get(run)?.({ stage: 'accept', mode: 'review' });
     if (git(worktree, ['rev-parse', 'HEAD']) !== implementationCommit || gitDirty(worktree)) {
       throw new Error('Fresh-context review changed the inspected implementation.');
@@ -927,6 +1032,7 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
       token: lease.token,
       durationMs: Math.min(86_400_000, run.timeoutMs + 10 * 60 * 1000),
     });
+    review.reviewResults = reviewResults;
     const branchHead = git(worktree, ['rev-parse', 'HEAD']);
     const reviewerIdentity = reviewers.map(reviewer=>`${reviewer}/${reviewer === provider ? 'fresh-session' : 'independent-cli'}`).join(',');
     taskState(run, task, { status: 'ready-to-integrate', implementationCommit, branchHead, reviewer: reviewerIdentity });
@@ -934,7 +1040,7 @@ async function implementTask(projectRoot, run, task, provider, dependencies = {}
     return {
       task, lease, worktree, branchHead, implementationCommit, review,
       reviewer: reviewerIdentity, verifiedCommands: [red, green, refactor], changedFiles: changed,
-      actualBranch, repository,
+      actualBranch, repository, continuation, remainingTaskMs,
     };
   } catch (error) {
     const control = requireRun(projectRoot, run.id).run;
@@ -960,6 +1066,7 @@ async function integrateTask(projectRoot, run, result) {
   const specsRepository = run.topology.repositories.find((candidate) => candidate.name === run.topology.specsRepository);
   if (!specsRepository) throw new Error('AFK run has no configured SPECS repository.');
   const paths = pathsFor(projectRoot, run.id);
+  result.remainingTaskMs?.();
   taskState(run, task, { status: 'integrating' });
   saveRun(paths, run);
   event(projectRoot, run, `Integrating ${task.id}.`, 'The orchestrator is merging sequentially and running post-merge checks.');
@@ -982,7 +1089,7 @@ async function integrateTask(projectRoot, run, result) {
       const untracked = git(root, ['ls-files', '--others', '--exclude-standard', '-z']).split('\0').filter(Boolean);
       if (git(root, ['rev-parse', 'HEAD']) !== baseline.head || git(root, ['branch', '--show-current']) !== baseline.branch
         || stagedDelta.some(path => !staged || !owned(path) || sha256(execFileSync('git', ['show', `:${path}`],
-          { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] })) !== ownedEvidence.get(resolve(root, path)))
+          { cwd: root, stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: Math.max(1024 * 1024, statSync(resolve(root, path)).size + 1024) })) !== ownedEvidence.get(resolve(root, path)))
         || [...workingDelta, ...untracked].some(path => !owned(path))) {
         integrationConflict = true;
         throw new Error('Repository changed outside the owned integration; preserve the checkout for review.');
@@ -1008,7 +1115,7 @@ async function integrateTask(projectRoot, run, result) {
     const postMerge = [];
     for (const [index, command] of (task.merge?.post_merge_checks ?? []).entries()) {
       const outputPath = resolve(delivery.deliveryRoot, 'tasks', task.id, 'evidence', `post-merge-${index + 1}.txt`);
-      const check = await executeCommand(command, repository.root, outputPath, run.timeoutMs, projectRoot, run, task);
+      const check = await executeCommand(command, repository.root, outputPath, result.remainingTaskMs?.() ?? run.timeoutMs, projectRoot, run, task);
       const evidencePath = relative(delivery.deliveryRoot, outputPath).replaceAll('\\', '/');
       postMerge.push({ command, exit_code: check.exitCode, output_path: evidencePath, output_sha256: sha256(readFileSync(outputPath)) });
       ownedEvidence.set(realpathSync(outputPath), postMerge.at(-1).output_sha256);
@@ -1145,14 +1252,15 @@ export async function executeAfkRun(projectRoot, runId, dependencies = {}) {
   } catch (error) {
     const control = requireRun(paths.projectRoot, run.id).run;
     run.desiredState = control.desiredState;
-    run.status = control.desiredState === 'cancelled' ? run.unconfirmedExecution ? 'cancel-unknown' : 'cancelled' : 'blocked';
+    run.status = control.desiredState === 'cancelled' ? run.unconfirmedExecution ? 'cancel-unknown' : 'cancelled'
+      : error.message === 'AFK continuation stopped: paused.' && !run.unconfirmedExecution ? 'paused' : 'blocked';
     if (control.desiredState === 'cancelled') run.cancellation = { ...control.cancellation,
       status: run.unconfirmedExecution ? 'unknown' : 'confirmed', settledAt: now() };
     run.pid = null;
     run.messages.push({ at: now(), message: error.message });
     run.executionStopped = !run.unconfirmedExecution;
     if (!run.unconfirmedExecution) abandonExecutionLeasesForRun(paths.projectRoot, run.id, { outcome: 'conductor-blocked' });
-    event(paths.projectRoot, run, 'Unattended Build is blocked.', error.message, 'blocked', true);
+    event(paths.projectRoot, run, run.status === 'paused' ? 'Unattended Build safely paused.' : 'Unattended Build is blocked.', error.message, run.status === 'paused' ? 'progress' : 'blocked', run.status !== 'paused');
     saveRun(paths, run);
     return run;
   } finally { authorityChecks.delete(run); }

package/src/runtime/provider-adapters.mjs

@@ -152,6 +152,7 @@ export function invokeProvider(invocation, options = {}) {
   const maxCapture = Number(options.maxCaptureBytes ?? 1024 * 1024);
 
   return new Promise((resolvePromise, reject) => {
+    output.once('error', reject);
     const child = spawn(invocation.command, invocation.args, {
       cwd: invocation.cwd,
       env: options.env ?? process.env,
@@ -204,8 +205,9 @@ export function invokeProvider(invocation, options = {}) {
         try { process.kill(-child.pid, 0); kill('SIGKILL'); }
         catch (error) { processGroupStopped = error.code === 'ESRCH'; }
       }
-      output.end();
-      resolvePromise({
+      // Return only after the captured log has finished flushing. Callers hash
+      // this file immediately; a process exit alone does not settle its stream.
+      output.end(() => resolvePromise({
         provider: invocation.provider,
         exitCode: exitCode ?? -1,
         signal: signal ?? '',
@@ -223,7 +225,7 @@ export function invokeProvider(invocation, options = {}) {
           invocation.provider,
           options.providerUsage ?? invocation.providerUsage,
         ),
-      });
+      }));
     });
     options.signal?.addEventListener('abort', cancel, { once: true });
     if (options.signal?.aborted) cancel();

package/src/task-graph.mjs

@@ -110,6 +110,41 @@ function evidenceFile(root, configuredPath, expectedHash, label, errors) {
   }
 }
 
+// Semantic support is assessed by the existing fresh reviewer; the host enforces
+// complete, explicit results rather than inferring every claim from one green exit.
+export function validateCompletionClaims(results, names, options = {}) {
+  const errors = [], expected = new Set(names), seen = new Set();
+  if (!Array.isArray(results)) return ['completion claim validation results are missing'];
+  for (const result of results) {
+    if (!result || !expected.has(result.name)) errors.push('completion claim validation contains an unknown claim');
+    if (seen.has(result?.name)) errors.push('completion claim validation contains a duplicate claim');
+    seen.add(result?.name);
+    if (result?.status !== 'pass' || !text(result?.support)) errors.push('completion claim validation requires a passing result with specific supporting evidence');
+  }
+  if (options.observed) for (const result of results) {
+    const requiredType = options.requirements?.find(item => item.name === result?.name)?.evidence_type ?? 'behaviour';
+    const observation = result?.observation, challenge = result?.challenge;
+    if (!['behaviour','configuration','command-result','review-result'].includes(requiredType) || observation?.evidence_type !== requiredType) errors.push('completion claim evidence type does not match its planned obligation');
+    if (!['expected','actual','evidence'].every(key => typeof observation?.[key] === 'string' && observation[key].trim())) errors.push('completion claim requires expected and actual observed result with evidence');
+    if (!['attempt','result'].every(key => typeof challenge?.[key] === 'string' && challenge[key].trim())) errors.push('completion claim requires a concrete challenge attempt and result');
+  }
+  for (const name of expected) if (!seen.has(name)) errors.push(`completion claim validation is missing: ${name}`);
+  return errors;
+}
+
+export function parseCompletionClaimReview(output, names, options = {}) {
+  const results = [];
+  for (const line of String(output).split(/\r?\n/)) {
+    const match = /^COMPLETION_CHECK:\s*(.+)$/.exec(line.trim());
+    if (!match) continue;
+    try { results.push(JSON.parse(match[1])); }
+    catch { throw new Error('Completion claim validation contains malformed JSON.'); }
+  }
+  const errors = validateCompletionClaims(results, names, options);
+  if (errors.length) throw new Error(errors.join('; '));
+  return results;
+}
+
 export function validateTaskEvidence(deliveryRoot, task) {
   const root = resolve(deliveryRoot);
   const configured = text(task?.evidence_path);
@@ -129,7 +164,12 @@ export function validateTaskEvidence(deliveryRoot, task) {
       errors.push(`structured task evidence is not valid JSON: ${error.message}`);
     }
     if (evidence) {
-      if (evidence.schema !== 'ewai.task-evidence/v1') errors.push('schema must be ewai.task-evidence/v1');
+      if (!['ewai.task-evidence/v1', 'ewai.task-evidence/v2', 'ewai.task-evidence/v3'].includes(evidence.schema)) errors.push('unsupported task evidence schema');
+      const observedValidation = evidence.schema === 'ewai.task-evidence/v3' || task.claim_validation?.version === 3;
+      const claimOptions = {observed:observedValidation,requirements:task.completion_requirements ?? []};
+      if (task.claim_validation?.version === 3 && evidence.schema !== 'ewai.task-evidence/v3') errors.push('required observed claim validation cannot use earlier evidence');
+      const claimValidation = ['ewai.task-evidence/v2','ewai.task-evidence/v3'].includes(evidence.schema) || task.claim_validation?.required === true;
+      if (task.claim_validation?.required === true && !['ewai.task-evidence/v2','ewai.task-evidence/v3'].includes(evidence.schema)) errors.push('required completion claim validation cannot use legacy evidence');
       if (evidence.task_id !== task.id) errors.push(`task_id must be ${task.id}`);
       if (text(evidence.task_branch)) {
         if (evidence.task_branch !== task.branch) errors.push(`task_branch must be ${task.branch}`);
@@ -166,6 +206,24 @@ export function validateTaskEvidence(deliveryRoot, task) {
         }
         evidenceFile(root, command.output_path, command.output_sha256, `${command.stage || 'command'} output`, errors);
       }
+      if (evidence.continuation) {
+        const history = evidence.continuation;
+        const enabled = task.ralph_loop?.allowed === true;
+        const limit = enabled ? task.ralph_loop.max_iterations : 1;
+        if (history.enabled !== enabled || history.max_iterations !== limit) errors.push('continuation budget must match the task contract');
+        const iterations = history.iterations;
+        if (!Array.isArray(iterations) || !iterations.length || iterations.length > limit) {
+          errors.push('continuation history must be non-empty and within its iteration budget');
+        } else {
+          for (const [index, iteration] of iterations.entries()) {
+            const check = iteration?.verification;
+            if (iteration?.iteration !== index + 1 || iteration?.provider_exit_code !== 0 || iteration?.execution_stopped !== true) errors.push('continuation iteration must record an ordered, successful, confirmed stopped worker');
+            if (!check || check.command !== task.red_green_refactor?.green_command || !Number.isInteger(check.exit_code)
+              || (index === iterations.length - 1 ? check.exit_code !== 0 : check.exit_code === 0)) errors.push('continuation verification must retain failures before the final passing green');
+            if (check) evidenceFile(root, check.output_path, check.output_sha256, 'continuation verification output', errors);
+          }
+        }
+      }
       const review = evidence.review ?? {};
       if (review.fresh_context !== true) errors.push('review.fresh_context must be true');
       if (review.tests_reviewed_first !== true) errors.push('review.tests_reviewed_first must be true');
@@ -174,10 +232,34 @@ export function validateTaskEvidence(deliveryRoot, task) {
       evidenceFile(root, review.evidence_path, review.evidence_sha256, 'review evidence', errors);
       const checks = Array.isArray(evidence.completion_checks) ? evidence.completion_checks : [];
       const checksByName = new Map(checks.map((check) => [text(check.name), check]));
+      if (claimValidation) {
+        if (!errors.length) {
+          try {
+            const captured = JSON.parse(readFileSync(resolve(root, review.evidence_path), 'utf8'));
+            if (captured.schema !== 'ewai.claim-review/v1' || !Array.isArray(captured.reviews) || !captured.reviews.length) throw new Error('captured claim reviews are missing');
+            const identities = String(review.reviewer).split(',').map(value => value.trim().split('/')[0]);
+            if (captured.reviews.length !== identities.length || new Set(captured.reviews.map(item => item.reviewer)).size !== identities.length) throw new Error('captured claim reviewer coverage differs');
+            let recorded;
+            for (const item of captured.reviews) {
+              if (!identities.includes(item.reviewer)) throw new Error('unknown captured claim reviewer');
+              recorded = parseCompletionClaimReview(item.output, list(task.completion_evidence), claimOptions);
+            }
+            if (JSON.stringify(recorded) !== JSON.stringify(review.claim_results)) throw new Error('claim results differ from captured review');
+          } catch (error) { errors.push(`completion claim validation differs from captured review: ${error.message}`); }
+        }
+        errors.push(...validateCompletionClaims(review.claim_results, list(task.completion_evidence), claimOptions));
+        if (checks.length !== list(task.completion_evidence).length || checksByName.size !== checks.length) errors.push('completion claim validation must cover exactly the planned checks');
+      }
       for (const planned of list(task.completion_evidence)) {
         const check = checksByName.get(planned);
         if (!check || check.status !== 'pass') errors.push(`planned completion check has no passing evidence: ${planned}`);
-        else evidenceFile(root, check.evidence_path, check.evidence_sha256, `completion check ${planned}`, errors);
+        else {
+          evidenceFile(root, check.evidence_path, check.evidence_sha256, `completion check ${planned}`, errors);
+          if (claimValidation) {
+            const result = Array.isArray(review.claim_results) ? review.claim_results.find(item => item?.name === planned) : null;
+            if (!result || check.support !== result.support || observedValidation && (JSON.stringify(check.observation) !== JSON.stringify(result.observation) || JSON.stringify(check.challenge) !== JSON.stringify(result.challenge)) || check.evidence_path !== review.evidence_path || check.evidence_sha256 !== review.evidence_sha256) errors.push(`completion claim validation is not bound to its supporting review: ${planned}`);
+          }
+        }
       }
     }
   }
@@ -412,8 +494,8 @@ export function validateTaskGraph(deliveryRoot, options = {}) {
         if (!list(task.completion_evidence).length) add('afk-completion-evidence-missing', `${id} requires completion evidence.`, id);
       }
       if (task?.ralph_loop?.allowed === true) {
-        if (!Number.isInteger(task.ralph_loop.max_iterations) || task.ralph_loop.max_iterations < 1) {
-          add('ralph-loop-unbounded', `${id} Ralph loop requires a finite positive max_iterations.`, id);
+        if (!Number.isInteger(task.ralph_loop.max_iterations) || task.ralph_loop.max_iterations < 1 || task.ralph_loop.max_iterations > 100) {
+          add('ralph-loop-unbounded', `${id} Ralph loop requires max_iterations between 1 and 100.`, id);
         }
         if (!text(task.ralph_loop.completion_promise)) add('ralph-loop-promise-missing', `${id} Ralph loop requires a completion promise.`, id);
       }
@@ -421,6 +503,16 @@ export function validateTaskGraph(deliveryRoot, options = {}) {
       if (task?.review?.fresh_context_required !== true) add('fresh-review-required', `${id} requires fresh-context review.`, id);
     }
 
+    for (const task of tasks) {
+      if (task.completion_requirements !== undefined) {
+        const requirements = task.completion_requirements;
+        const names = Array.isArray(requirements) ? requirements.map(item => item?.name) : [];
+        if (!Array.isArray(requirements) || names.length !== list(task.completion_evidence).length || new Set(names).size !== names.length || names.some(name => !list(task.completion_evidence).includes(name))
+          || requirements.some(item => !['behaviour','configuration','command-result','review-result'].includes(item?.evidence_type))) add('completion-requirements-invalid', `${task.id} requires one valid evidence type per completion claim.`, task.id);
+      }
+      if (task.claim_validation?.version !== undefined && task.claim_validation.version !== 3) add('claim-validation-version-invalid', `${task.id} declares an unsupported claim validation version.`, task.id);
+    }
+
     const ledgerClaims = recordsFrom(claimLedger, ['implementation_claims', 'claims']);
     const actionableClaims = new Set(ledgerClaims.filter(actionableClaim).map(recordId).filter(Boolean));
     if (!ledgerClaims.length) add('claim-ledger-empty', 'The Claim Ledger must contain implementation claims.', graph.source?.claim_ledger);