@awak-app/simy-cli 0.5.10 → 0.5.11

package/README.md

@@ -424,6 +424,19 @@ Deploy this CLI and the web capability proxy before enabling the backend scope
 requirement. Older clients receive an explicit upgrade error, never an expanded
 organization-wide bundle.
 
+### Minimum functional completion
+
+Every CLI coding-loop promotion now requires a current two-layer observation
+matrix: the requested operation and result, plus independently checked final
+postcondition and integration. See the [minimum completion contract](src/codex-plugins/simy/skills/agentic-delivery-loop/references/minimum-completion.md)
+for the executable format. Missing mappings, mismatching observations, changed
+artifacts or stale revisions block promotion even when the executor reports
+success. Independent review checks original-request coverage and the test oracle.
+
+Existing v2 run history is retained; resumed/rechecked runs need the new evidence.
+The same checker ships in the standalone Delivery Loop skill, but it does not
+control the host's final response or establish deployment completion.
+
 ### Submit repaired local delivery evidence to SQM
 
 The bundled Delivery Loop maintains an external acceptance checklist with separate
@@ -444,3 +457,13 @@ session. `--dry-run` previews the exact document without uploading it. See the
 [local evidence contract](src/codex-plugins/simy/skills/agentic-delivery-loop/references/local-sqm-evidence.md).
 The receipt identifies the source digest and analysis job; it is not a declaration
 that an incident or blocking rule has been published.
+
+## Delivery Loop shared specification
+
+The [Delivery Loop system specification](docs/systems/delivery-loop/README.md)
+explains its purpose, As-Is and proposed To-Be through twelve linked views. Keep
+these as shared team documents; each change updates affected views and checks
+cross-view consistency. The skill requires independent design, implementation-to-
+To-Be and PR reviews, plus explicitly opted-in SQM before and after PR creation.
+The [workflow reference](src/codex-plugins/simy/skills/agentic-delivery-loop/references/shared-system-specifications.md)
+explains baseline updates, historical regression coverage and evidence limits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -40,7 +40,7 @@
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js",
-    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js",
+    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js",
     "check:package": "node ./scripts/check-package-contents.js",
     "build:macos-installer:dev": "bash packaging/build-macos-arm64.sh --unsigned-dev",
     "build:macos-installer": "bash packaging/build-macos-arm64.sh --production",

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.10";
+export const CLI_VERSION = "0.5.11";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/skills/agentic-delivery-loop/SKILL.md

@@ -7,8 +7,11 @@ description: Drive complex repository changes from a frozen success charter and
 
 Use one Codex task as the controller for the complete delivery lifecycle. Shell,
 browser, API, log, database, and artifact operations may all run in the same
-task. Treat implementer, user actor, evidence collector, and verifier as logical
-roles; they do not require separate agents.
+task. The controller coordinates implementation and evidence collection. Every
+review verdict must come from an independent agent/session that did not author
+the reviewed implementation or specification; self-checks are useful diagnostics,
+not review approval. Give reviewers original sources and raw evidence, not a
+prescribed conclusion. The controller retains transition and authority ownership.
 
 ## Confirm the delivery level in chat
 
@@ -51,6 +54,31 @@ Do not silently weaken explicit conditions. Add discoveries as a charter patch.
 A scope or success-condition change needs user direction when it materially
 changes the requested result.
 
+## Maintain the system's shared specification
+
+Before implementation, read [shared system specifications](references/shared-system-specifications.md).
+Find the team's canonical specification for this system; create it once if absent.
+Record purpose, beneficiary, current pain, intended user experience and observable
+success. Reference the current As-Is revision and update only affected To-Be views.
+Maintain the twelve-view inventory, stable IDs and cross-view impact links in the
+shared source, not twelve new task-local copies. Unaffected views retain their
+version; unknown As-Is facts remain unknown. Review changes through the team's
+normal version control and preserve concurrent work.
+
+Use independent agents for design review (including consistency across diagram
+kinds), implementation-to-To-Be review, and final PR/evidence review at **every**
+level. Reviewers inspect the full affected path and unchanged linked views. Fix
+findings and obtain independent re-review. A changed requirement or baseline
+invalidates affected approval; do not rewrite To-Be to disguise a failed result.
+
+PR creation and post-creation verification include the SQM loop described in the
+reference. Announce this requirement when starting Delivery Loop. Running SQM
+still follows its explicit opt-in/authority rules; if opt-in or access is absent,
+retain the unmet SQM gate and continue independent work. Ordinary PR work outside
+Delivery Loop does not activate this workflow. Record known incident coverage and
+unknown coverage separately; a green proof with no applicable rules does not prove
+that historical failures cannot recur.
+
 ## Maintain the acceptance checklist outside the conversation
 
 Before implementation, read [acceptance evidence](references/acceptance-evidence.md)
@@ -77,6 +105,22 @@ gate and before issuing the completion receipt. A missing, pending, failed, stal
 or unverifiable applicable row prevents promotion. Matrix completeness is one
 necessary gate, not proof of deployment, authority, or overall completion.
 
+## Enforce the minimum functional floor
+
+At every delivery level, use [minimum completion](references/minimum-completion.md)
+for requested-outcome verification. Map all requirements to implementation and
+actual operation/result plus independent postcondition/integration observations.
+For persistence, require reload/session return and stored values/ownership. A
+working control, success message or HTTP 200 alone is insufficient.
+
+The bundled minimum checker extends the acceptance matrix with structured
+observations. Compare the original request to the AC-N list independently so
+omitted requirements cannot disappear before validation. A missing, failed or
+stale floor check prevents verified completion at any level. The CLI now enforces
+this before implementation/PR promotion and on recheck; the standalone command
+validates evidence but cannot intercept the host application's final response.
+Do not call a standalone result host-enforced completion or overall delivery.
+
 ## Check existing rules before implementation
 
 Before implementation, publish a compact rule inventory in the charter record.
@@ -221,13 +265,13 @@ Run focused regression tests first, then formatting, lint, type checking, unit
 tests, and the actual affected runtime. Apply only the relevant lanes from
 [the change-boundary matrix](references/change-boundary-matrix.md).
 
-For medium/high-risk work, run an independent blocker/P1 review after local
-verification. Fix findings narrowly and re-review only the fixes and directly
-affected behavior.
+After local verification at every level, have an independent agent compare the
+implementation and observed user outcomes to the frozen To-Be and original request.
+Include cross-view consistency, omissions and applicable historical regressions.
+Fix findings narrowly and independently re-review the affected behavior.
 
 Give the independent verifier the acceptance sources and raw evidence, not just
-the implementer's summary. Use a separate session/agent as required by risk and
-repository rules; another model can help but model count is not quality evidence.
+the implementer's summary. Use a separate session/agent for every review; another model can help but model count is not quality evidence.
 
 Treat deleted tests, weakened assertions, changed expected values, disabled
 checks, and relaxed CI or security policy as changes to the verification
@@ -239,9 +283,12 @@ production configuration, and CI or security-policy changes.
 
 ### 4. Coordinate through Draft PR and integration state
 
+Before creating a PR, pass the independent To-Be review and pre-PR SQM loop.
 After authority for the required remote changes exists, record reproduction,
 tests, evidence, companion revisions, skipped checks, and remaining gates in the
