@awak-app/simy-cli 0.5.16 → 0.5.17

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

@@ -45,7 +45,7 @@ for the end-to-end row when the requested experience depends on their combinatio
 ## 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
+CLI runtime delivery/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
@@ -98,7 +98,7 @@ 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>
+node <cli-package>/src/orchestrator/delivery/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
@@ -143,4 +143,4 @@ for purpose, user experience, cross-view consistency, risk-proportionate indepen
 reviews and explicitly opted-in, identity-aware 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.
+remain responsible for executing this workflow and cannot claim an enforced host hook.

package/src/orchestrator/delivery/references/pr-closure.md

@@ -0,0 +1,203 @@
+# PR closure: SIMY Web / CLI procedure
+
+This procedure is loaded by the Web/CLI executor and independent auditor through
+`src/orchestrator/pr-closure.js`. It is not a local Codex skill or a GitHub hook.
+It adds a closure safety gate to the existing delivery workflow, not a new remote
+mutation tool, permission or terminal state. Closing a PR never proves delivery.
+
+Flow: scope/authority -> original requirements and exact revisions -> before/after
+table -> real outcome verification -> independent review -> decision -> freshness
+and authority recheck -> authorized close -> remote read-back and durable receipt.
+When blocked, stop the close, not independent authorized investigation. Reuse the
+run's attempt/time/cost limits; do not repeat unchanged failed checks indefinitely.
+
+## 1. Define the scope and reason
+
+Record repository/PR, purpose, beneficiary, source requirements and non-goals.
+Distinguish merged, duplicate/fully superseded, transfer to unfinished work, and
+intentional cancellation/retirement. An already merged PR needs its actual merge
+identity verified, not a manual unmerged close. Merge is not deployment.
+
+An audit/table request is read-only. Record close and comment-posting authority
+separately; a factual same-PR comment must be covered by explicit authorization
+or governing policy. Otherwise prepare an unposted draft. Do not infer authority
+to merge successors, deploy, delete branches or reopen an already closed PR.
+An existing clear authorization need not be requested twice; a newly discovered
+loss of functionality requires an informed decision on that consequence.
+
+## 2. Freeze requirements and comparison identities
+
+Use original requests, acceptance criteria and approved decisions as the oracle,
+not the closing comment or candidate's own tests alone. Reuse stable acceptance
+IDs from the delivery charter. Independently reconcile the original sources with
+the ID list so an omitted requirement cannot disappear before validation.
+
+Record full old PR head and merge-base SHAs, current target base, successor and
+companion heads, exact integrated candidate, PR/merge state, build/runtime identity,
+flags, permissions/tenant, environment and observation time. Track deployed state
+separately; never infer it from a branch. Preserve a recoverable reference to
+unmerged source before cleanup. An SHA without retrievable objects is not backup.
+
+Keep requested, intended-in-code, observed-in-runtime, absent and unknown distinct.
+An unavailable old environment does not prove a feature never existed. Old missing
+code does not waive an explicit requirement, and labels do not prove old guarantees.
+
+## 3. Persist the before/after table
+
+Use [UX behavioral completeness](ux-specification.md) for both sides of the
+comparison. A concise table cell must link to the complete interaction contract;
+do not reduce the comparison to feature labels or omit divergent branches.
+
+Use the existing [acceptance evidence](acceptance-evidence.md) and stable IDs.
+Keep separate bound results for each context and link the comparison to them;
+do not overwrite base-only results with combined or live results. Persist outside
+chat and retain failed/pending rows. Minimum comparison columns:
+
+| ID / requirement source | Persona, condition, required outcome | Old PR intended / observed | Current base alone | Base + successors | Deployed target | Decision, gap, owner, remediation PR | Evidence |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Stable criterion | Trigger, real entry, action, result, next action | Exact revision, evidence level | Exact revision, evidence level | Exact integrated identity | Observed identity or unknown | Retained / approved change / transferred / missing / unknown | Source locations, raw results, artifact hashes, times |
+
+For each affected journey cover real navigation, discoverability, first use and
+empty data, flags/roles/ownership; transferred input/context, confirmation, state
+changes, actual execution, usable output and next action; persistence, reload and
+session return, history/sync, privacy and data migration; loading, no-match,
+permission denial, error, cancellation and retry/recovery. Include accessibility
+and device variants when affected. Extra clicks or lost controls may be regressions
+even if an API is unchanged.
+
+For workflow products, separately account for existing-workflow reuse, composition,
+conversational design of a saved workflow, immediate ad-hoc work without saving a
+workflow, and background discovery/learning. Explicitly test the no-workflow or
+no-match branch: can the user ask for help, preserve intent, clarify/design/execute
+as required and obtain a usable result? A catalog recommender or background
+learning is not proof of conversational/ad-hoc fallback. Classify each capability
+against authoritative requirements; do not invent an old capability or silently
+exclude one because old code lacked it.
+
+Inventory every changed file, including deletions/renames, contracts, flags, tests
+and affected consumers outside the diff. Map each to criteria or a justified
+non-behavioral classification. Trace all requirements forward to proof, removed
+behavior back to retained behavior or approved retirement, and added permissions,
+data collection, automation, costs, defaults or steps back to authorized scope.
+Identical blobs, ancestry and file counts prove accounting, not UX equivalence.
+
+### Yellow/red rows must become remediation PR work
+
+Display unresolved partial/changed/unverified outcomes as yellow (🟡), and verified
+missing/regressed outcomes as red (❌). Keep factual behavior, evidence sufficiency
+and approved scope separate; uncertainty alone is not proof of a product defect.
+For every yellow/red row, create a new remediation PR for the required repair or
+verification within the active task's implementation/commit/push/PR authority.
+Group rows only when they form one coherent behavior change; do not mechanically
+create one PR per row or combine unrelated fixes. Use a Draft PR while unfinished.
+Before creation, check existing remediation PRs: reuse an exact open match with
+explicit criterion coverage rather than creating duplicate competing work. A broad
+successor link does not count without that mapping.
+
+Record criterion IDs, original PR, observed gap/evidence, required outcome, owner,
+repository/base, tests/E2E and acceptance gates in each remediation PR. Add its real
+URL and state to every covered table row; include dependencies and re-evaluation
+triggers. Evidence-only yellow rows need the missing verification, not speculative
+product changes. An unresolved product choice remains `needs_decision`; do not
+choose a new specification just to open a PR. If implementation or publication is
+unauthorized, blocked or outside the current budget, record a concrete PR plan and
+the missing decision/authority, but do not claim a PR exists. A plan/issue alone
+does not satisfy the requested PR handoff or justify `transfer_ready`.
+
+Independent review must reconcile all yellow/red IDs with the actual remediation
+PRs and explicitly named blockers before the original PR can be closed by transfer.
+Creating a PR is not fixing the issue: keep the row non-green until its required
+revision-bound checks pass. Approved changes/retirements may resolve a row only
+with the product decision and applicable safety evidence; preserve its history.
+
+## 4. Verify the actual consumer and independent postconditions
+
+Trace normal production entry -> caller -> UI/service -> backend -> persisted
+result -> next user action. Verify actual imports, routes, permissions and flags.
+A surviving component/API used only in fixtures is not a production experience.
+Test the unchanged old candidate where feasible, base alone and exact integrated
+candidate. Inspect the combined behavior, not just mergeability or individual CI.
+Reuse valid bound evidence; do not inflate counts with unnecessary reruns.
+
+For browser behavior, use [normal-user verification](chrome-user-verification.md)
+on the complete production-like stack with authorized services and safe fixtures.
+Capture meaningful visible states, errors and correlated technical postconditions
+for the same input/run. Mocked/component E2E, direct API calls and static analysis
+are supporting evidence, not substitutes. Only an exact-runtime live journey proves
+live inheritance. Do not imply that local or merged verification is deployed proof.
+For docs/CLI/library/API work use the actual artifact, command or downstream
+consumer; record why browser checks are inapplicable. Unavailable checks are pending,
+not inapplicable. Never make production writes solely to satisfy this procedure.
+
+Preserve initial failures. Classify product, environment and oracle failures with
+independent evidence. Changed assertions/fixtures create a different tested
+candidate and require independent oracle review; do not credit their passes to
+the unchanged original PR. A stale label alone does not explain a missing route.
+
+## 5. Independent review and decision
+
+Before the close action, a separate reviewer receives original requirements,
+candidate revisions, complete file inventory, table and raw artifacts, without
+a prescribed verdict. Review omissions, reachability, fallback, integrated results,
+unapproved scope and unfinished dependencies. Record identity-bound findings in
+the existing independent-review receipt. A comment claiming a review occurred is
+not review evidence. Repair only within authority; re-review changed inputs.
+The normal post-execution CLI audit is not a substitute for review before closing.
+
+Store these labels in the closure record, not in the delivery-state enum:
+
+| Decision | Required evidence and permitted action |
+| --- | --- |
+| `close_ready` | All requirements accounted for, candidate evidence and independent review pass; no hidden loss or pending implementation. State separately whether base-only or live. Deployment may remain an explicit delivery obligation. |
+| `transfer_ready` | Every pending outcome/risk has an accepted owner or authorized assignment, actual open remediation PR with criterion coverage, acceptance gate and re-evaluation trigger; explicit informed administrative-close authorization. No unmapped yellow/red row or unresolved handoff blocker. Not full inheritance/completed delivery. |
+| `retirement_ready` | Explicit product decision retires named outcomes; necessary user-data/migration/safety obligations verified or safely assigned before close. Not equivalence. |
+| `needs_decision` | Lost/changed outcome or trade-off lacks an authoritative human selection; present consequences/options and keep open. |
+| `blocked` | Missing/stale evidence, review, authority, classification or handoff, or unsafe consequence prevents the proposed action/claim. |
+
+Unknown/failed applicable rows cannot support `close_ready`. A deliberately
+authorized transfer keeps them non-green and visible. Verify the successor exists,
+is open and carries the actual pending criteria; a link alone is insufficient.
+Do not invent an owner's acceptance. Transfer cannot waive mandatory security,
+privacy, data-integrity or external-contract constraints. Retain the actual highest
+proven delivery state, independently of the closure-task disposition.
+
+## 6. Freshness check, authorized action and read-back
+
+Immediately before mutation refresh old head, target base, all successor heads and
+states, integrated identity, checks/review inputs, flags/environment and authority.
+Any changed bound input invalidates affected verification/review under
+[state and receipts](state-and-receipts.md). Inspect and reverify before continuing;
+checking only the old head is insufficient. Use conditional updates if available;
+otherwise read immediately before/after, record residual races and stop on drift.
+
+Prepare a factual explanation: reason, exact identities, comparison/evidence/review
+links, approved changes, pending obligations/owners, deployment status and recovery
+reference. Do not say nothing remains if work is unknown or unmerged. Missing close
+authority blocks closing; missing posting authority retains a draft. If policy
+requires a posted explanation, missing posting authority also blocks closing.
+
+After an authorized close, read back state, close/merge timestamps and identities,
+any authorized posted explanation, and successor status (open or demonstrably
+resolved). Reconcile ambiguous responses before retrying to avoid duplicate
+actions/comments. On unexpected concurrent changes, preserve evidence and report;
+do not silently reopen or declare success. Audit previously closed PRs read-only,
+separating the historical decision's evidence from today's state.
+
+## 7. Durable receipt and handoff
+
+Add a `closure` section to the existing completion/handoff evidence record, reusing
+its run/input digest, idempotency key and append-only rules. Record target/reason,
+decision, comparison/context digests, criterion/file coverage, all non-green rows,
+review and artifact references/hashes, human decisions and separate authorities,
+pre/post state/timestamps, mutation identity, comment ID/URL or unposted draft,
+pending owners/gates/triggers, yellow/red-ID-to-remediation-PR mappings and blocked
+PR plans, and source recovery references. Record unperformed
+actions as unperformed; reconcile retries with the same logical action identity.
+This documented section is not a new automatically validated CLI schema.
+
+Preserve the table, relevant raw proof, review and recoverable unmerged source in
+an approved durable location before deleting temporary worktrees. Verify links
+remain accessible and remove secrets/unrelated personal data. Never remove the
+only evidence/source copy. Administrative closure can finish a scoped closure task,
+not unfinished feature delivery. Promise ongoing monitoring only if authorized and
+actually configured; otherwise hand off to the recorded owner/tracking item.

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