-Draft PR. Before Ready or merge, combine the latest base with required companion
+Draft PR. After creation, run a fresh SQM loop bound to the actual PR head/base
+and have an independent agent review the PR diff, proofs and incident coverage.
+Before Ready or merge, combine the latest base with required companion
 and parallel changes, rerun the affected path, and confirm current CI and
 mergeability. Without combined-state proof, report `pr_only_verified`, not
 `integration_verified`.
@@ -295,7 +342,9 @@ and validation ordering still require Delivery Loop execution controls.
 ### 8. Clean up and issue the receipt
 
 Remove scoped fixtures and prove the residual count is zero. Deliver a compact
-completion receipt containing repository revisions, PR and CI, independent
+completion receipt containing shared-spec baseline/To-Be revisions and status,
+cross-view and implementation review results, pre/post-PR SQM proofs and historical
+coverage gaps, repository revisions, PR and CI, independent
 review, container/runtime results, local Chrome evidence, merge and deployment
 identity, deployed Chrome evidence, artifacts, cleanup, skipped gates, and
 residual risk. Convert recurring findings into the smallest maintainable rule,

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/acceptance-evidence.md

@@ -126,5 +126,6 @@ a collector told the truth, a criterion is adequate, or a system is deployed.
 Hashes are not signatures. The controller must protect the frozen digest, verify
 requirement coverage and genuine non-applicability, and inspect raw evidence.
 Independent review checks the oracle and findings; the validator is an additional
-gate within this skill, not a globally installed hook or the CLI orchestrator's
-completion authority.
+gate within this skill, not a globally installed hook. The CLI now additionally
+uses [minimum completion](minimum-completion.md) to enforce current functional
+evidence at its promotion boundary; this basic validator alone is insufficient.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/delivery-levels.md

@@ -39,7 +39,7 @@ messages.
 | --- | --- | --- | --- |
 | 1 | Maximum assurance | Authentication, payments, destructive or irreversible changes, production security/configuration, sensitive data, and risky migrations | Exercise all affected and adjacent invariants, failure/recovery and rollback paths; require the broadest applicable independent review and repository gates. |
 | 2 | Protected | Persistence, permissions, shared contracts, external side effects, cross-repository changes, and medium-risk migrations | Verify both evidence layers for every affected outcome, shared boundaries, retry/idempotency and recovery; require independent review of the change and affected integrations. |
-| 3 | Balanced (default) | Normal features and bug fixes with bounded, reversible impact | Run focused regressions, applicable static checks, the real affected runtime and main user journey; use risk- and repository-required independent review. |
+| 3 | Balanced (default) | Normal features and bug fixes with bounded, reversible impact | Run focused regressions, applicable static checks, the real affected runtime and main user journey; require independent design/To-Be/PR review, scoped to the affected path. |
 | 4 | Fast | Small, isolated, reversible UI or implementation changes | Run the direct regression and real affected path; add broader checks only for touched shared boundaries; keep mandatory review and evidence gates. |
 | 5 | Fastest | Copy, documentation, comments, metadata, or similarly trivial changes with no runtime/data/security effect | Verify the changed artifact, final diff, packaging/link integrity where applicable, and every repository-mandated check; do not claim untested runtime behavior. |
 
@@ -69,8 +69,12 @@ always choose a lower numbered, safer level.
 Every level preserves:
 
 - frozen success criteria and independent acceptance sources;
+- shared system As-Is/To-Be, cross-view consistency and independent agent reviews;
+- pre/post-PR SQM gates under explicit opt-in, with historical coverage reported;
 - honest state transitions and current revision/context binding;
 - required user/system evidence for applicable outcomes;
 - protection of user work, secrets, data integrity, and tenant boundaries;
 - explicit failure, pending, skipped, and non-applicable reporting;
 - repository-required tests, reviews, CI, and approval/authority boundaries.
+
+All levels retain the [minimum functional floor](minimum-completion.md): requirement mapping, actual operation/result, and independent postcondition/integration observations. Persistence requires reload and stored-state checks. Non-runtime work verifies its real consumer/artifact; no imaginary DB or API checks are added. The minimum checker has no level-based bypass.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/minimum-completion.md

@@ -0,0 +1,137 @@
+# Minimum functional completion
+
+Every level must prove that the requested work exists, actual operations reach
+the intended result, and necessary persistence/integration works. Speed changes
+adjacent verification breadth, never this floor. The CLI requires this matrix for
+all coding-loop attempts, including legacy v2 resumes/rechecks. No opt-out field
+in an executor result or assurance-level selection disables the gate.
+
+## Collect real observations
+
+Before implementation, reconcile the original request, acceptance criteria and
+planned operations. Preserve every requested outcome; a missing requirement must
+be added through the controller's charter process, not omitted from the matrix.
+The independent auditor compares original-request coverage and checks the oracle
+against raw evidence. Machine mapping checks cannot discover an omitted idea in
+natural language or authenticate what an evidence collector observed.
+
+For each AC-N record implementation_refs (repository-relative file paths), then:
+
+- user/operation: operate the actual UI or CLI/consumer. Expected is true; actual
+  is whether the intended operation really executed, not just whether a click
+  command succeeded. Include screenshots/traces where relevant.
+- user/result: observe the requested visible outcome, including reload and session
+  return for a saving feature. Compare expected and actual values.
+- system/postcondition: independently inspect the final state; for persistence,
+  include the saved values and ownership, not a toast or HTTP status.
+- system/integration: inspect the necessary combined path through APIs, storage,
+  workers or consumers. Job acceptance is not job completion. Use the same input
+  and execution context across layers; cite trace/runtime identities in subject
+  and additional evidence.
+
+For document-only work these mean opening the actual consumer and checking content,
+links and packaged bytes. No DB/API is required if none participates. Both generic
+layers remain required; there is no post-failure waiver. Tests, permissions or
+runtime unavailable means pending/blocked. Never fabricate expected/actual equality.
+
+## Executable contract
+
+`check-minimum-completion.mjs` and `check-acceptance.mjs` ship together under the
+installed skill's scripts directory. The CLI instruction supplies controller input
+JSON; save it as charter.json for the standalone command. It contains id,
+requirement, repository, acceptance_criteria, completion_contract (version 2), and
+thread_state.original_request. For standalone use the controller freezes the same
+fields independently of implementation. The matrix otherwise follows
+[acceptance evidence](acceptance-evidence.md).
+
+To derive the frozen specification/context, import `minimumCharter(charter)` and
+`minimumContext(charter, fullHeadSha)` from the minimum script; import `sha256`
+and `contextDigest` from check-acceptance.mjs. The charter digest is
+`sha256(Buffer.from(JSON.stringify(minimumCharter(charter))))`.
+The context digest is `contextDigest(minimumContext(charter, fullHeadSha))`.
+The CLI derives both itself; it never takes expected digests from executor output.
+
+The current CLI context is one local checkout, its full HEAD, controller charter
+ID and request digest. A clean checkout is required and checked again after
+collection. This is not automatic multi-repository deployment identity discovery.
+For companion services, verify the combined path and record the pinned service
+identities in the evidence; the independent reviewer must validate their current
+identity. Do not claim that this single-checkout gate automatically re-reads a
+companion service's Git HEAD or production environment.
+
+Every matrix row adds `implementation_refs: ["src/example.js"]`. Each required
+user/system cell's **first** evidence file is JSON with this shape (user example):
+
+```json
+{
+  "criterion_id": "AC-1",
+  "context_sha256": "<current context digest>",
+  "checks": {
+    "operation": {"subject": "Save clicked and request observed for fixture run", "expected": true, "actual": true},
+    "result": {"subject": "Note after reload and session return", "expected": "requested text", "actual": "requested text"}
+  }
+}
+```
+
+The system file uses `postcondition` and `integration` instead. Each has `subject`,
+non-null `expected` and actual observed `actual`. Values may be objects/arrays to
+compare saved values and ownership together. The checker compares values exactly;
+missing fields or mismatches fail regardless of a cell's passed flag. Additional
+cell evidence may contain screenshots or logs; all artifact hashes are validated.
+Keep raw evidence local and use synthetic data, never credentials/personal data.
+
+Store matrix and evidence under ui_evidence_root, or under repository `.artifacts`
+when no root was specified. All artifact paths are relative to the matrix directory.
+Return `delivery_evidence_path` in SIMY_RESULT_JSON, absolute under that root or
+relative to it. Source mappings must resolve to files inside the current repository.
+Evidence must be bounded regular files; path escapes/symlinks are rejected.
+
+Standalone invocation, with controller-owned trusted digests:
+
+```text
+node <installed-skill>/scripts/check-minimum-completion.mjs charter.json matrix.json context.json <trusted-charter-sha256> <trusted-context-sha256>
+```
+
+Exit 0 is evidence_complete; 1 is evidence_incomplete; 2 means invalid/unavailable
+inputs. JSON includes a readable checklist and floor failures. Check the top-level
+status, not only individual base-matrix rows. The standalone checker validates
+mapping structure; only the CLI additionally resolves mappings in its checkout.
+Neither file hashes nor a passed report authenticate the collector or prove an
+oracle matches the original requirement. Independent coverage/oracle review is
+required by the CLI and must inspect the raw evidence. The standalone command
+cannot stop Codex/Claude's final chat response and does not install global hooks.
+
+## State, review and recovery
+
+The CLI's implementation gate includes the minimum report before independent
+review. The review returns coverage_review with requirements_complete,
+unmapped_requirements and a concrete observation. The controller binds that
+review to the matrix digest, then recollects evidence. Changing the matrix after
+review requires a new review; changing HEAD or dirtying the tree invalidates the
+proof. A concurrent call using the same run ID is rejected, including cloned snapshots.
+A repeated start rechecks evidence without executing the implementation again;
+explicit resume remains the repair path. Cross-process
+execution remains subject to existing runner/host ownership controls.
+
+PR recheck clears prior completion flags and reruns the floor. Missing evidence
+never promotes an old successful audit. The old history is retained; do not rewrite
+it as verified under the new floor. Fix the named criterion, collect fresh evidence
+and resume within the retry budget. Reconcile ambiguous external side effects
+before retrying. The minimum pass is a prerequisite for existing CI/review/authority
+gates, not merge, deployment or a complete production delivery.
+
+Rollback: restoring the older CLI removes this additional enforcement. Retain the
+versioned evidence/history and report that limitation; never relabel old evidence
+as verified by this floor. Monitor minimum-completion findings and subsequent
+reviewer-discovered gaps through existing local run records; no new telemetry or
+external provider calls are introduced.
+
+## Shared specifications and independent review
+
+The floor's AC-N rows trace back to stable requirement IDs in the team's shared
+As-Is/To-Be specification. Follow [shared system specifications](shared-system-specifications.md)
+for purpose, user experience, cross-view consistency, independent reviews and
+pre/post-PR SQM. These are controller workflow obligations, not fields magically
+validated by the minimum checker. The CLI gate verifies minimum structured evidence;
+it does not launch every design review or SQM phase on its own. Standalone hosts
+remain responsible for executing this skill and cannot claim an enforced host hook.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/shared-system-specifications.md