@@ -14,7 +14,10 @@ Persist one controller-owned snapshot with at least:
 - acceptance-source identities and digests, architecture boundaries, applicable
   rule decisions, human-decision receipt IDs, approved canonical sources and
   their precedence and fallback semantics, risk tier, requested/effective
-  delivery levels, the safety ceiling reason, and chat-confirmation receipt;
+  delivery levels, numbering version, safety floor and reason, complete five-level
+  comparison with per-level hour estimates and assumptions, recommendation and
+  rationale, and chat-confirmation receipt; preserve legacy numbering and record
+  verified conversions separately rather than rewriting historical choices;
 - repository, base SHA, head SHA, companion SHAs, merge SHA, image digests, and
   deployed revision;
 - target environments, user journey, user/tenant fixture identities, and

package/src/orchestrator/delivery/references/ux-specification.md

@@ -0,0 +1,98 @@
+# UX specification: behavioral completeness
+
+Apply this standard to every UX description across the SIMY Web/CLI delivery loop:
+requirements, As-Is/To-Be, design, implementation mapping, acceptance criteria,
+verification records, reviews, release, before/after comparisons, closure and handoff.
+The quality target is **behavioral completeness and verifiability**, not prose length.
+Expand until no material user-observable behavior must be guessed; stop expanding
+when additional text only repeats or introduces unsupported scope.
+
+## Unit of description and decomposition
+
+An **observable interaction unit** describes one coherent transition from a stated
+user context to an observable outcome, including the user's control and the system's
+response. A feature name or a list of implementation components is not such a unit.
+Reuse stable UX/acceptance IDs and link finer units to their parent criterion. Do not
+create a second competing source of requirements or silently replace frozen IDs.
+
+Split a unit when the actor, prerequisite, choice, observable state, postcondition
+or recovery obligation differs materially. Also split independently falsifiable
+claims so a partial failure cannot hide inside a broadly passing row. Retain an
+end-to-end criterion joining the units: local completeness does not prove a usable
+journey. Derive the necessary granularity from actual requirements and system
+boundaries, never from a fixed number of screens, steps, rows or words.
+
+## Semantic obligations for every unit
+
+Each obligation must have explicit content, a precise reference to shared content,
+or an authoritative non-applicability reason. These are semantic requirements for
+the canonical specification, not additional mandatory fields in the CLI JSON schema.
+
+| Obligation | Required description |
+| --- | --- |
+| Actor and intent | Who acts or receives value, what they seek, and how the outcome serves that intent. |
+| Context and preconditions | Relevant prior state, available information, authority and constraints that determine whether and how the experience is possible. |
+| Trigger and reachability | What initiates the unit, how the actor reaches it, and which prerequisite or preceding unit supplies the entry state. |
+| Perception and comprehension | Information and feedback available to the actor, its timing and meaning, and how it communicates current state, consequences and what can happen next. Do not assert a mental state as observed without evidence. |
+| Action, choice and control | Permitted actions, required input, alternatives, decision ownership, confirmation and reversibility where applicable, with their consequences. |
+| System response and transition | Response to each relevant action or event, observable intermediate and terminal states, and applicable timing, ordering and consistency constraints. |
+| Usable outcome and postconditions | What the actor can actually use after the transition, affected state or effects, and the conditions that distinguish complete, partial and unsuccessful outcomes. |
+| Continuation and handoff | Next permitted action or terminal boundary, destination/owner and context retained across the transition. A handoff must identify its receiving preconditions. |
+| Alternatives, failure and recovery | Conditions producing materially different behavior, what the actor perceives, available recovery/control and retained or lost state. A terminal state must be intentional, not an unexplained dead end. |
+| Acceptance oracle and provenance | Requirement source, observable pass/fail predicates, observation method and evidence identity for the same actor/context/revision. Distinguish planned verification from its observed result. |
+
+Apply relevant usability, accessibility, privacy, authority and continuity constraints
+to these obligations where they change the experience. Express qualitative requirements
+as observable discriminators; use quantitative thresholds only when grounded in an
+authoritative requirement or an explicitly approved decision. Unspecified values or
+policy remain unknown; never invent them to make the description appear complete.
+
+## Completeness review criteria
+
+Use these criteria together, not an average score. A complete description satisfies
+every applicable criterion for its declared scope. A completed form is not proof.
+
+| Criterion | Pass condition |
+| --- | --- |
+| Source coverage | Every in-scope user outcome and constraint from the independent acceptance sources maps to identified units; every specified behavior maps back to a source or recorded authorized decision. |
+| Causal continuity | Entry and exit conditions connect across units without an unstated user step, system dependency or context transfer. The complete path reaches a usable outcome or an explicitly justified terminal state. |
+| Branch closure | Each material alternative derived from requirements and actual boundaries has a condition, observable response, consequence and continuation or recovery. Conditions distinguish which response applies. |
+| Control clarity | The actor can determine what they may do, what is automatic, who decides, and the consequences and available reversal of relevant actions. |
+| Observability and falsifiability | An independent verifier can distinguish success, partial success and failure using the stated oracle and evidence method, without inventing expected behavior. |
+| Cross-view consistency | Descriptions of the same intent agree on actors, prerequisites, transitions, authority, outcomes and recovery across all affected surfaces and specification views, or cite an approved difference. |
+| Traceability and freshness | Stable IDs connect source, specification, implementation, checks, observations and unresolved obligations; referenced revisions and context match the claim. |
+| Epistemic separation | Requirements, intentions, observations, assumptions and unknowns are separately identified; lack of evidence is not presented as absence, success or non-applicability. |
+
+Perform an **independent reconstruction check**: a reader who did not author the
+implementation must be able to derive the intended interaction and its acceptance
+checks without supplying a material product decision. Review against original
+sources as well as the described units, so omitted behavior cannot pass unnoticed.
+Return gaps by criterion ID, missing obligation, consequence, authoritative question
+or evidence needed, and dependent phase. Do not claim exhaustive coverage beyond
+the declared scope and available sources; disclose unavailable sources and risks.
+
+## Application through the lifecycle
+
+| Phase | Required use of the same contract |
+| --- | --- |
+| Discovery and charter | Record known As-Is observations separately from requested outcomes and unknowns; derive coverage and freeze intended behavior before solution-dependent decisions. |
+| Design and implementation | Maintain the source-linked To-Be units and map their obligations to affected paths; inspect dependencies and consistency, without weakening the contract to fit candidate code. |
+| Verification and review | Observe the complete applicable paths and independent postconditions in the same bound context; compare expected and observed behavior unit by unit and end to end. |
+| Repair and scope change | Preserve failed results, record authorized requirement changes and invalidate only affected descriptions/evidence; re-review dependent units and their connected paths. |
+| Release and operation | Identify the target runtime and applicable outcome/guardrail observations; distinguish expected exposure, observed behavior and unresolved operational obligations. |
+| PR closure and handoff | Compare before/after using the same units, retain reachability and recovery detail, map unresolved obligations to authorized remediation work and preserve evidence and ownership. |
+
+Persist complete descriptions in the canonical specification and reference their IDs
+from matrices, PRs and receipts. Compact user-facing summaries may omit repetition,
+not material behavior, uncertainty or the link to the full contract. Do not impose
+long transcripts or duplicate the full specification in each progress update.
+
+Unknowns are visible work, not a reason to fabricate detail. A material unresolved
+requirement decision blocks dependent design/implementation; a missing runtime
+observation blocks the affected verification or equivalence claim. Discovery and
+independent authorized work may continue. Explicit assumptions retain their source,
+risk and resolution condition; assumption-based behavior cannot be presented as
+verified. Genuine non-applicability needs a reason/source before execution, not a
+post-failure waiver. This is a workflow and independent-review standard; existing
+validators check their documented evidence contracts, not these semantic criteria
+automatically. Do not claim machine enforcement merely because this guide is loaded.