@@ -0,0 +1,138 @@
+# Shared system specifications and delivery review
+
+Read before planning a Delivery Loop change. The specification belongs to the
+system and its team, not to a single run. Use existing team paths and conventions;
+if none exist, start `docs/systems/<system-id>/` with an index and the applicable
+views below. Repository paths here are a convention, not a demand to move existing
+documents or to create a new service. Keep one canonical source for each concept.
+
+## Shared baseline and proposed change
+
+The system index records its owner/maintainers, repository/document links, stable
+system ID, As-Is source revision(s) and environment, verified date, and gaps.
+Distinguish source-code behavior, locally observed behavior, and deployed behavior.
+An old design or green PR is not proof of current production behavior.
+
+At the start of each run:
+
+1. Read the existing index and current linked views. Reconcile relevant As-Is with
+   code and actual behavior; label unknowns, cite evidence, and correct documented
+   drift without claiming that the drift was part of the requested feature.
+2. State why the change matters: beneficiary, current difficulty, what they can
+   do after the change, observable success, and non-goals. Preserve the user's
+   original request as an independent acceptance source.
+3. Prepare a proposed To-Be on a branch/change proposal linked from the shared
+   system index. Record its baseline revision, affected stable IDs, before/after
+   behavior, dependencies and acceptance oracles. Reuse unchanged views by reference;
+   do not copy the whole specification into every run or generate empty diagrams.
+4. Link the requirement to workflow, screen/control, state/sequence, API/event,
+   data/relationship, permission and runtime boundaries as applicable. Map these
+   stable system IDs to the run's AC-N rows and implementation/evidence locations.
+5. Obtain independent design review before implementation. Supply the original
+   request, shared baseline, To-Be and linked unchanged views. Missing evidence or
+   contradictory views remains pending/failed, never silently accepted.
+
+The twelve-view index must account for every category: present (with a canonical
+link), unchanged (with a revision), not applicable (with a reason), or unknown
+(with an owner/next action). Only create/update a diagram where it describes a
+real system concept. For CLI/skill systems, chat/terminal interactions can be the
+interface views; do not invent application screens, APIs, tables or infrastructure.
+
+| View | Primary content | Consistency checks against other views |
+| --- | --- | --- |
+| art-01-screen-inventory-final | Screens or user interaction surfaces and stable IDs | Every referenced screen/control in workflows, transitions and wireframes exists |
+| art-02-screen-transitions | Navigation, entry/exit, failure/recovery | Reachable inventory entries, correct permission guards and state conditions |
+| art-03-wireframes | Controls, content, empty/loading/error/success states | Each action has a requirement, transition and downstream sequence; no dead control |
+| art-04-functional-requirements | Purpose, beneficiary, outcomes, invariants, acceptance | Every request maps to implementation and evidence through the other affected views |
+| art-05-state-machines | Legal states, guards, terminal outcomes, retry/cancel | Sequences/events trigger legal transitions; UI messages match actual final state |
+| art-06-permissions | Actor/role, action, resource, authority boundary | UI guards, API checks, ownership and execution roles agree |
+| art-07-user-workflows | User goal, steps, completion and recovery experience | Requirements covered end to end through screens, APIs, persistence and runtime |
+| art-08-data-dictionary | Fields, meaning, type, requiredness, lifecycle and owner | API/event payloads, ER cardinality and state invariants use the same definitions |
+| art-09-sequences | Calls/events through components, errors, asynchronous completion | API names/payloads, states, authorization and deployed component boundaries agree |
+| art-10-api-design | Existing APIs, commands or file contracts, errors and compatibility | Sequence inputs/outputs, data meanings and permission checks agree |
+| art-11-er-diagram | Entities, relationships, ownership and cardinality | Dictionary and API reads/writes agree; label logical artifact models as non-DB |
+| art-12-infrastructure | Repositories, execution environments, services and trust boundaries | Every sequence participant has an actual host/owner; revision/rollout dependencies align |
+
+## Review evidence and neutral agents
+
+All reviews use independent agents/sessions, including design, cross-view
+consistency, implementation-versus-To-Be, verification changes and PR review.
+An agent must not approve work it authored. A reviewer can re-review fixes to its
+findings if it did not implement the fixes. Supply raw sources, not desired answers;
+require inspected references, discrepancies, uncertainty and a reasoned verdict.
+Use the repository-required model (gpt-5.5 / xhigh where mandated and available).
+If independent review is unavailable, report that gate as blocked.
+
+Persist a compact review receipt: reviewer/session identity, review kind, original
+request and shared baseline/To-Be references, candidate revisions, inspected views
+and evidence, findings, result, and re-review links. An independent reviewer checks:
+
+- coverage of the original request, user benefit and acceptance oracles;
+- consistency for every affected cross-view link, including unchanged neighbors;
+- behavior after actual operation, reload/session return and final persistence or
+  integration outcome where applicable;
+- implementation and tests against the proposed To-Be, not just against each other;
+- missing/extra functionality, stale evidence and unresolved historical regressions.
+
+A diagram syntax/link checker helps, but cannot replace semantic cross-view review.
+Do not declare neutral review merely by renaming the implementer's role.
+
+## SQM before and after PR creation
+
+Use the installed SQM loop skill. Respect explicit SQM opt-in, existing session and
+service authority. Explain unavailable gates; do not install global hooks, weaken
+rules, force an upload or switch organizations to obtain a pass.
+
+For each phase use fresh, separate local paths outside the diff (for example an
+ignored `.artifacts/delivery/<run>/sqm/pre-pr/` or `post-pr/` directory):
+
+```sh
+simy sqm min-check --base <actual-pr-base> --output <phase>/min.json
+simy sqm check --base <actual-pr-base> --min-result <phase>/min.json --proof <phase>/proof.json --signed-evidence <phase>/proof.json.signed.json
+```
+
+Use supported no-upload options when required by the authorized sharing scope.
+Read the proof and verify its repository, head, base, working-tree/diff identity,
+knowledge bundle version/digest and `outcome.status == passed`; verify the bound
+signature using SQM tooling. Exit zero alone is insufficient. Do not edit or commit
+between min-check and check. Pin the commit before the pre-PR check; writing proof
+into the committed diff would invalidate its identity.
+
+Before the pre-PR phase, inventory relevant known incidents from the team's shared
+incident records, SQM knowledge and repository regression history. Record incident
+or source ID, failure boundary, applicable/unaffected/unknown classification,
+regression command and result, SQM rule match/coverage, and residual gaps. Link this
+ledger from the shared specification so the next task can reuse and improve it.
+Separate confirmed incidents from synthetic risk scenarios; never invent history.
+A zero-match/no-applicable-rules proof does not establish historical coverage.
+Use concrete regressions for relevant uncovered incidents and have an independent
+reviewer assess coverage; keep missing incident history or untested boundaries
+visible. No finite test promises absence of all future bugs.
+
+Pre-PR: implementation-to-To-Be review and relevant regressions pass, then run SQM;
+repair findings within the bounded loop, re-review changed work, and rerun against
+the final candidate before creation. On unavailable/failed proof, withhold creation
+and report the exact blocker while continuing independent authorized preparation.
+
+Post-PR: fetch the actual PR head/base and check out/verify that combination, run
+both SQM phases again into new paths, inspect proof and current CI, and obtain
+independent PR/evidence review. The pre-PR proof cannot stand in for this run.
+If it fails, retain the PR as draft/not-ready with unmet gates recorded, repair and
+rerun affected independent reviews and SQM. A changed head/base/spec or relevant
+bundle invalidates affected approvals and proofs; preserve old receipts as history.
+Promote Ready only with current required gates, including applicable combined-state
+verification. Merge and deployment still require their own authority and evidence.
+
+## Team maintenance after verification
+
+Merge reviewed specification changes with the corresponding implementation through
+the normal team review process. Record proposed, implemented locally, merged and
+verified-in-environment status separately. Advance As-Is only for the revision and
+environment actually verified; a merged To-Be is not automatically production As-Is.
+Preserve the prior baseline and decisions in version history. If another change
+updates a shared view, reconcile its semantics and re-review affected links even
+when Git reports no textual conflict. Do not overwrite concurrent edits.
+
+Each run stores pointers, deltas and evidence in its receipt, not another competing
+master specification. Record unresolved drift with an owner, source and next action.
+Never lower the intended outcome merely to make an implementation match a diagram.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/references/state-and-receipts.md

@@ -135,6 +135,7 @@ For the full delivery mode:
 done =
   reproduction_verified
   && acceptance_evidence_complete
+  && minimum_functional_evidence_verified
   && locally_verified
   && pr_ci_green
   && integration_verified
@@ -155,3 +156,5 @@ with current context and the required user/system layers. After each evaluated
 action, refresh the JSON matrix and its readable table; append a receipt for the
 update. Keep the frozen charter distinct from mutable results. A charter patch
 supersedes the old digest only after the controller verifies its authority.
+
+The CLI records minimum evidence in observed_evidence.minimum_completion, independently of executor status. The independent audit is bound to its matrix digest. Legacy v2 histories remain readable, but missing minimum evidence cannot be reused as passing evidence on resume/recheck. Missing or unsupported charters require a refresh; they do not disable verification.

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs

@@ -60,7 +60,7 @@ function validateContext(context, runId) {
   }
 }
 