package/src/{codex-plugins/simy/skills/agentic-delivery-loop → orchestrator/delivery}/scripts/production-contract.mjs

@@ -1,4 +1,4 @@
-// Shared by the CLI and the independently installed skill. Keep this module
+// Shared by the CLI and the packaged evidence checker. Keep this module
 // self-contained so validation never depends on the repository checkout.
 const cleanString = value => typeof value === "string" ? value.trim() : "";
 const record = value => value && typeof value === "object" && !Array.isArray(value) ? value : {};

package/src/orchestrator/delivery-level.js

@@ -0,0 +1,19 @@
+import { fileURLToPath } from "node:url";
+import { section } from "./shared.js";
+
+export const DELIVERY_LEVELS_PATH = fileURLToPath(
+  new URL("./delivery/references/delivery-levels.md", import.meta.url),
+);
+
+export function buildDeliveryLevelInstruction({ auditor = false } = {}) {
+  return section("delivery_level_contract", [
+    `Read the Web/CLI delivery-level contract: ${DELIVERY_LEVELS_PATH}`,
+    "Use assurance-ascending-v2: 5 is maximum assurance, 4 protected, 3 balanced, 2 fast, 1 lightest. Higher numbers mean more assurance, not greater task priority. Apply the highest applicable risk/policy floor; never lower mandatory verification or expand authority.",
+    "Whenever recommending, confirming or changing a level, present ALL five levels in descending order 5, 4, 3, 2, 1, as a table or clearly separated prose. For EACH show content, verification/review scope, trade-off, task applicability, and task-specific duration in hours. Mark the recommendation and explain its task/risk rationale, even when the user already selected a level; acknowledge a valid selection without asking again. Mark unsafe levels unavailable with reasons; do not hide them.",
+    "Estimate numeric lower-to-upper execution and elapsed-hour ranges for the same task scope and endpoint, using observed boundaries, implementation, checks, review, setup, repair and dependency critical path. Separate execution from CI/queue/approval/external waiting; account for parallelism. State assumptions, evidence, uncertainty and confidence. Do not hardcode per-level durations or product examples. Unknown external wait stays explicitly unbounded, with a conditional numeric execution range; never invent a finite total. If execution cannot yet be estimated, show the missing input and discovery step for each affected row and keep the selection packet incomplete pending a defensible range. Explain overlaps or inversions; estimates are not guarantees or permission to skip work.",
+    "Record the comparison, estimate basis, recommendation/reason, requested/effective level, numbering version, risk floor and user selection reference in existing charter/decision evidence, not invented CLI API fields. Refresh on material changes. Preserve historical receipts: map verified legacy levels 1→5, 2→4, 3→3, 4→2, 5→1 without changing assurance; clarify ambiguous unversioned selections rather than guessing.",
+    auditor
+      ? "Remain read-only. Check the actual user-facing comparison and selection evidence, not only this instruction. Report missing levels, scope, estimates, rationale, unsafe effective levels, or ambiguous legacy numbering as findings. This is procedural guidance, not a new deterministic selection validator."
+      : "Before material implementation ensure a valid selection and complete comparison are available. Read-only discovery may continue while unresolved; do not substitute a recommendation-only message. This is procedural guidance, not a new deterministic selection validator.",
+  ].join("\n"));
+}

package/src/orchestrator/independent-audit.js

@@ -1,4 +1,8 @@
 import { bullets, cleanString, section } from "./shared.js";
+import { buildPrClosureInstruction } from "./pr-closure.js";
+import { buildUxSpecificationInstruction } from "./ux-specification.js";
+import { buildDeliveryLevelInstruction } from "./delivery-level.js";
+import { buildChecklistContinuationInstruction } from "./checklist-continuation.js";
 import {
   COMPLETION_CONTRACT_VERSION,
   acceptanceCriterionRows,
@@ -19,6 +23,10 @@ export function buildIndependentAuditInstruction(charter, attempt) {
     : [];
 
   return [
+    buildUxSpecificationInstruction({ auditor: true }),
+    buildDeliveryLevelInstruction({ auditor: true }),
+    buildChecklistContinuationInstruction({ auditor: true }),
+    buildPrClosureInstruction({ auditor: true }),
     section(
       "role",
       "You are an independent PR auditor. You did not implement this change and must not edit files.",

package/src/orchestrator/instruction.js

@@ -1,7 +1,12 @@
-import { minimumCharter } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
+import { minimumCharter } from "./delivery/scripts/check-minimum-completion.mjs";
 import { bullets, looksLikeUiTask, section } from "./shared.js";
 import { problemSolvingResultContract } from "./problem-solving.js";
 import { acceptanceCriterionRows } from "./completion-contract.js";
+import { fileURLToPath } from "node:url";
+import { buildPrClosureInstruction } from "./pr-closure.js";
+import { buildUxSpecificationInstruction } from "./ux-specification.js";
+import { buildDeliveryLevelInstruction } from "./delivery-level.js";
+import { buildChecklistContinuationInstruction } from "./checklist-continuation.js";
 import { PR_PREPARATION_CHECKS } from "./pr-preparation.js";
 
 export function buildCodingInstruction(
@@ -16,6 +21,9 @@ export function buildCodingInstruction(
 ) {
   const sections = [
     section("role", "You are the local coding executor for a SIMY agentic loop."),
+    buildUxSpecificationInstruction(),
+    buildDeliveryLevelInstruction(),
+    buildChecklistContinuationInstruction(),
     section(
       "requirement_charter",
       [
@@ -64,7 +72,7 @@ export function buildCodingInstruction(
     section("minimum_completion_evidence", [
       "All delivery levels require this floor. Before implementation reconcile every original requirement and frozen experience with the stable criterion-ID 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.",
+      `Use the packaged Web/CLI verifier: ${fileURLToPath(new URL("./delivery/scripts/check-minimum-completion.mjs", import.meta.url))}. The contract is ${fileURLToPath(new URL("./delivery/references/minimum-completion.md", import.meta.url))}. No local Codex Delivery Loop skill is required.`,
       "For each stable criterion ID 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.",
@@ -92,6 +100,7 @@ export function buildCodingInstruction(
       "Disclose remaining work, intentional skips, uncertainty, and post-merge migration/deploy/monitoring steps without calling them complete.",
     ].join("\n")),
     section("must_not", bullets(charter.must_not)),
+    buildPrClosureInstruction(),
     section(
       "active_request_reconciliation",
       [

package/src/orchestrator/loop.js

@@ -1,4 +1,4 @@
-import { minimumCharter } from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
+import { minimumCharter } from "./delivery/scripts/check-minimum-completion.mjs";
 import { auditAttempt, evaluatePrReadiness } from "./audit.js";
 import {
   buildIndependentAudit,

package/src/orchestrator/minimum-completion.js

@@ -5,11 +5,11 @@ import {
   minimumContext,
   checkMinimumCompletion,
   loadMinimumJson,
-} from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-minimum-completion.mjs";
+} from "./delivery/scripts/check-minimum-completion.mjs";
 import {
   contextDigest,
   sha256,
-} from "../codex-plugins/simy/skills/agentic-delivery-loop/scripts/check-acceptance.mjs";
+} from "./delivery/scripts/check-acceptance.mjs";
 
 export function minimumCharterDigest(charter) {
   return sha256(Buffer.from(JSON.stringify(minimumCharter(charter))));

package/src/orchestrator/pr-closure.js

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "node:url";
+import { section } from "./shared.js";
+
+export const PR_CLOSURE_GUIDE_PATH = fileURLToPath(
+  new URL("./delivery/references/pr-closure.md", import.meta.url),
+);
+
+// Both real executor and independent-auditor instructions use this contract.
+// This is not a GitHub permission hook: external mutations still need authority.
+export function buildPrClosureInstruction({ auditor = false } = {}) {
+  return section("pr_closure_gate", [
+    "Applies only when proposing, performing or auditing PR closure/supersession/retirement. It does not request closing any PR.",
+    `Before a closure decision, read the packaged Web/CLI procedure: ${PR_CLOSURE_GUIDE_PATH}`,
+    "Freeze the original outcome criteria and exact old head/base, current target base, successor heads, integrated candidate and deployed identity. Preserve intended, observed and unknown behavior separately.",
+    "Persist a criterion-ID before/after table: old PR, current base alone, integrated successors and deployed target. Account for all changed files and unintended added behavior; file counts, ancestry and green CI are not UX equivalence.",
+    "For every unresolved yellow/red row, create a new remediation PR within explicit implementation/commit/push/PR authority, grouping only coherent changes. Reuse an exact existing open remediation PR rather than duplicating it. Map every criterion ID to a real PR URL, owner and acceptance tests; a broad successor link or uncreated PR plan is insufficient for transfer_ready. Missing authority, unresolved product decisions or budget blocks remain explicit blockers. PR creation alone never makes a row green.",
+    "Verify normal production reachability and the complete trigger-to-usable-result path, with independent technical postconditions and recovery. Code surviving only in fixtures is not inherited UX. Distinguish reuse, composition, conversational design, immediate ad-hoc work and background learning, including the no-workflow/no-match fallback.",
+    "Unknown, failed or stale applicable evidence blocks close_ready. Require independent review of original requirements and raw evidence before an authorized close. Preserve initial failures; tests changed to pass do not validate the unchanged original candidate.",
+    "Unfinished successors require transfer_ready with explicit informed administrative-close authorization, accepted owner, open tracking and remaining gates; never claim full inheritance. Intentional removal requires an explicit retirement decision and safe data/migration handling.",
+    "Re-read all bound revisions, successor state, checks and authority immediately before mutation; changed inputs invalidate affected verification/review. Close and comment-posting authority are separate. Audit-only requests authorize neither.",
+    "After an authorized action, read back remote state before claiming success or retrying. Persist pre/post state, review/evidence digests, draft/comment identity, pending obligations and recovery references before cleanup. Do not infer branch deletion, successor merge, deployment or delivery completion.",
+    auditor
+      ? "You remain read-only. Independently inspect the closure table and raw proof; report gaps as findings. Closure decisions never turn unmet delivery criteria green. Do not close, reopen, comment or repair the PR."
+      : "If any required decision, evidence, independent review or authority is missing, stop the dependent close action and report the blocker. This protocol is not authorization and does not introduce a new loop completion state.",
+  ].join("\n"));
+}

package/src/orchestrator/presentation.js

@@ -88,9 +88,9 @@ export function summarizeCodingLoopEvent(snapshot, event) {
       };
     case "pr_ready_for_review":
       return {
-        summary: "Implementation is complete, but the PR still needs human review or external evidence.",
+        summary: "The run is unfinished: required PR checks, review or evidence still need verification.",
         result: pendingReasons.length ? `Pending: ${pendingReasons.join("; ")}` : cleanString(event?.message),
-        next: "Review or approve the PR, then refresh its evidence from Web or CLI.",
+        next: "Continue authorized verification, resolve the listed pending gates, then refresh evidence from Web or CLI. Obtain human approval only where required.",
       };
     case "merge_ready":
       return {

package/src/orchestrator/result.js

@@ -1,6 +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 { minimumContext } from "./delivery/scripts/check-minimum-completion.mjs";
+import { contextDigest } from "./delivery/scripts/check-acceptance.mjs";
 import { cleanString, stringArray } from "./shared.js";
 import { normalizeProblemSolving } from "./problem-solving.js";
 import {

package/src/orchestrator/ux-specification.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+import { section } from "./shared.js";
+
+export const UX_SPECIFICATION_PATH = fileURLToPath(
+  new URL("./delivery/references/ux-specification.md", import.meta.url),
+);
+
+export function buildUxSpecificationInstruction({ auditor = false } = {}) {
+  return section("ux_specification_contract", [
+    `Apply the same behavioral-completeness standard throughout requirements, design, implementation mapping, verification, review, release, closure and handoff. Read: ${UX_SPECIFICATION_PATH}`,
+    "Describe observable interaction units, not feature inventories. Reuse stable acceptance IDs. For each unit specify actor/goal, context/preconditions, trigger/reachable entry, perceived information, available action/choice/control, system response/state transition, usable outcome/postconditions, next action/handoff, alternative/failure/recovery paths, and verification oracle/provenance. Treat these as semantic obligations in the existing specification, not new CLI JSON fields.",
+    "Decompose when actor, precondition, decision, observable state, postcondition or recovery differs materially, or when any clause could fail independently. Link predecessors/successors and preserve end-to-end criteria. Derive branches and applicable constraints from authoritative requirements and observed system boundaries; do not invent scenarios, defaults, thresholds or product policy to fill gaps.",
+    "Description is sufficient only when another implementer can derive the intended behavior and an independent verifier can determine pass/fail without guessing a material requirement. Review source coverage, causal continuity, branch closure, controllability, observability, traceability, consistency and epistemic separation. Word count, row count and verbosity are not quality thresholds.",
+    "Keep required/intended/observed/assumed/unknown distinct. Unknown facts stay explicit with affected IDs and resolution evidence; a missing requirement decision blocks dependent design, while missing runtime evidence blocks the affected verification claim. Genuine non-applicability needs a source and reason, not an empty cell.",
+    "Persist the complete contract in the canonical specification and link the same IDs from summaries, matrices, PRs and receipts. Summaries may shorten repetition but must not replace or drop behavioral obligations, unresolved gaps or evidence. A phase change revalidates affected descriptions and results; plans never become observed proof by wording alone.",
+    auditor
+      ? "Remain read-only. Independently derive coverage from original sources, identify any material behavior that still requires guessing, and report affected criterion IDs and required clarification/evidence as findings. Do not infer completeness from filled fields or copied executor claims."
+      : "Before dependent implementation, resolve material specification ambiguity within authority or report needs_decision; continue independent work. Before verification or completion, repair missing descriptions/evidence rather than relabeling incomplete UX as complete. This procedural contract does not add automatic schema or GitHub enforcement.",
+  ].join("\n"));
+}

package/src/runner.js

@@ -532,6 +532,18 @@ async function runLocalCodingRun(
 
   markAttachmentsDelivered(run.request.attachments);
 
+  // All collectors and the executor must use the same root. Bind a missing
+  // default only after resolving the authorized checkout, including on resume.
+  if (!run.snapshot.charter.ui_evidence_root) {
+    const evidenceRoot = path.join(repositoryPath, ".artifacts");
+    run.snapshot.charter.ui_evidence_root = evidenceRoot;
+    run.request.ui_evidence_root = evidenceRoot;
+    appendEvent(run.snapshot, run.status, "Local evidence root bound to the verified checkout.", {
+      code: "local_evidence_root_bound",
+    });
+    await updateRun(run, run.status);
+  }
+
   const executor =
     executeAttempt ||
     ((context) =>

package/src/codex-plugins/simy/skills/agentic-delivery-loop/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Agentic Delivery Loop"
-  short_description: "Converge code changes through real live proof"
-  default_prompt: "Use $agentic-delivery-loop to take this change from reproduction through verified delivery."
-