-async function checkArtifact(root, artifact) {
+export async function readEvidenceArtifact(root, artifact) {
   requireValue(object(artifact) && text(artifact.path) && hashPattern.test(artifact.sha256), "Invalid artifact reference");
   // Explicit bundle-relative paths only; never fetch URLs or execute evidence.
   const segments = artifact.path.split("/");
@@ -77,7 +77,9 @@ async function checkArtifact(root, artifact) {
   try {
     const stat = await handle.stat();
     requireValue(stat.isFile() && stat.size > 0 && stat.size <= 16 * 1024 * 1024, "Artifact must be a nonempty regular file of at most 16 MiB");
-    requireValue(sha256(await handle.readFile()) === artifact.sha256, "Artifact digest mismatch");
+    const bytes = await handle.readFile();
+    requireValue(sha256(bytes) === artifact.sha256, "Artifact digest mismatch");
+    return bytes;
   } finally {
     await handle.close();
   }
@@ -150,7 +152,7 @@ export async function checkAcceptance({ charterBytes, matrix, expectedCharterSha
             requireValue(text(cell.observed_at) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(cell.observed_at) &&
               Number.isFinite(Date.parse(cell.observed_at)) && Date.parse(cell.observed_at) <= Date.now(), "Invalid or future observation timestamp");
             requireValue(Array.isArray(cell.evidence) && cell.evidence.length > 0, "Passed result needs evidence");
-            for (const artifact of cell.evidence) await checkArtifact(root, artifact);
+            for (const artifact of cell.evidence) await readEvidenceArtifact(root, artifact);
             row.status = "passed";
           } catch {
             row.reason = "Invalid, missing, empty, unsafe, or changed evidence; check action, observation, timestamp and artifact hashes";

package/src/codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+// Record/observation checks, not authentication of the collector or host completion.
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import {
+  checkAcceptance,
+  contextDigest,
+  readEvidenceArtifact,
+  sha256,
+} from "./check-acceptance.mjs";
+
+const text = (value) => typeof value === "string" && value.trim().length > 0;
+const object = (value) =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+export const MINIMUM_COMPLETION_VERSION = 1;
+
+export function minimumCharter(charter) {
+  if (
+    charter?.completion_contract?.version !== 2 ||
+    !text(charter.id) ||
+    !text(charter.requirement) ||
+    !Array.isArray(charter.acceptance_criteria) ||
+    !charter.acceptance_criteria.length ||
+    !charter.acceptance_criteria.every(text)
+  ) {
+    throw new Error("Current completion charter required");
+  }
+  const source = {
+    original_request:
+      charter.thread_state?.original_request || charter.requirement,
+    requirement: charter.requirement,
+    minimum_scope:
+      charter.completion_contract.minimum_scope || charter.acceptance_criteria,
+    non_goals: charter.completion_contract.non_goals || [],
+  };
+  return {
+    schema_version: 1,
+    minimum_completion_version: MINIMUM_COMPLETION_VERSION,
+    run_id: charter.id,
+    source,
+    criteria: charter.acceptance_criteria.map((outcome, index) => ({
+      id: `AC-${index + 1}`,
+      outcome,
+      acceptance_source: `request:${contextDigest(source)}`,
+      layers: {
+        user: {
+          applicability: "required",
+          method:
+            "Exercise the actual operation and observe its result; reopen/reload when persistence is required.",
+        },
+        system: {
+          applicability: "required",
+          method:
+            "Independently inspect the final postcondition and necessary integration; persisted values and ownership when saving.",
+        },
+      },
+    })),
+  };
+}
+
+export function minimumContext(charter, headSha) {
+  const frozen = minimumCharter(charter);
+  return {
+    run_id: charter.id,
+    stage: "locally_verified",
+    environment: "local",
+    fixture_id: charter.id,
+    input_sha256: contextDigest(frozen.source),
+    source_revisions: { [charter.repository]: headSha },
+  };
+}
+
+export async function loadMinimumJson(file) {
+  const stat = await lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+    throw new Error("Invalid minimum evidence input");
+  return JSON.parse(await readFile(file, "utf8"));
+}
+
+export async function checkMinimumCompletion({
+  charter,
+  matrix,
+  context,
+  evidenceRoot,
+}) {
+  const frozen = minimumCharter(charter);
+  const charterBytes = Buffer.from(JSON.stringify(frozen));
+  const charterSha = sha256(charterBytes);
+  const contextSha = contextDigest(context);
+  const report = await checkAcceptance({
+    charterBytes,
+    matrix,
+    expectedCharterSha256: charterSha,
+    expectedContextSha256: contextSha,
+    evidenceRoot,
+  });
+  report.minimum_completion_version = MINIMUM_COMPLETION_VERSION;
+  report.charter_sha256 = charterSha;
+  report.context_sha256 = contextSha;
+  report.matrix_sha256 = contextDigest(matrix);
+  report.head_sha = context.source_revisions[charter.repository];
+  const fail = (id, reason) => report.errors.push(`${id}: ${reason}`);
+  for (const criterion of frozen.criteria) {
+    const row = matrix.results.find((result) => result.id === criterion.id);
+    if (
+      !Array.isArray(row?.implementation_refs) ||
+      !row.implementation_refs.length ||
+      !row.implementation_refs.every(
+        (ref) =>
+          text(ref) &&
+          !path.isAbsolute(ref) &&
+          !ref.includes("\\") &&
+          ref
+            .split("/")
+            .every(
+              (segment) =>
+                segment &&
+                segment !== ".." &&
+                segment !== "." &&
+                !segment.includes(":"),
+            ),
+      )
+    ) {
+      fail(
+        criterion.id,
+        "Missing or unsafe requirement-to-implementation mapping",
+      );
+    }
+    for (const [layer, names] of Object.entries({
+      user: ["operation", "result"],
+      system: ["postcondition", "integration"],
+    })) {
+      const cell = row?.layers?.[layer];
+      if (cell?.status !== "passed") continue;
+      try {
+        // The first artifact is a structured observation; further artifacts may be images/logs.
+        const observation = JSON.parse(
+          (
+            await readEvidenceArtifact(
+              await realpath(evidenceRoot),
+              cell.evidence[0],
+            )
+          ).toString(),
+        );
+        if (
+          observation.criterion_id !== criterion.id ||
+          observation.context_sha256 !== contextSha ||
+          !object(observation.checks)
+        )
+          throw new Error("Wrong observation context");
+        for (const name of names) {
+          const check = observation.checks[name];
+          if (
+            !object(check) ||
+            !text(check.subject) ||
+            check.expected === null ||
+            check.expected === undefined ||
+            (name === "operation" && check.expected !== true) ||
+            !isDeepStrictEqual(check.expected, check.actual)
+          ) {
+            fail(
+              `${criterion.id}/${layer}/${name}`,
+              "Missing observation or expected/actual mismatch",
+            );
+          }
+        }
+      } catch {
+        fail(
+          `${criterion.id}/${layer}`,
+          "Missing, altered or invalid structured observation",
+        );
+      }
+    }
+  }
+  report.status = report.errors.length
+    ? "evidence_incomplete"
+    : "evidence_complete";
+  // Additional floor failures must be visible in the human-readable record too.
+  report.markdown += `\nMinimum completion: ${report.status}\n${report.errors.map((error) => `- ${error}`).join("\n")}\n`;
+  return report;
+}
+
+const entry = process.argv[1]
+  ? await realpath(process.argv[1]).catch(() => null)
+  : null;
+if (entry === fileURLToPath(import.meta.url)) {
+  try {
+    const [
+      charterPath,
+      matrixPath,
+      contextPath,
+      expectedCharter,
+      expectedContext,
+      ...extra
+    ] = process.argv.slice(2);
+    if (!expectedContext || extra.length) throw new Error("Invalid arguments");
+    const charter = await loadMinimumJson(charterPath);
+    const context = await loadMinimumJson(contextPath);
+    if (
+      sha256(Buffer.from(JSON.stringify(minimumCharter(charter)))) !==
+        expectedCharter ||
+      contextDigest(context) !== expectedContext
+    )
+      throw new Error("Trusted digest mismatch");
+    const report = await checkMinimumCompletion({
+      charter,
+      context,
+      matrix: await loadMinimumJson(matrixPath),
+      evidenceRoot: path.dirname(path.resolve(matrixPath)),
+    });
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    process.exitCode = report.status === "evidence_complete" ? 0 : 1;
+  } catch {
+    process.stderr.write(
+      "Minimum completion unavailable. Supply charter.json matrix.json context.json trusted-charter-sha256 trusted-context-sha256.\n",
+    );
+    process.exitCode = 2;
+  }
+}

package/src/orchestrator/audit.js

@@ -1,3 +1,4 @@
+import { minimumCompletionCheck } from "./minimum-completion.js";
 import { open, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 
@@ -131,7 +132,7 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
   }
   attempt.retry_problem_solving = retryProblemSolving;
 
-  for (const check of completionEvidenceChecks(charter, attempt)) {
+  for (const check of [...completionEvidenceChecks(charter, attempt), minimumCompletionCheck(charter, attempt)]) {
     addCheck(
       check.id,
       check.label,
@@ -143,6 +144,13 @@ export async function auditAttempt(charter, attempt, { previousAttempt = null, s
     );
   }
 
+  if (attempt.independent_audit) {
+    addCheck("minimum_review_current", "Independent review covers the current evidence",
+      Boolean(attempt.independent_audit.minimum_matrix_sha256 &&
+        attempt.independent_audit.minimum_matrix_sha256 === attempt.observed_evidence?.minimum_completion?.matrix_sha256),
+      "Changed minimum evidence requires a fresh independent review.");
+  }
+
   const evidenceRequired = charter.expected_evidence.includes("ui_evidence_path");
   const evidenceArtifact = await inspectEvidence(charter, attempt.ui_evidence_path);
   if (evidenceRequired || attempt.ui_evidence_path) {
@@ -305,7 +313,12 @@ export function evaluatePrReadiness(charter, attempt) {
   const github = attempt.observed_evidence?.github || {};
   const local = attempt.observed_evidence?.local || {};
   const independentAudit = attempt.independent_audit;
+  const minimum = minimumCompletionCheck(charter, attempt);
   const checks = [
+    readinessCheck(minimum.id, minimum.passed, minimum.detail),
+    readinessCheck("minimum_independent_binding",
+      Boolean(independentAudit?.minimum_matrix_sha256 && independentAudit.minimum_matrix_sha256 === attempt.observed_evidence?.minimum_completion?.matrix_sha256),
+      "Independent review must cover the current minimum evidence matrix."),
     readinessCheck("implementation_gate", attempt.audit?.passed === true, "Implementation gate must pass."),
     readinessCheck(
       "independent_ai_audit",
@@ -372,7 +385,9 @@ export function evaluatePrReadiness(charter, attempt) {
     state: ready ? "merge_ready" : "pr_ready_for_review",
     summary: ready
       ? "PR has independently verified evidence, passing checks, and required approval."
-      : "Implementation is complete, but the PR is not merge-ready.",
+      : attempt.audit?.passed && minimum.passed
+        ? "Implementation is verified, but the PR is not merge-ready."
+        : "Implementation verification is incomplete; resolve the pending evidence before promotion.",
     checks,
     pending_reasons: checks.filter((check) => !check.passed).map((check) => check.detail),
   };

package/src/orchestrator/completion-contract.js

@@ -76,7 +76,7 @@ export function normalizeVisualReview(value) {
 
 export function completionEvidenceChecks(charter, attempt) {
   const contract = record(charter?.completion_contract);
-  if (contract.version !== COMPLETION_CONTRACT_VERSION) return [];
+  if (contract.version !== COMPLETION_CONTRACT_VERSION) return [check("completion_contract_version", "Supported completion contract required", false, "Missing or unsupported completion contract; re-charter and verify before promotion.")];
 
   const uncertainty = normalizeUncertaintyVerification(attempt?.uncertainty_verification);
   const rows = acceptanceCriterionRows(charter);

package/src/orchestrator/evidence.js

@@ -1,3 +1,4 @@
+import { collectMinimumCompletion } from "./minimum-completion.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
@@ -25,9 +26,16 @@ export async function collectPrEvidence({
     runCommand,
   });
   const github = await collectGitHubEvidence({ charter, attempt, repositoryPath, runCommand });
+  const minimumCompletion = await collectMinimumCompletion({ charter, attempt, repositoryPath, local });
+  const latest = await collectLocalGitEvidence({ baseBranch: charter.base_branch, repositoryPath, runCommand });
+  if (!latest.available || latest.head_sha !== local.head_sha || !latest.working_tree_clean) {
+    minimumCompletion.status = "evidence_incomplete";
+    minimumCompletion.errors = ["Checkout changed while collecting minimum evidence; verify again."];
+  }
   return {
+    minimum_completion: minimumCompletion,
     collected_at: new Date().toISOString(),
-    local,
+    local: latest,
     github,
   };
 }

package/src/orchestrator/independent-audit.js

@@ -26,6 +26,7 @@ export function buildIndependentAuditInstruction(charter, attempt) {
       "audit_target",
       [
         `Requirement: ${charter.requirement}`,
+        `Original request: ${charter.thread_state?.original_request || charter.requirement}`,
         `Acceptance criteria:\n${bullets(charter.acceptance_criteria)}`,
         `User-visible outcome: ${charter.completion_contract?.user_outcome || charter.requirement}`,
         `Minimum scope:\n${bullets(charter.completion_contract?.minimum_scope || charter.acceptance_criteria)}`,
@@ -43,6 +44,8 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         `Reported tests:\n${bullets(attempt.tests_run || [])}`,
         `Executor uncertainty verification: ${JSON.stringify(attempt.uncertainty_verification || {})}`,
         `Executor criterion evidence: ${JSON.stringify(attempt.criterion_evidence || [])}`,
+        `Minimum evidence matrix: ${attempt.observed_evidence?.minimum_completion?.evidence_path || "missing"}`,
+        `Minimum evidence digest: ${attempt.observed_evidence?.minimum_completion?.matrix_sha256 || "missing"}`,
         `Executor visual review: ${JSON.stringify(attempt.visual_review || {})}`,
         `Observed local branch: ${localEvidence.branch_name || "unknown"}`,
         `Observed local HEAD: ${localEvidence.head_sha || "unknown"}`,
@@ -59,6 +62,7 @@ export function buildIndependentAuditInstruction(charter, attempt) {
         "Inspect the final diff and related code directly from the repository.",
         "Look for unmet acceptance criteria, regressions, security issues, data and concurrency risks, missing tests, and unrelated changes.",
         "Treat executor claims as untrusted until supported by repository evidence.",
+        "Compare the original request to the complete AC-N list and implementation mapping. Report forgotten features, dead controls, unsaved results and broken integration. Open the raw minimum evidence, verify its oracle and actual runtime observations; matching expected/actual JSON and hashes alone do not prove truth. Check reload/session return and persisted values/ownership when saving is required.",
         "For every AC-N criterion, return a criterion_results entry only after directly checking its cited proof and observed outcome.",
         charter.evidence_policy?.browser_required
           ? "Open and inspect the actual local screenshots or videos. Return visual_review.inspected=true only after checking their visible content against the acceptance criteria."
@@ -70,7 +74,8 @@ export function buildIndependentAuditInstruction(charter, attempt) {
       "result_contract",
       [
         "Finish with exactly one line beginning SIMY_AUDIT_JSON: followed by one JSON object.",
-        "Required keys: passed, summary, findings, criterion_results, visual_review.",
+        "Required keys: passed, summary, findings, criterion_results, visual_review, coverage_review.",
+        "coverage_review must contain requirements_complete (boolean), unmapped_requirements (array), and observation explaining the comparison of the original request, AC-N list, implementation and raw user/system proof. Use false and list gaps when anything is missing or unverified.",
         "Each finding candidate must contain passed, code, severity, target, explanation, and repairability.",
         "criterion_results must contain one entry per AC-N with criterion_id, passed, verification_method, evidence_refs, and observed_result.",
         "visual_review must contain inspected, artifacts, and acceptance_observations.",
@@ -195,12 +200,19 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       auto_fix_hint: null,
     });
   }
+  const coverage = result.coverage_review;
+  if (attempt && !(coverage?.requirements_complete === true &&
+      Array.isArray(coverage.unmapped_requirements) && coverage.unmapped_requirements.length === 0 && cleanString(coverage.observation))) {
+    findings.push({ passed: false, code: "MINIMUM_REQUIREMENT_COVERAGE_UNPROVEN", severity: "blocker",
+      target: "coverage_review", explanation: "Original request coverage and raw minimum evidence were not independently verified.", repairability: "auto" });
+  }
   const requiresHuman = findings.some((item) => item.repairability === "manual");
   return {
     passed: result.passed === true && findings.length === 0,
     summary: cleanString(result.summary) || "Independent audit completed.",
     findings,
     criterion_results: criterionResults,
+    coverage_review: coverage || null,
     visual_review: visualReview,
     requires_human: requiresHuman,
   };

package/src/orchestrator/instruction.js

@@ -1,3 +1,4 @@
+import { minimumCharter } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
 import { bullets, looksLikeUiTask, section } from "./shared.js";
 import { problemSolvingResultContract } from "./problem-solving.js";
 import { acceptanceCriterionRows } from "./completion-contract.js";
@@ -50,6 +51,17 @@ export function buildCodingInstruction(
         ),
       ),
     ),
+    section("minimum_completion_evidence", [
+      "All delivery levels require this floor. Before implementation reconcile every original requirement with the AC-N list; report omissions instead of silently dropping them.",
+      "Save a matrix.json under the local evidence root (ui_evidence_root or repository .artifacts). Return delivery_evidence_path in SIMY_RESULT_JSON. A passed flag or tests_run string is not proof.",
+      "Use check-minimum-completion.mjs from the installed Delivery Loop skill. Its reference minimum-completion.md defines the matrix and structured observation format.",
+      "For each AC-N include real implementation_refs and required user/system evidence. Exercise the actual operation and result, then inspect postcondition and integration independently. For saving, reload/return in a new session and verify stored values and ownership. Document-only work uses the real command/consumer and artifact integrity, not imaginary API/DB checks.",
+      "First evidence artifact per layer must be JSON: {criterion_id, context_sha256, checks}. User checks: operation (expected=true, actual=observed boolean) and result; system checks: postcondition and integration. Each check includes subject, expected and actual. Derive expected values from the original requirement, not from the candidate output. Include screenshots/logs as additional evidence.",
+      "Freeze and bind observations to the current committed revision and charter before verification. Do not rehash old observations to make changed code pass. Use pending/failed for unavailable or mismatching evidence.",
+      `Controller input JSON: ${JSON.stringify({ id: charter.id, requirement: charter.requirement, repository: charter.repository, acceptance_criteria: charter.acceptance_criteria, completion_contract: charter.completion_contract, thread_state: { original_request: charter.thread_state.original_request } })}`,
+      `Controller-owned acceptance specification: ${JSON.stringify(minimumCharter(charter))}`,
+      `Context: run_id=${charter.id}, stage=locally_verified, environment=local, fixture_id=${charter.id}; input_sha256 is contextDigest(spec.source); source_revisions maps ${charter.repository} to current full HEAD.`,
+    ].join("\n")),
     section("expected_tests", bullets(charter.expected_tests)),
     section("must_not", bullets(charter.must_not)),
   ];
@@ -130,7 +142,7 @@ export function buildCodingInstruction(
       "result_contract",
       [
         "Finish with exactly one line beginning SIMY_RESULT_JSON: followed by one JSON object.",
-        "Required keys: outcome_kind, summary, branch_name, commit_sha, commit_message_headline, pr_url, pr_number, pr_title, pr_base_branch, tests_run, tests_passed, ui_evidence_path, unrelated_changes_detected, secret_scan_passed, changed_files, residual_risks, problem_solving, uncertainty_verification, criterion_evidence, visual_review.",
+        "Required keys: outcome_kind, summary, branch_name, commit_sha, commit_message_headline, pr_url, pr_number, pr_title, pr_base_branch, tests_run, tests_passed, ui_evidence_path, unrelated_changes_detected, secret_scan_passed, changed_files, residual_risks, problem_solving, uncertainty_verification, criterion_evidence, visual_review, delivery_evidence_path.",
         problemSolvingResultContract(),
         "uncertainty_verification must contain top_uncertainty, first_verification, evidence_checked, observed_result, resolved, and fallback. Only set resolved=true when concrete observed evidence resolves it.",
         "criterion_evidence must contain one entry for every AC-N with criterion_id, passed, verification_method, evidence_refs, and observed_result. Only set passed=true when the evidence directly proves that criterion.",

package/src/orchestrator/loop.js

@@ -1,3 +1,4 @@
+import { minimumCharter } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
 import { auditAttempt, evaluatePrReadiness } from "./audit.js";
 import {
   buildIndependentAudit,
@@ -9,7 +10,7 @@ import { buildAttempt, mergeTokenUsage } from "./result.js";
 import { evaluateRetryCircuit } from "./retry.js";
 import { appendEvent, publish } from "./shared.js";
 
-export async function runCodingLoop({
+async function runCodingLoopOwned({
   snapshot,
   executeAttempt,
   executeIndependentAudit,
@@ -21,6 +22,19 @@ export async function runCodingLoop({
   shouldStop = () => false,
   consumeHumanGuidance = () => "",
 }) {
+  if (!resume && snapshot.attempts.length > 0) {
+    return recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm, onUpdate });
+  }
+  snapshot.implementation_gate_passed = false;
+  snapshot.done_gate_passed = false;
+  try { minimumCharter(snapshot.charter); } catch {
+    snapshot.final_audit = humanGate("Completion charter requires refresh before verification.", [{
+      code: "MINIMUM_CHARTER_REQUIRED", severity: "blocker", target: "completion_contract",
+      explanation: "Missing or unsupported completion charter. Preserve history, re-charter and collect current minimum evidence.", repairability: "manual",
+    }]);
+    await publish(snapshot, "waiting_human", onUpdate);
+    return snapshot;
+  }
   if (!resume || snapshot.attempts.length === 0) {
     appendEvent(snapshot, "risk_classifying", "PR risk classification completed.", {
       risk: snapshot.charter.risk,
@@ -197,6 +211,7 @@ export async function runCodingLoop({
     await publish(snapshot, "independent_auditing", onUpdate);
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     const auditInstruction = buildIndependentAuditInstruction(snapshot.charter, attempt);
+    const reviewedMatrix = attempt.observed_evidence?.minimum_completion?.matrix_sha256;
     const auditExecution = await safeExecution(() =>
       executeIndependentAudit({
         attemptNumber,
@@ -215,6 +230,8 @@ export async function runCodingLoop({
     attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
     attempt.budget = refreshBudgetState(snapshot);
 
+    attempt.independent_audit.minimum_matrix_sha256 = reviewedMatrix;
+
     // Re-collect after the read-only auditor to catch any mutated HEAD or working tree.
     attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
     attempt.sqm = await safeSqm(checkSqm, attempt, attempt.sqm);
@@ -276,9 +293,11 @@ async function stopCodingLoop(snapshot, onUpdate) {
   return snapshot;
 }
 
-export async function recheckPrReadiness({ snapshot, collectEvidence, checkSqm = null, onUpdate }) {
+async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = null, onUpdate }) {
   const attempt = snapshot.attempts.at(-1);
-  if (!attempt || !attempt.audit?.passed || !attempt.independent_audit?.passed) return snapshot;
+  snapshot.implementation_gate_passed = false;
+  snapshot.done_gate_passed = false;
+  if (!attempt) return snapshot;
   appendEvent(snapshot, "checking_pr", "Refreshing GitHub review and CI evidence.", {
     attempt_number: attempt.attempt_number,
   });
@@ -296,7 +315,7 @@ export async function recheckPrReadiness({ snapshot, collectEvidence, checkSqm =
   snapshot.final_audit = aggregateAudit(
     attempt,
     attempt.pr_readiness.ready,
-    attempt.independent_audit.findings || [],
+    attempt.independent_audit?.findings || [],
   );
   appendEvent(snapshot, attempt.pr_readiness.state, attempt.pr_readiness.summary, {
     pr_url: attempt.pr_url,
@@ -583,3 +602,14 @@ function humanGate(summary, findings) {
     release_gate: null,
   };
 }
+
+const activeControllers = new Set();
+async function withController(options, action) {
+  const owner = options.snapshot?.id;
+  if (typeof owner !== "string" || !owner) throw new Error("Delivery snapshot ID required");
+  if (activeControllers.has(owner)) throw new Error("Delivery controller is already active for this snapshot");
+  activeControllers.add(owner);
+  try { return await action(options); } finally { activeControllers.delete(owner); }
+}
+export const runCodingLoop = options => withController(options, runCodingLoopOwned);
+export const recheckPrReadiness = options => withController(options, recheckPrReadinessOwned);

package/src/orchestrator/minimum-completion.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { lstat, realpath } from "node:fs/promises";
+import {
+  minimumCharter,
+  minimumContext,
+  checkMinimumCompletion,
+  loadMinimumJson,
+} from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
+import {
+  contextDigest,
+  sha256,
+} from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs";
+
+export function minimumCharterDigest(charter) {
+  return sha256(Buffer.from(JSON.stringify(minimumCharter(charter))));
+}
+
+export async function collectMinimumCompletion({
+  charter,
+  attempt,
+  repositoryPath,
+  local,
+}) {
+  try {
+    if (!local.available || !local.working_tree_clean)
+      throw new Error("Clean current checkout required");
+    const root = await realpath(
+      charter.ui_evidence_root || path.join(repositoryPath, ".artifacts"),
+    );
+    const requested = attempt.raw_output?.delivery_evidence_path;
+    if (typeof requested !== "string") throw new Error("Matrix path missing");
+    const file = path.resolve(root, requested);
+    const relative = path.relative(root, file);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative))
+      throw new Error("Outside evidence root");
+    let current = root;
+    for (const segment of relative.split(path.sep)) {
+      current = path.join(current, segment);
+      if ((await lstat(current)).isSymbolicLink())
+        throw new Error("Symlink evidence path");
+    }
+    const matrix = await loadMinimumJson(file);
+    const report = await checkMinimumCompletion({
+      charter,
+      matrix,
+      context: minimumContext(charter, local.head_sha),
+      evidenceRoot: path.dirname(file),
+    });
+    if (report.status !== "evidence_complete") return report;
+    // Check mapping paths without reading source contents or following links outside the checkout.
+    const repo = await realpath(repositoryPath);
+    for (const row of matrix.results) {
+      for (const ref of row.implementation_refs || []) {
+        if (typeof ref !== "string") continue;
+        const target = await realpath(path.resolve(repo, ref));
+        const rel = path.relative(repo, target);
+        if (
+          rel.startsWith("..") ||
+          path.isAbsolute(rel) ||
+          !(await lstat(target)).isFile()
+        )
+          throw new Error("Invalid implementation mapping");
+      }
+    }
+    if (contextDigest(await loadMinimumJson(file)) !== report.matrix_sha256)
+      throw new Error("Matrix changed during verification");
+    return { ...report, evidence_path: file };
+  } catch {
+    return {
+      status: "evidence_incomplete",
+      errors: [
+        "Minimum completion evidence missing, invalid or stale; verify the actual operation, result, postcondition and integration for every AC-N.",
+      ],
+    };
+  }
+}
+
+export function minimumCompletionCheck(charter, attempt) {
+  const report = attempt.observed_evidence?.minimum_completion;
+  const head = attempt.observed_evidence?.local?.head_sha;
+  let passed = false;
+  try {
+    passed =
+      report?.minimum_completion_version === 1 &&
+      report.status === "evidence_complete" &&
+      report.errors?.length === 0 &&
+      report.charter_sha256 === minimumCharterDigest(charter) &&
+      report.context_sha256 === contextDigest(minimumContext(charter, head)) &&
+      /^[a-f0-9]{64}$/.test(report.matrix_sha256) &&
+      report.head_sha === head &&
+      attempt.observed_evidence.local.working_tree_clean === true;
+  } catch {
+    /* Unsupported/missing charters never waive this gate. */
+  }
+  return {
+    id: "minimum_completion",
+    label: "Every requested outcome has current operation and system evidence",
+    passed: Boolean(passed),
+    detail: passed
+      ? "Current minimum evidence verified; independent coverage/oracle review and remaining gates still apply."
+      : (
+          report?.errors || [
+            "Minimum completion evidence has not been verified.",
+          ]
+        ).join("; "),
+    evidence_refs: report?.evidence_path ? [report.evidence_path] : [],
+  };
+}

package/src/orchestrator/result.js

@@ -1,3 +1,6 @@
+import { minimumCharterDigest } from "./minimum-completion.js";
+import { minimumContext } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
+import { contextDigest } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs";
 import { cleanString, stringArray } from "./shared.js";
 import { normalizeProblemSolving } from "./problem-solving.js";
 import {
@@ -15,6 +18,8 @@ export function buildAttempt({ attemptNumber, charter, instruction, promptInterv
   const completed = execution.exitCode === 0 && !execution.error;
   const now = new Date().toISOString();
   return {
+    minimum_charter_sha256: safeDigest(() => minimumCharterDigest(charter)),
+    minimum_context_sha256: safeDigest(() => contextDigest(minimumContext(charter, cleanString(result.commit_sha)))),
     attempt_number: attemptNumber,
     backend: charter.backend,
     base_branch: charter.base_branch,
@@ -112,3 +117,5 @@ function buildArtifactPreviews(result) {
 function isUsageRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+
+function safeDigest(compute) { try { return compute(); } catch { return null; } }