project-tiny-context-harness 0.8.17 → 0.12.0

package/assets/skills/long-task-workflow/SKILL.md

@@ -1,75 +0,0 @@
----
-name: long-task-workflow
-description: Author, preflight, execute, resume, verify, or close one complete Single-Goal Delivery Contract in the currently selected host execution Goal and workspace. Use only when explicitly invoked or a valid common-dir active authority binding exists.
----
-
-# Single-Goal Long-Task Workflow
-
-## Boundaries
-
-Use one currently selected host execution Goal, one repository, one selected verification workspace, one complete Contract and one Final Gate. This workflow never creates, invokes or manages a scheduler, agent runtime, App Server, branch/worktree fan-out, merge, push, PR, deployment, legacy orchestration chain, matrix, verdict or second Contract plan. The parent Goal owns Source, Contract, Authority, architecture, Context writeback, integration, current-candidate checks, formal verification, Final Gate, close and completion. Harness never allocates, schedules, retries or recovers delegated workers; their reports are not Progress, Evidence or proof, and every result must converge into the selected verification workspace before verification counts. Never activate from task size alone.
-
-That Goal is host/user-selected; Harness does not create, persist or reconnect a Goal identifier. Compaction may continue inside it; a later physical Goal/session restores semantic state through `resume`, not a prior Turn. With a valid binding, run `ty-context long-task resume <workdir>`, then directly load the installed `long-task-workflow` Skill; recovery needs no implicit invocation.
-
-The host/user owns model selection. Exactly one unconditional terminal-turn checkpoint follows the first Authority Lock before implementation. Harness neither switches nor verifies the model, persists checkpoint/acknowledgement/route state, nor creates a model scheduler, automatic switch or native-Goal completion state. Do not otherwise pause a healthy Goal solely to change models.
-
-A Codex-root `long-task` install may expose fixed package-owned `long_task_implementation` with child agents disabled. It is static, stateless, non-Authority and post-checkpoint; install proves neither selection nor effective model/reasoning/tier. Profile and spawn never set `service_tier`. Exact-call or capability failure returns a packet to the parent; never infer it, use a generic child, or add tiers/retry/scheduling.
-
-`long-task-delivery-v2` is the active Contract schema. `delivery-contract.yaml` is the root authoring file. New authoring uses inline Outcomes; existing `outcome_files` are compatibility only. Legacy split-delivery commands are non-executing.
-
-## Controlling Objective
-
-Prevent false completion inside declared authority. Given complete and accurate Source, a meaning-preserving Contract projection, complete applicability and the admitted-observer boundary, `AcceptedDeliveryTerminal` implies no declared machine-observable drift remains. Machine completion requires package-admitted Actual and Harness-owned comparison; unsupported proof remains blocking External Confirmation. Implementation may drift or require rework, but every declared requirement, Fact, proof obligation and independently falsifiable AC stays traceable, and every unproved item blocks or qualifies completion.
-
-Complete Source is not a prose or current-code ceiling. Material non-UI meaning uses the finest independently decidable standard and custom semantic Facts plus every required proof method. For selected design resources, Agent implementation, acceptance and testing fully conform to every material Fact in declared scope and conditions; formal input therefore uses complete canonical acquisition, Census, atomic Fact/proof closure and exact production-target evidence. Deliberately partial design input remains an explicitly scoped constraint or blocking unresolved input; incomplete implementation-source acquisition is blocking, and an exact target requires layout and pixel Facts for every declared condition. `UI symbolic V2 is explicit opt-in; V1 remains the default.` Non-UI symbolic admission remains out of scope; machine-observer and verifier/runner trust-boundary closure is mandatory rather than deferred Provider/P0 work. Read the Source, Contract and Evidence references for the exact V1/V2 authoring and proof rules.
-
-Only fresh evidence from the complete current final snapshot may create machine acceptance. Exactly fresh `machine_accepted` with no pending External Confirmation is `AcceptedDeliveryTerminal`; `machine_accepted_external_pending` proves only declared machine scope. Progress is repair evidence only and never acceptance authority. Final Gate is the sole Long-Task Engineering Quality Conformance and Architecture Conformance carrier, and it proves only the declared, falsifiable, project-check-bound set—not overall code quality. This adds no quality Boolean, matrix, Source aspect, Claim/risk kind, Contract field, second Gate, state or Receipt, and no separate default Contract Conformance closure runs.
-
-Anti-Degradation Assurance protects coverage, false-negative resistance, fail-closed Authority and final-snapshot proof before cost. Purpose replacement requires a project-owner design-purpose decision and replacement proof. `F = Implementation Freedom Boundary` leaves methods, feedback, packet decomposition and dynamic count Goal-owned within Source/Contract/safety. After the checkpoint, identify packets before profile/capacity. Each is `independently_safe`, has `positive_expected_parallel_benefit` and `bounded_input_and_output`, is `parent_integratable`, and the set is pairwise `owner_disjoint`, `path_disjoint` and `source_of_truth_disjoint`. Unless explicit user/host policy prohibits agents, make actual host calls for multiple exact workers with `agent_type: long_task_implementation`; intent is not delegation and only call or explicit capability results establish profile/capacity. Count stays dynamic.
-
-Select one zero-start reason by the Workflow Contract's ordered first-match rule: policy prohibition -> insufficient base candidates -> disjointness conflict -> coordination cost -> actual exact-spawn capacity failure -> other exact-worker unavailability. Unknown capacity is not insufficiency. Once any exact worker starts, later profile/capacity failure is partial delegation rather than a parent-only reason: keep that worker, return the rest to the parent and report the cause; use no generic substitute or retry. A type mismatch returns its packet. Never override `service_tier` or claim unobservable inheritance. Add no development phase/method Gate, fixed count/Outcome mapping, allocator/scheduler, queue/DAG/registry/proof or persistent delegation state.
-
-Each worker gets one self-contained packet containing its goal, allowed owners and paths, forbidden paths, relevant Source, Contract and Context references, implementation entrypoints, checks, expected return format and known dependency/integration risk. Before dispatch, the parent reads `git status --short` and `git diff --name-only` non-persistently. Workers only implement/check; truth, Authority, spawning, worktrees and acceptance remain parent-owned. `PreToolUse` denies non-exact creation and freshly checks visible profile parity; `SubagentStart` reinforces type without proving trust, effective execution or load atomicity. After return, the parent inspects the actual diff and integrates results only after comparing actual changed paths and the final working-tree diff with the union of packet envelopes. This proves path-envelope conformance, not per-line actor attribution; unexplained/overlapping/out-of-envelope/shared-owner changes block integration and Final Gate.
-
-## Progressive Reference Loading
-
-Read the reference for the current activity completely. These four one-level references are detailed guidance, not new artifacts, stages or authority:
-
-- For raw, mixed, attachment-heavy, incomplete or conversation-only inputs, read [`references/source-authoring.md`](references/source-authoring.md) alongside Contract authoring. It owns Source inventory, synthesis/refinement, provenance, preference/research decisions, complete semantic input expansion, selected-resource intake and marker convergence inside the same Draft loop.
-- Before creating or structurally revising Source markers, Outcomes, requirements, Controls, obligations, applicability, architecture boundaries, paths, Bindings, Assertions or risk, read [`references/contract-authoring.md`](references/contract-authoring.md). It owns the exact Contract projection and structural closure rules, including selected-design V1/V2 authoring.
-- Before creating or repairing Checks, runners, Observations, proof surfaces, Counterfactuals, Population/environment probes or selected-design evidence, read [`references/evidence-design.md`](references/evidence-design.md). It owns exact execution evidence, sensitivity and Oracle boundaries.
-- Before Preflight, Compile, the one-time model checkpoint, protected revision, resume, targeted verify, Final Gate, Stop, close or abandon, read [`references/authority-lifecycle.md`](references/authority-lifecycle.md). It owns command and lifecycle detail.
-
-Do not copy reference detail into another Skill, plan or state file. The same `delivery-contract.yaml`, active authority and current workspace remain the only lifecycle surfaces.
-
-## Contract Draft And Outcome Decomposition
-
-Every external initial proposal, selected design resource, ordinary planning document or other material input enters the same non-authoritative `delivery-contract.yaml` Draft immediately. Inventory, Source-quality synthesis/refinement, provenance, markers, repository binding and Contract mapping converge in one `long-task-workflow` lifecycle and need not be completed in one response. Conversation-only material becomes exactly one project-native Markdown Source. Do not create a Source-authoring phase, standalone Contract Draft Skill, Draft Receipt, Authoring State, draft schema/CLI/runtime state, handoff or second plan.
-
-A Draft Outcome is an Outcome before Authority Lock, not a new schema field or runtime entity. Decompose only vertical, independently observable, decidable and target-verifiable results whose dependencies and owner boundary can be stated. `depends_on` and Stage gates express acceptance and intermediate-proof readiness, never implementation permission. Do not split for response/YAML/file length, implementation layer, module/file count, Agent capacity, Worker assignment or desired parallelism.
-
-> Outcome decomposes execution and diagnosis, not completion authority.
-
-## Lifecycle Summary
-
-1. Read the request, real Source, relevant Context, repository owners and selected design resources. Before formal Compile and the first implementation edit, surface one repository-bound `Architecture Deliberation`: owner/extension point/source of truth, dependencies and lifecycle, selected and rejected alternatives, future-change challenge, debt disposition, forbidden shortcuts, project-owned Checks and triggered quality attributes or concrete preservation. Put durable conclusions in owning Context and material falsifiable delivery conclusions in real marked Source plus existing Contract fields. Decide `Context Delta: none|required`.
-2. Open the one Contract Draft immediately. When inputs need Source repair, read Source authoring and Contract authoring together; preserve at least one real `source_path`, complete all required semantic/design closure and repair every `decision_required` item without inventing product meaning.
-3. Run read-only `ty-context long-task preflight <workdir>`, repair the same Draft, then run formal Compile only when Source, Context, Contract, repository scope and proof bindings are ready. Compile creates the first Authority Lock; Preflight creates no Authority, Progress, Receipt or state.
-4. On the first Compile result with `execution_model_checkpoint.required: true`, do no product implementation, edit, build or test; end the turn. Tell a Chinese-speaking user exactly `处理好模型更换后，请仅回复：模型切换卡点解除，继续`; in English use `After handling the model change, reply exactly: model checkpoint cleared, continue`. Generic continuation does not satisfy this managed prompt protocol. Harness observes neither the next host message nor the model change, so this is no machine unlock or attestation. Later Compile returns `required: false` without repeating the pause.
-5. After continuation, begin Goal-owned rolling implementation and apply Delegation Suitability above. Qualifying work gets actual multiple exact `long_task_implementation` calls; otherwise record one admitted solo reason. Keep coupled work in the parent. Refresh Context Delta and Architecture Deliberation when durable scope, ownership, dependency, design, quality or debt changes.
-6. Use targeted verification only when its expected localization value exceeds cost. If authority changes, keep the same Draft and follow protected revision; mechanically bounded repairs may auto-adopt, while semantic weakening or unknown change requires the exact user decision. Adoption returns to rolling implementation and is never completion.
-7. Complete Context, implementation and project tests, create the clean candidate required by the lifecycle reference, then run the one source-recompiled current-snapshot Final Gate. Stop/close and any native Goal completion remain subject to the exact lifecycle and veto rules in the Authority reference.
-
-## Rolling Execution
-
-Apply packet-first above. Outcomes/Stages govern acceptance, not edits; coherent-owner packets may cross them. Parent retains Authority, packet selection, Context, integration and verification; proof-bearing changes converge into the selected verification workspace.
-
-The derived Frontier is only an acceptance/verification and diagnosis projection. Use `verify --explain [--outcome/--check]` for a read-only cost preview and targeted `verify --outcome/--check` for optional feedback. `progress_stale` is a freshness fact; refresh only before an intermediate decision relies on that Progress. Continuing implementation and entering Final Gate need no targeted refresh because Final Gate ignores Progress and reruns all required Checks. Do not add another model-switch pause, trigger queue, implementation gate, per-edit rebuild rule or per-platform progress state.
-
-When implementation discovers a blocker, classify it under the existing protected-revision rules. Difficulty or delay never makes machine-verifiable scope external and never removes Source. Keep exact revision identity, old-Authority continuity, compare-and-swap adoption, evidence invalidation and the complete Final Gate; use the lifecycle reference for diagnosis, decision transport, approval and adoption.
-
-## Final Authority And Handoff
-
-Final Gate recompiles Source authority, freezes and rechecks the complete protected current snapshot, reruns every declared Check and sensitivity control and rejects any protected-input, workspace/tree or Active Authority drift. It never trusts historical Progress, Receipt, compiled cache, delegated report or Agent judgment. Before invoking native Goal completion, perform the required veto-only comparison of current user/Goal meaning with accepted marked Source; mismatch returns to Source/Contract repair and creates no second Gate or proof.
-
-Report implementation/risk, Architecture and Engineering Quality Conformance, Claim Coverage, Stage/target/Gate results, acceptance scope, pending External Confirmations, Context and blockers. Use verifier terms and state boundaries honestly: undeclared/inaccurate Source and unsound project Oracles are not mechanically repaired; Final Gate proves only declared machine authority and its project-check-bound quality set; the host/user owns the native Goal/model; worker injection and reports are not acceptance inputs. The observer remains Level 3; `observed_lifecycle_*` facts cannot replace complete total-cost ROI or the independent audit required for Level 4.

package/assets/skills/long-task-workflow/agents/openai.yaml

@@ -1,6 +0,0 @@
-interface:
-  display_name: "Long-Task Workflow"
-  short_description: "Run one Delivery Contract in the current native Goal"
-  default_prompt: "Use $long-task-workflow for one Canonical Delivery Contract. After the first-Authority-Lock checkpoint, identify qualifying bounded packets before profile/capacity; absent an explicit policy prohibition, make actual calls for multiple exact long_task_implementation workers and let host results determine zero-start or partial fallback. Never infer unavailability, use a generic substitute or fix the count. Keep Source, Contract, Authority, architecture, Context, packet selection, integration and formal verification in the parent Goal."
-policy:
-  allow_implicit_invocation: false

package/assets/skills/long-task-workflow/references/authority-lifecycle.md

@@ -1,80 +0,0 @@
-# Authority Lifecycle Reference
-
-Read this before Preflight, Compile, revision, resume, targeted verify, Final Gate, Stop, close or abandon.
-
-## Preflight And Compile
-
-Run `ty-context long-task preflight <workdir>` before first formal Compile. Resolve every `error` and `decision_required` diagnostic and review warnings. Preflight is read-only: it creates no Active Authority, initial base, marker, cache, Progress, Receipt or pending revision, runs no project Check and persists no success record.
-
-Preflight and Compile call the same activation-safety validator. Skipping Preflight bypasses no closed-grammar Source/background continuity, semantic-manifest input/Census/family/unit/relation/population/condition/property/Fact/proof set closure, architecture Source obligation, Control field/relation closure, atomic applicability dimensions, criterion, Claim/all-of-surface, Population universe binding, Stage closure/cross-surface gate, required-target/root/capability/runner binding, scenario/journey separation, capability adequacy, typed external impact, per-Fact semantic proof binding, per-method selected-design artifact binding, bounded Product Conformance, adapter/Observation, risk, owner/path/Binding, recursively frozen verifier dependencies, narrow semantic Counterfactual/liveness or sensitivity rule.
-
-The same workspace classifier also runs before activation and during verification. Before first lock it classifies `HEAD`-relative current paths; later it classifies immutable-`initial_task_base` changes. Protected authority, declared expected change and allowed support remain distinct from forbidden or unclassified paths, which block activation. During first enable, protection covers only exact files present in the current package asset tree for configured managed destinations plus the exact harness config/hook files; managed directory roots and broad `.codex/**` are never implicitly allowed.
-
-Preflight keeps every independently discovered diagnostic. When a structural duplicate makes the same Claim ambiguous or repeated, only that pair receives stable `diagnostic_id`, `repair_group`, `repair_priority` and `blocked_by` metadata so the structural blocker is repaired first. Independent findings keep their compact existing shape; no finding is hidden, reclassified or treated as resolved, and no repair state or authority is created.
-
-The first successful `ty-context long-task compile <workdir>` is Authority Lock and freezes the immutable initial base and complete compiled authority snapshot in Git common-dir, bound to the worktree marker by task id, revision and compiled identity.
-
-Its JSON result includes `execution_model_checkpoint.required: true`, `action: change_model_in_host_then_continue`, `resume_token: model checkpoint cleared, continue`, `generic_continue_satisfies: false`, `turn_boundary: end_current_turn`, the blocked implementation actions and explicit model non-observability. Always do no product implementation, file edit, build or test after that result, even when an earlier message stated a model strategy. End the turn and tell a Chinese-speaking user exactly `处理好模型更换后，请仅回复：模型切换卡点解除，继续`; use `After handling the model change, reply exactly: model checkpoint cleared, continue` in English. Do not accept a generic continuation under this package-managed prompt protocol. Harness cannot observe the next host message or verify the host model change, and the continuation is neither a machine-enforced unlock nor an acknowledgement record. Later Compile revisions return `required: false`; no checkpoint file, acknowledgement state, model route or automatic model switch is created.
-
-The optional Codex `long_task_implementation` custom agent is available only as a post-checkpoint rolling implementation affordance. Its fixed package-owned configuration is not a checkpoint option and cannot acknowledge, satisfy or replace the host boundary. It writes no workflow state and owns no Source, Contract, Authority, Context writeback, Progress, Evidence, Receipt or Final Gate; if the exact profile selector or Codex custom-agent support is unavailable, the parent Goal continues directly without a generic substitute and formal acceptance is unchanged. The main Skill owns the complete Delegation Suitability and parent/worker policy.
-
-## Protected Revision
-
-After Authority Lock, every candidate compares against active authority. `authority_changed` does not by itself mean `user_decision_required`:
-
-1. proven monotonic evidence strengthening—including added capabilities while preserving every existing Assertion meaning—and proven tightening auto-revise;
-2. mechanically bounded repair may auto-revise when compiled user-facing meaning and proof obligations stay fixed: raw Source/Context snapshot updates with unchanged Claims/targets, operational Runner or verification-input repair, risk strengthening and machine-proven equivalent Counterfactual Claim/assertion-failure coverage;
-3. repo-bound owner/expected-change/allowed-support or Binding-carrier expansion may auto-revise; `diagnose-revision` may exercise existing active Check identities without creating state before final Compile; or
-4. Product/Source Claim/target/external-confirmation change, lost scenario/Claim/Evidence Capability/failure interception, forbidden or owner-Context removal, runner type/effect change, verifier-kernel change and every unknown reason fails closed for the exact revision identity and is never candidate-executed.
-
-Automatic adoption never means “unprotected”: exact identity, active-Authority compare-and-swap, affected-evidence invalidation and the complete source-recompiled Final Gate remain mandatory. Risk downgrade is still rejected.
-
-`diagnose-revision` recompiles the same `delivery-contract.yaml` in memory, creates only a disposable workspace snapshot when class 2 is proven, and returns transient repair results with `acceptance_authorized: false`. It writes no pending/approval state, authority/marker, cache, Progress or Receipt. Repeated edits therefore accumulate only in the one existing Contract authoring file, not a pending Draft authority or candidate state plane.
-
-Ordinary `compile --revise` is the only operation that may create the one pending decision. It binds a deterministic concise change summary into the revision identity and distinguishes `user_decision_reasons` from `mechanically_bounded_reasons`. Compile/status/resume derive the same self-contained `decision_brief` from that canonical summary. The brief explains what Authority Revision is, why this one needs a decision, material changes, affected Outcomes, previous-Authority/reject behavior, the no-completion effect and mandatory Final Gate.
-
-Present that brief before asking for the exact identity. First compare every listed decision reason with explicit instructions in the current task: if one task-specific instruction already covers all of them exactly, mechanically relay that existing user decision through the exact approval command without asking again. This is decision transport, not Agent approval. A generic continue/resume/finish, blanket “approve later revisions”, recommendation, partial coverage or Agent inference never qualifies. The executing Agent never originates its own weakening decision.
-
-During repair, use stateless diagnosis and ordinary edits; do not invoke decision-producing Compile for intermediate candidates. Withdrawn or replaced identities therefore generate no question. When the final blocking candidate is stable, ask at most once. If it later changes, its identity changes and any old approval is rejected. No instruction ledger, standing approval or candidate state is created.
-
-The previous Authority remains active until exact approval and compare-and-swap adoption. Adoption reports `delivery_completed_by_this_event: false`, invalidates affected evidence and returns to rolling implementation or repair under the revised Authority; the complete source-recompiled Final Gate remains mandatory.
-
-Every path-bearing field uses canonical grammar. Internal `.`/`..`, control characters, empty segments, absolute/drive/UNC paths and unsupported glob syntax fail closed.
-
-Controlling Context includes core Context, explicit `context_refs`, verification/deployment Context and every selected Context file. `context_snapshot_mode: full` is mandatory; legacy referenced-mode Contracts require semantic migration rather than silently retaining a partial authority snapshot.
-
-A selected design target, its exact/constraint interpretation, an authored token source or any applicable Control semantic is product/verification authority, not generated evidence. External design resources are ordinary Context-reachable Source: a candidate or unresolved selection cannot authorize fidelity work, while a selected exact target still requires downstream UI Authority Closure, stable key, readable immutable identity/digest, declared Fact universe, editable upstream/update route and Contract adoption. Open every affected exact target/constraint during authoring and repair; a registry mention alone is not consumption. Adding or changing its selected resource, selection basis, immutable identity, condition/variation/property/Fact/proof universe, expected located digest, comparator/tolerance/mask, Oracle/environment, sensitivity policy or acceptance-affecting token/prototype fixture after Authority Lock follows Authority Revision and returns to rolling implementation. Never silently overwrite an adopted baseline; a candidate/planned target, implementation screenshot or historical diff cannot authorize fidelity work or preserve affected Progress by itself.
-
-`context.toml` retrieval guidance (`triggers`, `read_when`, `read_policy`, default selection and unselected nodes) is excluded from the selected delivery-authority projection. Selected area ownership, role/dependency structure and selected Context contents remain protected revision material. Retrieval-only edits may preserve scoped Progress, but a changed final Git tree still invalidates historical final acceptance and must pass the Live Final Gate again.
-
-## Targeted Verification And Recovery
-
-Implementation remains parent-Goal-owned throughout rolling execution. Apply the complete suitability and worker policy in the main Skill; Harness allocates and records no worker. Delegated reports are not Progress, Evidence or proof, and every proof-bearing result must converge into the selected verification workspace. Stage/Outcome readiness, `progress_stale` and targeted feedback never become agent allocation, edit permission, a method Gate or a scheduler.
-
-`verify --explain [--outcome/--check]` is a read-only execution preview. It groups declared Main Raw Executions, lists applicable Counterfactual runner invocations and bounded declared retry-attempt counts, but runs no command, writes no Progress, predicts no duration/internal subprocess count and creates no proof.
-
-Before an expensive first targeted run, use the preview to review selected Check count, deduplicated Main executions, Counterfactual mutations and retry bounds. If the expanded plan reveals an obsolete carrier, unnecessarily broad invalidation surface or repeated expensive runner, repair the same Contract Draft/Authority through the normal revision path. The preview cannot see build systems or subprocesses hidden inside a project runner.
-
-`verify --outcome/--check` runs scoped current-snapshot checks for repair and rechecks active identity before writing Progress. A Counterfactual finding is projected into the owning Main Check, changes an otherwise passed Check to `invalid_evidence`, clears Claim proofs and remains recoverable through `status`/`resume`. Global Checks use the same record without a new Global Outcome state.
-
-For a declared target-runtime Check, the earliest useful runnable boundary and later coalesced relevant changes are recommended targeted-feedback points only when their expected localization value exceeds cost. The owning Outcome binds proof; it does not gate implementation order. `progress_stale` is a fact about evidence freshness, not an immediate execution instruction. Refresh the declared Check only before an intermediate decision relies on its Progress. Continuing implementation and entering Final Gate require no targeted refresh because Final Gate ignores Progress and reruns all Checks. Do not create a per-edit/per-Outcome rebuild rule, implementation gate, trigger queue or platform state. These runs remain `acceptance_authorized: false`.
-
-Do not add a second executing `diagnose-check` mode merely to avoid Progress: it would still pay the project runner's cost and create a competing execution path. Use project-owned fast feedback while editing, the read-only preview for declared cost shape, targeted verify at a useful stability boundary and the complete Final Gate for acceptance.
-
-Progress freshness binds Outcome authority, applicability, runner, verification inputs, Controlling Context and implementation inputs. Retry defaults to none; one retry is allowed only for explicit `transient_once`, idempotent, read-only/test-sandbox work.
-
-Status, Progress, Receipts and workdir compiled output are audit/recovery projections only. Development-period authority state is `manual_required` and never migrated.
-
-Report their exact meaning: `progress_passing` is current targeted repair evidence rather than “Outcome complete”; `progress_stale` is a freshness fact rather than a current pass or immediate rerun command; `final_workflow_status: null` means the Goal is unfinished. `status`/`resume` derive `ready_stages`, `ready_outcomes` and Stage status from current Progress; they do not persist a Stage pass. `target_state` remains `not_accepted` until a fresh Final Gate accepts, becomes `blocked_external` for a target blocker, or names the Contract's `implementation_complete`, `target_profile_usable` or `production_release_ready` state after machine acceptance. Do not invent per-platform progress/status.
-
-## Final Gate And Terminal Paths
-
-Before Final Gate, complete Context/code/tests and create a clean candidate commit. Final Gate first verifies the accepted compiled authority is still fresh, then recompiles Source authority and records semantic plus raw protected-input identity for the Contract and fragments, the Source-embedded semantic manifest, every Source file, full Controlling Context, verifier/runner, recursively frozen local verifier dependencies, `verification_inputs` and workdir inputs. It validates the common-dir record/marker, creates one Git-tree snapshot and reruns every Check and sensitivity control. Non-UI semantic evidence must reproduce exactly every compiled machine Fact × method expectation with one attributable actual observation/environment/comparison/verdict under frozen expected/tolerance/mask/Oracle authority; selected-design method evidence must reproduce its exact compiled `fact_results` universe; every verdict passes, while named external obligations remain pending rather than fabricated. After execution it recompiles and re-hashes the same full protected set; any change returns `protected_inputs_changed_during_final_gate`, while an Active Authority race returns `active_authority_changed_during_final_gate`. Only unchanged protected inputs, workspace/tree and Authority may be accepted. It is the sole Long-Task `Engineering Quality Conformance`/`Architecture Conformance` carrier and the sole non-UI semantic and selected-design closure carrier: material independently falsifiable deliberation conclusions must already be declared through existing Source-backed obligations/constraints/forbidden shortcuts, owners/paths/Bindings, project-owned Checks and separate Assertions when functional behavior can pass independently. It proves exactly that declared project-check-bound engineering-quality set, not overall code quality, and no separate default Contract Conformance closure runs. A target-runtime Check must exercise its exact target again in that Final Gate execution; rereading historical status does not become live proof merely because the reader reran. The Receipt reports the target profile/state and every Stage as `passed`, `failed`, `blocked_external` or `blocked_dependency`.
-
-Commit, verifier migration, clear and abandon share one active-state lock. Stop/close clear only the identity actually accepted through CAS and preserve `machine_accepted_external_pending` plus every named external confirmation in output. Final Gate/Stop/close identify `acceptance_scope: declared_machine_authority` and `native_goal_effect: none`; close additionally identifies `closed_scope: machine_authority`. The Stop Hook emits the same scope as one non-blocking message for either accepted machine status. A stale Receipt exposes no accepted workflow status.
-
-Before platform-native Goal completion, compare current Goal/user meaning with accepted marked Source and check for a pending revision, unresolved blocker or omitted requirement. This review may only veto completion and direct Source/Contract repair; it is not a second acceptance Gate and cannot create proof.
-
-For invalid, mismatched, unrecoverable or stale-lock continuity, use only `ty-context long-task abandon <workdir> --force-corrupt-state`; it preserves authored Contract, Source, Context and Git content.
-
-An older `long-task-delivery-v2` Contract that lacks the Source `semantic-fact-manifest-v1`, root manifest identity, exact Outcome Fact/proof bindings, typed per-Fact results, Stage, required-target capabilities, full Context mode, atomic applicability dimensions, scenario, journey, success/degradation, Population universe binding, Control-relation applicability, per-method design record/primary-observation artifacts, canonical design `fact_expectations`, blocker-required capabilities, narrow semantic witnesses or typed external-impact fields is a manual migration. `upgrade --check` reports `long-task-v2-semantic-drift-authority`, and parsing lists missing field paths. Re-author the semantic universe and those meanings from Source, controlling Context and any current validated handoff; never infer them from old Progress/Receipts or import historical passing evidence as acceptance. Reclassify every Check path explicitly: implementation/runtime material belongs in `input_paths`, `expected_output_paths` or `artifact_globs`; Oracle/config/data inputs belong in `verification_inputs`. Supported direct-literal local Oracle dependencies are frozen recursively, while non-literal loaders fail closed and indirect runtime access remains declared Oracle TCB.

package/assets/skills/long-task-workflow/references/contract-authoring.md

@@ -1,152 +0,0 @@
-# Contract Authoring Reference
-
-Read this only while authoring or structurally revising the one `delivery-contract.yaml` Draft.
-
-## Source And Semantic Boundary
-
-- Every declared Source file contains at least one Material Source Item. Mark items in original Markdown without rendering or changing meaning. Every other non-empty line belongs to the one schema-valid `design-resource-handoff-v1` formal block or a closed-grammar background block: `markdown-structure` permits only text-free anchors/horizontal rules and `provenance` permits only `ty-source-provenance` comments with fixed `input`, `mode`, conditional `source` and optional `sha256` fields. A text-bearing heading or free-form provenance field may carry authority and cannot be background. Arbitrary background prose and every other unclassified line fail closed.
-- Marker keys and `source_claim` keys are set-equal and globally unique. `statement` preserves marked text after line-ending normalization, surrounding blank-line removal and trailing-space cleanup.
-- Typed dispositions keep Result, Requirement, Control, Technical Obligation, Non-completing Claim, Acceptance, Global Constraint/Non-goal, Forbidden Shortcut, Risk, External Confirmation and Decision distinct.
-- Every non-decision Source item owns exactly one same-kind, text-identical canonical target; no target may collapse multiple Source items. `out_of_scope` is not a resolution.
-- A Source AC maps criterion-identically to one named Assertion and proves at least one independently Source-backed non-Result Claim.
-- At least one `technical_obligation` Source Item has `aspect=architecture`, maps text-identically to a named architecture obligation and is independently provable; a generic Result or unmarked architecture review cannot substitute.
-- Missing headings or keys from a pre-existing planning document never blocks authoring. Raw/mixed inputs enter this Contract Draft immediately; apply `source-authoring.md` alongside mapping until real Source, provenance and markers converge. Missing mandatory Material Source Item markers still blocks Preflight/Compile.
-- A revised initial proposal and selected design resources are parallel Source inputs. Preserve their stable resource/surface/control/state/target keys, declared conditions, provider/project/run/entry provenance and immutable digest/snapshot; do not flatten visual meaning into an untraceable prose summary.
-- `delegated` in an input proposal is provenance, not a Contract disposition or new Claim kind. An instruction to synthesize, refine, complete, implement or use judgment delegates plan-level authoring, but it does not invent material tradeoff preferences. Before comparative research or a material product, technical, architecture or provider selection, identify the criteria that could change the research scope, candidate set or recommendation. If such a preference is unknown or ambiguous, ask a concise targeted question before research or selection and keep the item `decision_required` until answered; do not impose a fixed questionnaire or re-ask preferences already supplied by the user, Source, Context or controlling constraints.
-- Once the material preference envelope is clear, use current authoritative or primary evidence for external capability, price, quota, license, compatibility, region, security posture or support claims. When one defensible recommendation exists, record the authoring instruction, preference/evidence or conservative-default basis and exact added meaning in real Source, then preserve that keyed item as ordinary Source of its semantic kind. If ordinary prose is the Source, append the delegated item without rewriting the user's original text; never place the choice only in Contract YAML.
-- A delegated plan choice is not action authorization. Payment, contracting, production deployment/publication, destructive production mutation, real permission grants, sensitive-data transmission and required legal/security/human approval remain named External Confirmations. Conflicting authority, an explicitly user-reserved choice, a missing material preference or the absence of a defensible recommendation remains `decision_required`; high impact or multiple options with known criteria alone does not.
-- A rolling implementation blocker is not an External Confirmation merely because work is difficult, delayed or unavailable through the current implementation path. Reclassify or remove machine-verifiable scope only through an explicit marked Source change and protected exact approval; otherwise keep the requirement and revise the implementation/evidence path.
-- Exactly one Source-embedded `semantic-fact-manifest-v1` is mandatory. Root `semantic_fact_manifest` binds its key, declared Source path and immutable digest. Its scope includes every Outcome and every Material Source Item; ordinary Material Source cannot be `supporting_only`, while independently validated design-owned Source may be `ui_design`. Full Controlling Context inventory and every other declared attachment/specification/repository/external/delegated input are classified with exact digest, Fact refs or explicit basis-backed disposition.
-
-## Non-UI Semantic Fact Projection
-
-The semantic manifest is the task-local Source index, not a second Contract or durable value authority. It must already close the complete standard/custom semantic family floor, stable subject/relation/population Census, exact applicable condition axes/values/combinations, atomic property partitions, Fact Cells/Facts, proof obligations, Oracles/environments/blockers and complete-generation identities before Compile. Values stay at their Source locators; Contract freezes identities, located digests and comparison authority.
-
-For every Outcome:
-
-- `semantic_fact_bindings.manifest_ref` equals the root manifest key;
-- `semantic_fact_bindings.facts` is set-equal to that Outcome's manifest Facts. Each row binds one `fact_ref` to exactly the generated `semantic_fact.<fact_ref>` Claim and one matching atomic applicability profile;
-- `semantic_fact_bindings.proofs` is set-equal to that Outcome's Fact × required-method obligations. A machine row preserves method, proof surface and all evidence capabilities, binds one owning Check and one single-Claim Assertion at the same applicability, and is legal only when Compile can project it to one package-admitted current-Actual authority. An external row binds one typed External Confirmation whose impacts include the full Fact Claim;
-- every declared observer resolves to an execution target and admitted package adapter capable of observing the furthest independently failing boundary; a project-authored Oracle, product/self-reporting proxy, wrapper or submitted capability record cannot impersonate that observer;
-- the Claim/Assertion/Check projection must be bijective. Missing, extra, duplicate, reused, narrowed or orphan Fact/proof identities block Authority Lock.
-
-The exact invariants are:
-
-`Expected Semantic Facts = Source Indexed Facts = Contract Indexed Facts`
-
-`Source Fact × required-method obligations = Contract proof bindings = current Final-Gate result identities`
-
-Do not copy raw semantic values into Contract, merge multiple atomic facts into one Claim, use one Assertion for several Fact obligations, turn a machine-verifiable Fact external because implementation is difficult, or accept a default/sample/aggregate path. A protected Fact uses digest-only expected authority and a policy-bound redacted/digest observation with no raw persistence. Genuine decision/external authority remains explicit and target-blocking as required.
-
-Compile derives one internal observation-authority row for each machine proof. Current admission has only two choices: `package_static_json_exact` for plain `exact_value + exact` static implementation/configuration content in a pre-run-frozen UTF-8 JSON production carrier, and `package_process_json_exact` for plain exact output observed while Harness directly spawns the declared `process` product root. Every other proof—including custom/`named_external_tcb` Oracles, project wrappers, protected data, tolerance/mask, custom locators and browser/native/device/layout/pixel/accessibility/motion observations—must be authored as a blocking External Confirmation. This projection is not a new Contract field, Authority, state or registry, and unsupported machine rows fail Compile rather than auto-migrating.
-
-## Outcome Boundary
-
-Create an Outcome only when its result is independently observable, decidable, target-verifiable, dependency-expressible and localizable to its own Claims, Assertions, Checks and owner boundary. Requirement coupling, acceptance/verification-ready projection, targeted verification, precise failure localization, semantic resume and stale-result invalidation are valid reasons to decompose. Outcome boundaries never restrict implementation order. File count, implementation layer, context length, desired parallelism and Agent capacity are not.
-
-For every Outcome declare:
-
-- one complete observable result;
-- atomic requirements and actually applicable controls/states;
-- non-completing claims;
-- owner Context/surfaces and expected/support/forbidden path envelopes;
-- stable technical obligations, Bindings, forbidden shortcuts and recovery requirements;
-- risk facts;
-- executable Checks and named AC Assertions.
-
-Global non-goals, constraints and forbidden shortcuts remain Global authority and use Global Checks/Assertions when machine proof is required.
-
-Declare only real applicability, not a blind Cartesian product. Each global or Outcome profile names one exact execution target, journey role, a non-empty duplicate-free set of atomic dimension assignments, keyed Given condition/input/state facts and ordered When actions. One profile cannot bundle phone/tablet, light/dark, default/loading or other multiple values of the same dimension. Every Claim-bearing fact lists all and only its applicable profile refs. Every Claim-bearing Assertion proves exactly one Claim in exactly one matching profile, and every required proof surface of every actual applicable cell has an attributable Assertion. Two cells may share one Check execution only when their individual Assertion failures remain distinguishable; risk-based, pairwise, representative or sampled coverage never substitutes for a declared applicable cell.
-
-## Feedback-cost boundary
-
-Declare each Check's `input_paths` and Binding carriers as the smallest sound causal envelope for that Check. Do not use a repository, application or platform root merely because it is convenient: a broad pattern is justified only when any matching change can actually invalidate the declared result. If independent capabilities have different invalidation surfaces or useful feedback boundaries, assign them to the owning Outcomes/Checks rather than making every early Stage gate stale.
-
-Every Counterfactual mutation path must be a current production carrier with a defensible route from the declared target root to the asserted behavior. A Binding or `input_paths` declaration is not reachability proof. A static-structure proof mutates and observes the frozen structure object itself and cannot be promoted to runtime behavior; a runtime proof requires Harness mutation of the declared carrier, direct execution of the same process product root and package-observed actual change. Declare the expected affected Facts, preserved Facts and allowed fan-out Facts; baseline and mutation must retain the same obligation universe, all expected Facts must change, preserved/liveness Facts must not change and every other change must be listed fan-out. A machine-closing Check with no admitted baseline or mutated observation fails rather than skipping. Review `verify --explain` before an expensive first execution and repair obsolete routes, barrels, fixtures or duplicate Main/Counterfactual invocations.
-
-Declare cheap machine-checkable prerequisites through existing environment requirements and verification inputs. Product/API readiness probes, incremental build caches, streaming phase output and timeout heartbeats belong to the project-owned runner when they depend on its runtime. The admitted direct-process observer is the narrow exception: Harness owns bounded stdout capture plus process-tree inspection and cleanup because those are part of its host execution TCB; this remains containment rather than an absolute hostile-code sandbox.
-
-## Stage And Target Profile
-
-- Declare one ordered `stages` DAG in the same Contract. Every Outcome belongs to exactly one Stage; every Stage names one gate Outcome; the gate transitively depends on every other Outcome in that Stage; and every later Stage Outcome transitively depends on every prerequisite gate.
-- A Stage Gate is not a second Final Gate or Receipt. It is one or more `stage_gate` Checks owned by the gate Outcome, and its status/frontier is derived from ordinary Outcome Progress.
-- A multi-Outcome Stage Gate declares `cross_surface_consistency`. Its diagnostic runtime record names at least two distinct `surface_ref` values, may use the same runtime target for several pages and reports one matching state version. Because the current slice has no package derivation for that capability, the owning machine obligation remains a blocking External Confirmation.
-- `task.target_profile` declares `required_state` plus a non-empty, duplicate-free `required_target_refs`. Each ref resolves to a `product` execution target with one bounded runtime family, root entrypoint, complete `root_argv` and explicit capabilities. Give every required target one Source technical obligation whose canonical target is `execution_target.<key>` and whose exact normalized statement preserves key, role, family, root, complete argv and capabilities; the Source Claim disposition, execution target and production Binding must agree. A required process root and every argv path admitted by the finite production-Binding match belong to the production owner and a Binding, not merely to the runner, a fixture, verification input or `input_paths`. The match examines a standalone argument or explicit `--key=value`, resolves a safe repository-relative value from declared `cwd`, and accepts exact or pattern Binding coverage, including glob-owned and extensionless files. Unmatched safe relative values are labels/outputs rather than inferred dependencies and are not copied. Absolute paths, repository escapes, `file:` URLs and network URLs fail closed unless explicitly routed to the external TCB/External Confirmation boundary. An exact planned root, matched argv file or process carrier may be absent through Preflight/Compile, but Final Gate requires it to exist; materializing the already-declared path does not revise Authority. Do not guess from file extensions, substrings, output flags or a language dependency graph. Root/family/role/argv/capability declaration change is a protected Source/Contract and Authority Revision. Current machine `target_runtime` proof exists only for a Harness-direct Source-backed `process` product root; required browser/native/desktop/device targets and other unsupported families retain target-blocking External Confirmation. Every Stage Gate and every `critical_user_path` Outcome accounts for every required ref through admitted root proof or that External Confirmation. Optional support/observer targets never substitute.
-- Use `implementation_complete` only when code-level implementation is the selected target, `target_profile_usable` when the declared required targets must be usable, and `production_release_ready` only when release gates are part of the selected target. These are terminal target qualifications, not Outcome progress states.
-
-## Engineering Quality Deliberation And Closure
-
-Architecture Deliberation occurs once for every implementation delivery before formal Compile and the first implementation edit; risk changes depth, not occurrence. Surface concise conclusions and repository evidence rather than private chain-of-thought. A preservation result still names the concrete owner/extension point, applicable engineering-quality attributes or their concrete preservation basis, and why durable boundaries and debt do not worsen. Material work covers module ownership, unique source of truth, dependency direction, API/schema/data boundary, state/resource lifecycle, persistence/recovery, security boundary, compatibility/migration, selected and rejected alternatives, one plausible future-change challenge, touched technical debt, forbidden bypasses and triggered failure/load/threat scenarios.
-
-Correctness/invariants and maintainability/changeability always receive at least preservation. Reliability/resource lifecycle, concurrency/consistency, performance/capacity/cost, security/privacy/safety, compatibility/migration/rollout and operability/observability/testability activate only when the Source or implementation risk makes them material. Exact expected predicates remain in Semantic Facts or selected-design authority. A performance claim additionally binds workload, metric, baseline or budget, environment, comparator/tolerance and a project-owned benchmark/probe; static shape cannot prove runtime performance.
-
-Represent every material independently falsifiable architecture or engineering-quality invariant with existing Contract fields:
-
-1. a Source-backed technical obligation, global constraint or forbidden shortcut;
-2. owner Context and expected/support/forbidden paths;
-3. a Binding to the implementation carrier when Counterfactual sensitivity is required;
-4. a project-owned executable type, compiler, lint, AST, dependency, contract, behavior, benchmark or probe Check; and
-5. a separate Assertion when functional behavior could pass while the quality invariant fails.
-
-New or worsened debt is unacceptable unless a project-owned bounded exception identifies owner, rationale, tracking and removal/expiry condition. Unrelated legacy debt does not automatically expand delivery scope, but debt touched, relied on or worsened by the implementation cannot remain hidden. Material changes to scope, owner, Context, dependency direction, selected design or debt disposition refresh the deliberation and, after Authority Lock, use protected revision.
-
-Do not encode subjective “clean architecture”, `quality == true`, a functional pass or generic quality prose as machine authority. If no reliable observation can falsify it, keep it as durable Context/review judgment or return `decision_required`. Harness routes repository-native checks; it does not become a language-generic dependency, quality or performance analyzer. Final Gate is the only Long-Task Engineering Quality/Architecture Conformance carrier and reruns these declared Checks on its current snapshot. It proves only the declared project-check-bound invariant set, not overall code quality. Do not add a default-workflow closure, quality matrix, Source aspect, Claim/risk kind, Contract field, second Gate, state or Receipt.
-
-## Proxy And Target Runtime Independence
-
-When a declared result can pass on a proxy surface while failing in its target runtime, author independent target-runtime proof for the exact required target ref. Put it in the earliest Outcome that owns the first runnable target boundary rather than postponing it to a terminal release/quality Outcome; this assigns proof ownership and does not dictate implementation order. Under the current admitted slice, machine runtime proof is available only through Harness direct-process observation; all other runtime families remain target-blocking External Confirmation.
-
-Use existing Contract semantics:
-
-1. require `runtime_behavior` or the other proof surface that matches the actual Claim;
-2. for machine proof, use a `project_binary` runner whose target exactly equals the declared `runtime_family: process`, `role: product` root entrypoint, has no wrapper and permits read-only or test-sandbox execution;
-3. let Harness own the process handle and capture exactly one bounded `ty-context-product-observation-v1` envelope from product stdout. It proves only exact values that the root itself emits on that declared JSON output surface; project-authored instrumentation/mapping cannot reclassify arbitrary internal/UI facts as package-observed, and any Claim that cannot bind directly to the surface requires External Confirmation. Do not declare or consume an observation-path, challenge or protocol environment variable; the execution nonce is internal host-attestation data. Project-submitted v3 actual/comparison/verdict and capability records remain diagnostic only;
-4. declare runtime-affecting entrypoints, modules/configuration and Claim/Counterfactual carriers through the production owner and Binding. For argv, use a standalone argument or explicit `--key=value`; Harness resolves a safe repository-relative value from declared `cwd` and includes it only when an exact or pattern production Binding covers the result. Glob-owned and extensionless files are valid, an unmatched safe relative value is not copied, and absolute/escaping/file-URL/network values fail closed unless explicitly external. `input_paths` still describes Check scope/freshness but is neither broadly role-scanned nor promoted into the process snapshot. Compile rejects any actual closure member that overlaps Source/Context/Contract/canonical expected, verification, expected-output/artifact, evidence/status/report/comparison/Receipt/Long-Task or historical-session roles. Global closure records keep `<outcome>.<binding>` logical identity while physical files deduplicate by path; authored Contract Bindings remain local and unchanged. Harness copies only this compiled closure, and a dependency that cannot be explicitly production-bound remains External Confirmation rather than triggering extension, substring, output-flag or language dependency guessing; and
-5. otherwise bind the Claim to a blocking External Confirmation instead of inventing a project-verifier proof.
-
-This process path relies on the host OS/filesystem/process APIs, Node runtime, snapshot copy/digest checks, stdout decoder and process-tree inspection/cleanup. It is not a security sandbox and does not claim containment against a malicious executable using ambient filesystem/network resources or evading every process-tree mechanism. If the Contract requires that threat boundary, use an independently controlled sandbox and keep its acceptance external until a package adapter is separately admitted.
-
-A proxy check, project-verifier payload, static repository shape, tracked status report, prior screenshot, binary, historical run or new `session_id` cannot be the sole proof of a Claim that can fail independently in the target. The required target family must equal the admitted observer family. Use only the bounded execution-target runtime families and required refs in the Contract; do not add open-ended `platform_impact` flags or per-platform Progress state.
-
-## Success, Degradation And External Boundaries
-
-- Set `success_path_required` and `degradation_path_required` explicitly. A Result Claim is proved only by a `success` Check; the same Check cannot be both success and degradation, and an honest unavailable/pending/recovery state cannot replace required success.
-- External confirmations declare `kind`, exact `impact_claims` and `blocks_target`. A `functional_prerequisite` blocks the selected target; a `production_release_gate` blocks a production-release target but may remain non-blocking for a lower target. Reclassification or impact changes are protected authority.
-- External Confirmation coverage is exact for ordinary/global Claims and Semantic Fact Claims; it creates no machine Assertion or result. For a fully unsupported Outcome, set `success_path_required: false`, omit machine Checks, include every affected Claim in `impact_claims` and keep each Semantic Fact proof explicitly bound to that confirmation. A Stage Gate may omit its machine Check only when a `blocks_target: true` confirmation impacts that gate's `result` Claim. A non-blocking confirmation or one missing the result impact cannot substitute, and `success_path_required: true` still requires a real success Check. The final status is `blocked_external`, never machine accepted.
-- `boundary_invocation` and `external_side_effect` still require a declared independent `observer` target, but the current slice has no package derivation for either capability. Their project records are diagnostic and their obligations remain External Confirmation; product self-report never proves the downstream effect.
-
-## Visual Delivery Authoring
-
-When the selected delivery includes a new/redesigned screen, primary layout/navigation/theme/component system, high-fidelity implementation or other material production UI, resolve Design Authority before Compile and author the result through existing Contract semantics. The complete design Fact universe remains mandatory Source authority, but the current machine observer does not admit browser/native/device/layout/pixel/accessibility/motion or protected/tolerance/mask observations; those Fact × method obligations must be blocking External Confirmations rather than project-verifier machine rows:
-
-- when selected external resources are an implementation handoff, place one strict marked `design-resource-handoff-v1` Markdown file in `task.source_paths` and run `ty-context design-resource preflight <handoff.md>` before Contract Preflight. A formal Web/App profile requires a canonical entry, exact dependency closure, complete acquisition and one frozen-Inspector Fact manifest proving `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts`. The atomic unit is an explicit `subject × target × condition × variation × property` Fact Cell: stable component instances/Anatomy Parts/relations and dynamic populations; all standard/custom target-condition and subject-variation axes/combinations; the complete standard/custom atomic property catalog; explicit N/A/exclusion basis; one Fact per covered cell; and every property-required Fact × method proof. Product Controls and eight UI/UX dimensions are semantic/roll-up owners, not the Fact ceiling. Incomplete acquisition/Census, aggregate labels, initial default-page inference, sampling/truncation, unresolved locators/lineage/conflicts/blockers, unsupported evidence and stale identities block. Canonical resources own exact values; the residual handoff projects located digests, value/design-system lineage, sensitivity, evidence, comparator/tolerance/mask, Oracle/environment and asset bindings without becoming a CSS copy. Every exact target additionally requires full-target layout and pixel Facts per condition. Deliberately partial input remains an explicitly scoped constraint or blocking unresolved and never an exact target. Treat candidates and unresolved decisions honestly; only a selected exact target with a valid selection basis, complete declared Fact universe and immutable identity can be proposed for fidelity authority, and downstream UI Authority Closure still owns adoption;
-- perform UI Authority Closure over stable surface/control/target keys: classify each material item as covered by owning Context/`DESIGN.md`, requiring an owner update, task-local Source, explicitly out of scope or genuinely `decision_required`. Product Surface Context owns cross-surface responsibility, Screen/interaction Context owns durable hierarchy/behavior, `DESIGN.md` owns visual-system/reference semantics and selected targets own concrete composition; Contract YAML must not duplicate or invent those owners;
-- inspect owning surface/interaction Context, `DESIGN.md`, its authored token source/generation direction and material design references. Classify every reference as `exact-target`, `constraint` or `inspiration`, with its surface/route/component, path/URI and covered viewport/theme/mode/state;
-- an unconfigured starter, style-only prose, inspiration-only set or conflicting target is not sufficient production authority. Resolve it by explicitly scoping Source to a prototype/non-fidelity result, recording an explicitly delegated and selected design target in real Source after material preferences are known, or keeping the unresolved/user-reserved direction `decision_required`;
-- never let implementation output authorize itself: a generated implementation screenshot/diff is an Artifact, not the target. An acceptance-affecting target or baseline must be selected Source/verifier input before fidelity implementation can be accepted;
-- derive the exact task-local Visual Coverage Set from declared Source, `project_context/**` and `DESIGN.md`: production surface/route/component, viewport, theme or product mode, interaction/state, content stress and accessibility/motion conditions. Do not invent an irrelevant Cartesian product, but cover every combination that is actually applicable;
-- never use risk-based, pairwise, representative or sampled combinations to waive an applicable cell. Equivalent execution may be shared only when each fact/method retains an independently attributable Assertion and any omitted applicable combination remains blocking;
-- encode each independently falsifiable visual expectation as an atomic Requirement, applicable Control field or named AC Assertion. Name the surface, viewport, theme/state/content condition and observable result when they matter to the claim;
-- close every real Control's canonical fields independently through `field_coverage`: `surface`, `region`, `location`, `control_type`, `label_content`, `user_task`, `visibility`, `availability`, `trigger`, `input`, `validation`, `default_value`, `interaction`, `navigation_result`, `loading_state`, `empty_state`, `success_state`, `failure_state`, `recovery`, `permission`, `feedback` and `accessibility`. `specified` names concrete meaning, `not_applicable` carries a falsifiable reason, and `unresolved` blocks Compile; specified and not-applicable entries create Claims for every declared applicability profile, so omission can never silently mean non-applicable;
-- close each Outcome's cross-Control/system meaning through `control_relation_closure` plus `control_relations`: shared state, dependency/order, mutual exclusion, navigation, permission, recovery, validation and feedback chains are explicit relations with Control refs, proof surfaces and applicability, while `state: not_applicable` is a negative Claim with exact applicability and an explicit assertion that no such relation applies; `unresolved` blocks;
-- when an Outcome declares Controls, add the minimum aggregated Product `surface_bindings`: one stable binding per owner surface and required product target, its Control refs, existing Technical route/component Binding refs, one root-entry success Check and its real entry action. Every Control must be bound and every Control Claim must have target-local disposition. The admitted direct-process observer can derive host `target_runtime` for the real process root, but it does not currently derive `interaction_trace`; interaction plus browser/native/device journeys remain blocking External Confirmations;
-- bind the declared result to the owning Context/`DESIGN.md`, one authored token source and generation direction, selected target/constraint inputs, production component/route carriers, path envelopes and project-owned target checks. Freeze acceptance-affecting selected target files, token sources and fixed prototype fixtures in `verification_inputs`; bind production carriers through `input_paths`/Bindings and reserve `artifact_globs` for generated implementation renders, diffs and reports. Detached kits, deep links, mocks or marketing specimens may be references or supplemental checks but not substitute implementation carriers or the production root journey;
-- for each selected exact/constraint target inside a surface binding, use the exact handoff target key and interpretation; declare `source_paths` as exactly the handoff plus that target's immutable resource paths and `condition_keys` as exactly its handoff condition refs. Put the same files in Check `verification_inputs`; map every covered handoff Source Item through `source_claims` to method-specific Source Claims and separate single-Claim Assertions at the target's exact applicability; and bind every handoff acceptance blocker in the surface binding. Every handoff verification method binds its own Assertion and exact per-condition `evidence_artifacts`. Each cell declares the exact proof-owned `fact_refs`, `path` for its method record, `observation_path` for its primary method-native observation and a canonical `fact_expectations` row for every Fact. That row freezes subject, variation, property, `plain|protected` sensitivity, expected canonical located digest, comparator, exact/tolerance mode, parameter/tolerance/narrow-mask located digests, Oracle key/trust/identity/version/digest and environment key/identity/definition located digest. Contract stores these references and digests, never a duplicate CSS value source. Cell Fact sets close every property-required Fact × method obligation; their exact union equals the target Fact set. Current package derivation supplies only admitted plain exact/presence results and host `target_runtime`; project or Playwright `design_method`, `fact_results`, `design_conformance` and `interaction_trace` rows remain diagnostic and cannot provide authority. Because the current slice does not admit design conformance, interaction, layout, pixel, accessibility, motion, browser/native/device, protected or tolerance/mask observation, those obligations retain their exact expectations but bind blocking External Confirmations instead of fabricated machine results. Missing/extra/duplicate/stale/failed rows, authority drift, mismatched environment, widened mask/tolerance, result reuse or indistinguishable observation still fail every admitted exact Assertion. `visual_render`, handoff preflight, Inspector counts, file hashes or registry presence remain input/resource integrity and cannot substitute for implementation conformance or omitted Fact proof;
-- explicitly inventory every declared design-acceptance blocker inside its surface binding. An empty array states that no blocker is declared; each declared entry preserves exactly the handoff's `source_item_refs`, `verification_methods` and non-empty `required_capabilities`. A `machine_claim` is valid only when the exact obligation compiles to a package-admitted static or direct-process exact observation and the referenced Claims have matching target-local proof; otherwise use a target-blocking External Confirmation whose impact includes the Outcome. There is no in-band not-applicable waiver: removing a blocker from scope first requires explicit revised Source and, after Authority Lock, protected Contract revision. Empty refs block Compile/Final Gate;
-- retain `ui_browser` assertions only as project diagnostics during this first observer slice. Browser, Expo-Web, native, mobile and desktop UI conformance cannot machine-close a Claim; bind the affected Claim or blocker to target-blocking External Confirmation rather than treating Playwright, a project binary, screenshot or device/session payload as observer authority;
-- keep subjective visual direction, taste or approval outside false machine proof. Resolve an undecided direction as `decision_required`; represent required human design or new-baseline approval as an explicit external confirmation.
-- for combined design-and-implementation delivery, ordinary design Outcomes/Stages may author candidates before selection, but candidate/planned artifacts cannot authorize fidelity Claims. Append the selected result to real marked Context-reachable Source and its owning Context/`DESIGN.md` reference; after Authority Lock adopt it through Authority Revision before downstream fidelity implementation. This creates no target-selection state, second Contract or second Gate.
-
-External design resources authorize fidelity only when they become a selected exact target with a validated handoff; they remain ordinary upstream Source rather than a Contract Draft, verification result or alternate authority. The revised initial proposal plus selected immutable canonical resources and the residual `design-resource-handoff-v1` is the recommended implementation input; no standalone intermediary authoring handoff is required. Map each exact fact set into method/condition evidence, each covered Source Item into the root conformance Assertion and each declared verification method to its own independently failing Assertion; carry blocker Source Items and methods unchanged into a target-local machine Claim or target-blocking External Confirmation. Any pre-existing planning document remains valid ordinary Source if supplied. The single Product `surface_bindings` projection is an aggregated cross-reference over existing Source, Controls, Technical Bindings, targets, Checks, Assertions, verification inputs and External Confirmations; it creates no `uiux_delivery` authority block, Claim kind, risk level, lifecycle state, required design directory, per-Control screenshot matrix or Gate, and it creates no copied style/value source.
-
-## Symbolic Selected-Design Authoring
-
-UI symbolic V2 is explicit opt-in; V1 remains the default. Accept `design-resource-handoff-v2` only when the target explicitly declares `representation: symbolic_rules_v2`. Require equal extensional disposition, located expected semantics and complete proof-obligation denotation across every subject/relation, target, reachable condition/variation, applicable atomic property and population/quantifier point; physical V1 ground-row identity is irrelevant. V2 Rules use constant located expected values and mutually exclusive exhaustive canonical regions. Applicability may retain legacy exact remainder partitions or use package-owned subject property profiles plus frozen Inspector custom-property closure and explicit unique instance exceptions; every logical subject-property point still needs exactly one disposition. Project every required method to typed current Rule-region evidence only when its Actual comes through the admitted package observer; otherwise bind the obligation to External Confirmation. Each set-valued Rule/omitted-axis certificate remains a separate fresh package-recomputed result without materializing Rule × axis edges. An omitted axis requires both Source-side and production-side proof through frozen closed-world static dependency closure, restricted-IR exact equivalence or finite complete-domain exhaustive equivalence; dynamic/reflected/unfrozen/external or sampled dependencies block. A Contract may mix V1 and V2 targets, but records cannot cross-substitute and all converge only in the existing Final Gate. V1 over-capacity diagnostics may guide an explicit V2 decision but never switch automatically. Purpose-efficiency is package admission, not terminal safety or a new Gate. Non-UI symbolic admission remains out of scope; verifier/runner observation authority is covered by the mandatory admitted-observer boundary above.
-
-## Compact Authoring
-
-Compact V2 may omit only deterministic defaults: empty optional arrays/nulls, `requested_level: auto`, runner `argv: []`, `cwd: .`, `timeout_ms: 30000`, `retry_policy: none`, `idempotent: false`, and empty output/artifact/assertion/environment lists. `context_snapshot_mode: full` remains explicit and is the only accepted authority mode.
-
-Goal, target profile/required targets, ordered Stages, Source/Source Claims and non-authoritative background ownership, Context, observable results, exact applicability profiles, success/degradation requirements, owners/paths, REQ, all-field CTRL closure, Control relations and production `surface_bindings`, selected target conditions/conformance artifacts, design-blocker dispositions, OBL, proof surfaces, Given/When scenarios, journey roles, Evidence Capabilities, runner targets/effects, verification inputs, single-Claim Assertions, behavioral semantic witnesses and liveness Assertions, risk, forbidden shortcuts and typed external confirmations remain explicit.
-
-Compiler-generated Outcome/Check/Claim identities replace handwritten mechanical cross-entity references. This does not authorize compiler inference of product meaning, owners, architecture, proof or risk.

package/assets/skills/long-task-workflow/references/evidence-design.md

@@ -1,121 +0,0 @@
-# Evidence Design Reference
-
-Read this only while designing or repairing Contract Checks and proof.
-
-## General Proof Rules
-
-- Every Outcome has at least one executable Check and one non-Result atomic Claim.
-- Keep four authorities separate: Source/Context/canonical resources/Contract own Expected; a package-admitted adapter owns current Actual; Harness owns comparison/result identity and verdict; the sole current-snapshot Final Gate owns terminal status. No project runner or Oracle may own two of these layers for a machine-closing obligation.
-- Required proof surfaces are non-empty, unique and all-of. Every Claim-bearing Assertion proves exactly one Claim at one exact applicability profile and uses explicit comparable Observations and expected values; every Claim/applicability/proof-surface cell must be covered.
-- `truthy`/`falsy` are diagnostic-only. `exists` proves only implementation-structure obligations. Missing or type-incomparable Observation never proves a Claim; negative proof uses an explicit value such as `equals: false`.
-- Claim and Population proof is emitted only after the entire Check passes. Exit failure, missing artifact, failed population, failed Assertion or invalid Counterfactual yields no Claim proof.
-- Verification inputs include entrypoints, helpers, fixtures/config, package scripts and lockfiles and cannot overlap implementation carriers. The frozen runner identity recursively includes the supported direct-literal local verifier module/config/data graph; runtime-owned Check inputs/outputs/artifacts are explicitly excluded from Oracle identity, while non-literal loaders, `createRequire` and package scripts without a recoverable static Node entry fail closed. Declaring other indirect/custom Oracle access as a named TCB does not admit it for machine completion; use a package-admitted adapter or blocking External Confirmation.
-- Runners receive the minimum environment whitelist plus only declared environment requirements. Never expose actual secret values in findings.
-
-## Runner And Observation Identity
-
-Runner kind still selects payload decoding, but payload decoding is not observation authority. Raw Execution identity binds the runner, its recursively frozen local dependency closure and canonical declared Environment Requirements, not actual values. Bare installed packages and the Harness/runtime remain named trusted-computing-boundary components rather than silently mutable project helpers. A project-authored verifier, `node_oracle`, wrapper or Playwright payload can provide diagnostics only unless a separate admitted package observer independently extracts the current Actual.
-
-Across all Checks sharing a Raw Execution, one Claim-bearing Observation belongs to one Assertion. Shared setup may execute once only when independent per-Check observations and artifacts remain unambiguous.
-
-## Observation Authority Admission
-
-Compile derives one immutable internal observation-authority plan for every machine Claim or Fact × required-method obligation. It binds the obligation/Fact/Assertion/target/proof-surface/method, expected identity/value, locator policy, carriers and runtime requirements. This is a rebuildable projection, never a new Contract Authority, state or Observer registry. A machine-closing row has exactly one of these first-slice authorities:
-
-- `package_static_json_exact`: plain `exact_value + exact` content for a static implementation/configuration structure. The UTF-8 JSON carrier must already exist in the pre-run workspace manifest; its no-follow path/type/size/digest/file identity remains unchanged after the runner; it matches the declared production Binding; and it is not Source, Context, Contract, expected authority, verifier output, evidence, report, status or Receipt. Harness, not the project, selects the fixed RFC 6901 `/observations/<stable Fact-or-obligation identity>` locator and applies the package duplicate-key, UTF-8, size, depth and pointer limits. A generated bundle/configuration is eligible only when it was already in the candidate snapshot. This proves only current static content, never runtime consumption, interaction or liveness.
-- `package_process_json_exact`: plain exact output from a declared `runtime_family: process`, `role: product` root. The Check uses `project_binary`, its target and complete argv equal the Source-backed root invocation exactly, no project wrapper intervenes and its effect is read-only or test-sandbox. The target's canonical Source obligation, Source Claim disposition and execution target agree on key, role, family, root, complete argv and capabilities. Compile creates one internal process-runtime closure containing that invocation, the Claim/Counterfactual production carriers and only finite argv values that resolve to production Binding members. It examines a standalone argument or explicit `--key=value`, resolves safe repository-relative values from declared `cwd`, and admits a path only when an exact or pattern Binding covers it; glob-owned and extensionless files are supported. An unmatched safe relative value is ignored and not copied. Absolute paths, repository escapes, `file:` URLs and network URLs fail closed unless explicitly routed to the existing external TCB/External Confirmation boundary. It neither broadly role-scans nor copies all `input_paths`; role separation applies only to actual closure members. Global Checks use internal scoped Binding records `{ outcome_key, local_key, binding_ref, binding }` with `<outcome>.<binding>`, preserving logical refs while deduplicating identical physical paths without changing authored Contract Bindings or adding a registry. Every closure member is disjoint from Source/Context/Contract/canonical expected authority, verification inputs, verifier/evidence/status/report/comparison/Receipt/Long-Task workdir, historical session/evidence, `expected_output_paths`, `artifact_globs` and other proof-output roles. Harness copies only this compiled closure into an OS-temporary snapshot, then directly spawns/owns the root there. The child receives the minimal runner environment and no observation-path, challenge or protocol variable. It writes exactly one bounded `ty-context-product-observation-v1` envelope to stdout with exact keys `schema_version` and identity-keyed `observations`; Harness captures stdout, requires the exact compiled identity set, extracts multiple values, records host execution attestation bound to the closure identity, verifies the closure again and deletes the snapshot. The envelope proves only exact values actually emitted by that root on the declared JSON output surface. Project-authored instrumentation or mapping cannot elevate arbitrary internal/UI facts into package-observed truth; a Claim that cannot bind directly to that surface remains External Confirmation. The per-execution nonce is generated and retained only inside host attestation; it is neither a child-visible challenge nor a trust root.
-
-Everything else is unsupported and therefore a blocking External Confirmation: custom or `named_external_tcb` Oracle, indirect wrapper, browser/native/device session, layout, pixel, accessibility, motion, protected raw observation, tolerance/mask and custom locator. Target family must equal observer family. Project-submitted v3 actual/value digest, comparison result, `passed`, verdict and capability records remain optional diagnostics and never own Actual or completion. Current package derivation covers exact/presence plus host-derived `target_runtime`; `interaction_trace`, `state_delta`, `design_conformance` and every other capability without package derivation require External Confirmation even when a project record is present. A diagnostic copy that disagrees with a derived result fails closed. The public project result remains `long-task-check-result-v3`; the stdout product observation envelope is a separate v1 protocol, so no v4 is introduced.
-
-## Scenario And Evidence Capabilities
-
-- Every Check declares non-empty keyed `scenario.given` and `scenario.when` steps. One Check covers one materially coherent journey; a different success path belongs in another Check or vertical Outcome. A Claim-bearing Assertion's `applicability_ref` must match the Check target, journey role, duplicate-free atomic dimension assignments, all keyed Given refs and ordered When refs exactly.
-- Every Assertion declares a non-empty all-of `evidence_capabilities` set. `presence` proves static existence only and cannot alone prove a behavioral Claim. A project payload may contain one typed current-execution compatibility record per capability, but a machine Claim is satisfied only by a matching package-derived result. In the current slice that means exact/presence and, for a direct process root, host `target_runtime`; missing admission, duplicate/unknown/undeclared records or disagreement with a submitted copy fail closed.
-- `interaction_trace` names the exact target plus the declared Given keys and ordered action keys, but no package derivation currently owns those semantics. Project/Playwright trace rows are diagnostic and the obligation remains External Confirmation, including on a direct process root.
-- `state_delta` compatibility rows still require different before/after hashes and named changed fields, but they are not package-derived machine proof. The same external boundary applies to `durable_readback`, `cross_surface_consistency`, `boundary_invocation`, `external_side_effect`, `failure_injection`, `input_variation`, `visual_render`, `design_conformance` and `design_method` until a package adapter derives the applicable result.
-- `target_runtime` binds the exact target/root and is host-derived only for a direct process product root. Runtime Fact refs and every admitted package-derived exact/presence result remain set-equal to the compiled obligation cells; no aggregate project record fills a missing cell.
-- Structured runners emit `long-task-check-result-v3` for capability records. V2 payloads remain decodable only for presence-only compatibility; they cannot satisfy a declared non-presence capability. Evidence records contain bounded hashes/ids/refs, not unrestricted raw payloads.
-
-## Non-UI Semantic Fact Evidence
-
-Every machine `semantic_fact` proof binding compiles one immutable expectation row identified by manifest/digest, Outcome, Fact, proof method, Claim, applicability, subject/relation/population, exact condition and property. It freezes the Source-located expected value digest, sensitivity, comparator/mode/parameters/tolerance/mask, admitted observer identity and environment definition. Runtime evidence cannot rewrite any field, and Compile rejects a machine row whose method/surface/target/sensitivity/comparison mode has no admitted observer.
-
-The owning Check may submit compatibility data, but the package observer derives exactly one authoritative current `semantic_fact` result for every and only every admitted expectation assigned to it. Each result records:
-
-- exact assertion/manifest/Outcome/target/Fact/proof/method/subject/condition/property identity;
-- an attributable actual-observation artifact, current digest, typed locator and value digest;
-- an attributable actual-environment artifact, current digest, typed locator and value digest;
-- the frozen expected located authority and comparison tuple, plus a current comparison artifact/locator/result digest;
-- explicit `passed|failed` comparison and verdict;
-- the exact Oracle/environment identity; and
-- one result for every declared independent observer where applicable.
-
-V1 ground, V2 symbolic, non-UI semantic Fact, static observer and process observer all call the same Harness-owned `evaluateExactDigestComparison` with identity, actual/expected value digests, comparator/mode and parameter/tolerance/mask digests. The admitted exact slice permits only `exact_value + exact`, requires empty tolerance/mask and fails whenever actual differs from expected. Harness recomputes result identity; submitted `passed`/verdict never participates and any submitted comparison field that disagrees fails closed. Protected and tolerance/mask observations are not admitted in this slice and remain External Confirmation; secrets, tokens, personal or regulated values never enter Contract, logs, findings, Context or artifacts in raw form.
-
-Result identities and primary observations are duplicate-free. One aggregate Boolean/report/log/screenshot, one reused artifact+locator+value tuple, one all-states row or one Check exit code cannot satisfy several Facts or methods. A Fact may legitimately require several independently admitted methods/observers, and all must pass. Population/quantified Facts additionally prove exact expected universe = eligible = observed plus valid exclusions. Evidence must reach the furthest independently failing admitted boundary; parser/request/queue acceptance or implementation self-report does not prove storage, downstream delivery, recovery, security or external effect.
-
-Final Gate requires exact expectation/result set equality on its one current snapshot and rejects missing, extra, duplicate, stale, failed, authority-drifted, environment-mismatched, proxy-only, reused or indistinguishable results. External-confirmation obligations emit no fabricated machine row and remain pending through terminal reporting. Manifest/preflight success, hashes, Census, schema validation, focused tests and Progress prove only their own input/integrity/intermediate claims.
-
-## Live Target Runtime Evidence
-
-- Machine target-runtime authority exists only for `package_process_json_exact`: Harness directly spawns the exact declared `runtime_family: process`, `role: product` root entrypoint and derives host execution attestation, target liveness, current exact/presence Actuals and exit result. This does not derive the semantic Given/action sequence required by `interaction_trace`. A project `target_runtime`, new `session_id`, `cold_start: true`, historical session, wrapper or child self-report is diagnostic only.
-- Static package observation proves structure/configuration content only. It cannot prove runtime consumption, interaction, liveness or production reachability merely because its path appears in a Binding or `input_paths`.
-- Browser/native/desktop/device runtime and layout/pixel/accessibility/motion observations have no admitted adapter in this slice. Playwright, H5/browser proxies, project binaries, screenshots and session payloads cannot close those machine Claims; retain a blocking External Confirmation.
-- Target family must equal admitted observer family. A proxy may prove only its own separately admitted Fact; it cannot substitute when proxy and required target can fail independently.
-- Historical reports, screenshots, binaries and logs are review material. Current-run diagnostics may accompany a Check as Artifacts, but only package extraction from the current frozen static carrier or Harness-owned direct process creates accepting Actual.
-- Bind every process runtime dependency through the Source-backed root plus its production owner/Binding. For argv, use only a standalone argument or explicit `--key=value`; Harness resolves a safe repository-relative value from declared `cwd` and includes it only when a production Binding exact path or pattern covers the result. Glob-owned and extensionless files are valid. An unmatched safe relative value is not copied; absolute, escaping, `file:` and network values fail closed unless explicitly external. Bind modules/configuration and Claim/Counterfactual carriers directly. Keep `input_paths` as ordinary Check scope/freshness and project verifier/helper material in `verification_inputs`: it is neither broadly role-scanned nor promoted into the snapshot. The declaration-stable compiled process closure is the only snapshot-copy input, and role separation checks only its actual members. Exact planned members may be absent through Preflight/Compile but must materialize at Final Gate. Compatible Cross-Check and implicit-preserved Facts may share one Raw Execution/envelope, but every Fact keeps its own obligation/comparison identity. A missing production binding for an actual dependency, forbidden closure-role overlap or absent Final member fails closed. This lets existing Progress freshness identify when rolling feedback is stale without a new trigger registry or dependency parser.
-
-### Process Containment TCB
-
-The isolated runtime-closure snapshot, minimal environment, bounded stdout capture, no-follow/digest checks, direct process handle, timeout, process-tree monitoring and cleanup reduce self-attestation and cross-execution priming. Static observation likewise retains prepare-all mutation watching plus per-file pre/post identity/hash. Subtraction controls reopen transient/persistent carrier swaps or descendant/timeout leaks when those owner responsibilities are removed, so do not replace either pair with prose or a new edge mechanism. They are not an absolute security sandbox. The TCB includes the host OS/filesystem/process APIs, Node runtime and process-enumeration/termination behavior. Harness does not claim to contain a deliberately malicious executable that escapes the copied closure, accesses ambient filesystem/network resources or evades every OS process-tree mechanism. If a Claim needs that adversary boundary, run the target inside an independently controlled sandbox and retain External Confirmation until that observer is separately admitted.
-
-## Causal Boundary Review After Revision
-
-- When a rolling blocker causes a semantic or proof revision, review only the affected weak-observability or high-risk Outcomes before adoption. Ask whether a cheaper proxy, fixed response or self-reported success could pass while the declared result still fails at a farther independent boundary.
-- Evidence must reach the furthest independently failing boundary named by the Claim. A proxy may prove its own result, but it cannot prove a downstream state or effect merely by reporting success.
-- Every behavioral Claim-bearing Assertion requires a same-Check claim-local semantic Counterfactual with admitted baseline and mutated observations. Use `replace_json_value` or `replace_text` to alter only the asserted semantic field/fragment while preserving the production carrier; the designated affected Fact set must change, `preserved_assertions` and preserved Facts/liveness must remain unchanged, other changes must belong to the explicit allowed fan-out set and the obligation universe must remain identical. `replace_file` remains compatibility-only and cannot establish semantic binding; `remove_paths` remains for non-behavioral existence/structure claims. A machine-closing Check with no admitted entries fails with `counterfactual_admitted_observation_required`; it never skips impact validation.
-- Static Counterfactuals prove only the mutated structure object itself. Runtime production reachability requires `Harness mutation of a compiled production carrier → direct execution of the same Source-backed process product root → package-observed actual change`; baseline and mutated execution bind the same process-closure identity and neither closure contains Authority, verification or evidence input. Binding/path declarations, synthetic status, evidence output and generated verifier carrier do not establish causality.
-- Keep this risk-proportional and internal. Do not create an evidence matrix, product-effect taxonomy, universal restart/end-to-end suite or persistent review state.
-
-For semantic Product Conformance, require one separate read-only Global `conformance` Check only when `weak_observability` combines with multiple Stages or multiple required product runtime families. It starts from a required root product target, uses a Raw Execution identity independent of Outcome Checks and runs inside the existing Final Gate. It can carry machine `target_runtime` only for an admitted direct-process root; unsupported families remain blocking External Confirmation and the conformance Check cannot bypass that boundary. Single-Stage/single-family weak work keeps the existing same-Check sensitivity path and does not pay this extra runtime cost.
-
-## Playwright
-
-Playwright is a diagnostic project verifier in the current observer slice, not machine Actual authority. `[ac:<assertion-key>]` may still bind one declared AC per Test Instance for failure localization; ordinary tags are ignored and legacy `[<key>]` binds only a declared key.
-
-Missing, skipped, flaky, unexpected, timed-out, interrupted, failed, multi-AC and duplicate-within-project cases remain failed diagnostics. The same AC across distinct projects aggregates all-of for that diagnostic Check, and aggregate status/count fields remain diagnostic-only. None can close a browser/UI machine Claim.
-
-Standard frozen Playwright content remains a stable diagnostic verifier input, not an admitted Actual source. Browser/UI machine obligations are External Confirmation in the current slice. Playwright Counterfactual output can localize repairs but cannot create machine acceptance, target-runtime authority or capability proof.
-
-## Visual UI Evidence
-
-- A selected implementation handoff must already pass `ty-context design-resource preflight`, including frozen-Inspector Census, exact manifest↔handoff universe equality, complete per-resource/Fact Cell/Fact/proof closure, non-sampling/non-truncation and exact-target layout/pixel defaults. Preserve exact handoff `fact_refs`, every property-required Fact × verification-method obligation and its exact expectation. Under the current observer slice, layout, pixel, visual, interaction, motion, accessibility, browser/native/device, protected and tolerance/mask methods bind blocking External Confirmations; project `design_method`, `fact_results`, screenshots and Playwright attachments are repair diagnostics only. A future package-admitted adapter may reuse these identities, but no project verdict can pre-admit it.
-- Keep separately attributable evidence where geometry/pixel/token/content, interaction/state, motion/haptic/sound timeline, accessibility semantic/navigation/visual adaptation and asset integrity cannot falsifiably share one observation method. This preserves the complete selected-design proof universe; it does not admit those currently unsupported methods for machine completion.
-- Never accept an aggregate Boolean, screenshot pass or one `all-states` result in place of per-Fact authority. The expected target cannot be generated from the implementation under test. Plain static/process exact observations remain attributable through package extraction; protected and tolerance/mask obligations remain External Confirmation until an admitted adapter owns their Actual and comparison.
-- Keep `design_resource_integrity` and `design_implementation_conformance` distinct. Stable paths/hashes, provider/export success, manifest/registry membership and expected counts prove resource integrity; `visual_render` proves a current artifact exists. Neither proves the production implementation matches a selected target.
-- When external design resources are Source, account for every selected exact-target/constraint condition that the Contract explicitly adopts. Candidate comparison, a mutable provider link, extraction success, metadata-only output, resource digest or an isolated prototype run is authoring/integrity material and cannot become product acceptance. Resolve each acceptance-affecting fact through a typed locator plus immutable path/hash and declared target/condition applicability before Compile. Include the handoff and every source-profile entry/dependency in `verification_inputs`; unsupported method-specific design, interaction and target-runtime obligations remain separate blocking External Confirmations on the real production target.
-- The decoder may validate a project `design_conformance` record against its compiled target/Assertion/current Check target, conditions and artifacts for diagnostics, but that record is not admitted Actual or comparison authority in this slice. Missing or swapped bindings fail the diagnostic Check; a matching record still cannot machine-close visual conformance or make the implementation render its own comparison authority.
-- Playwright may exercise declared `ui_browser` visual ACs for diagnostic localization. Give each independently falsifiable AC one `[ac:<assertion-key>]` Test Instance, but Playwright is not an admitted machine observer in this slice. Bind every browser visual obligation to blocking External Confirmation; a broad screenshot or one passing page case cannot waive an applicable cell.
-- Make the test environment deterministic enough for its claim: freeze the relevant browser/project, viewport, theme/mode, locale/timezone, font loading, fixtures/data and animation/motion policy in declared verifier inputs or configuration.
-- Any reviewed screenshot baseline that affects pass/fail must exist for the accepting Compile and be included in `verification_inputs`. Generated screenshots, diffs and reports are Artifacts and review material; they are not editable acceptance authority. Creating or replacing a baseline after Authority Lock is verifier-material revision and must never be silently auto-updated to make a failure pass.
-- Confirm that each baseline is a selected `exact-target` for the named surface/viewport/theme/state or implements a named `constraint`; an inspiration reference cannot become a fidelity oracle merely because it is available. The implementation's current screenshot is never its own target.
-- Screenshot comparison is diagnostic only under the current admitted boundary. Keep DOM/layout/accessibility/motion/responsive/input obligations distinct and blocking; one generic `design_conformance` record cannot erase Source Claims, verification methods or their External Confirmations.
-- Keep evidence aligned with stable surface/control/target keys. Visual similarity, interaction/navigation, validation/recovery, permission behavior, accessibility and target-runtime conformance are independently failing claims and need their own Assertions/capabilities when declared; one broad screenshot or UI pass cannot prove all Control fields.
-- Run diagnostic checks against production components or real product routes. Host `target_runtime` is available only when Harness directly executes the process product root; `interaction_trace` has no package derivation in the current slice and remains External Confirmation together with browser/native/device journeys. A detached kit/mock/deep-link harness cannot substitute for the production carrier or root journey.
-- Keep subjective visual quality and approval external. A new visual direction or baseline that needs human judgment remains an explicit external confirmation even when all machine checks pass.
-- `ui_browser` does not create machine proof in the current slice. Browser output cannot close native/mobile/desktop Claims; all such runtime reviews stay external until a package-owned adapter is admitted.
-- Preserve each handoff blocker's non-empty `required_capabilities`. A machine Claim closes it only when one admitted adapter for the exact target supplies every required observation; physical device, sensor, camera, orientation, haptic, screen-reader, pixel-density, safe-area and comparable observations are currently target-blocking External Confirmations and cannot be borrowed from a proxy.
-
-## Symbolic Noninterference Evidence
-
-For every non-interference method, require a digest-identified frozen executable Oracle with the exact `symbolic_noninterference.<side>.<method>` capability. Source proof must use the canonical package-owned restricted Source IR in the complete current Inspector inputs; package preflight binds its current bytes to target/certificate/Rule scope and derives and memoizes the static dependency DAG, exact predicate/axis-erased equivalence or every finite-domain evaluation itself. Submitted graph/predicate/evaluation/pass fields and the artifact are recomputable cache only, and the artifact is excluded from semantic inputs. Executable/CSS/implicit-DOM/template/dynamic/reflected/computed/unfrozen/external Source blocks; production remains limited to package-parsed static HTML plus inert JSON. Both sides bind implementation closure/version/capability, environment, exact current inputs, side snapshot, scopes, omitted axes, derived result, artifact and witness. When proofs exist, Source and production proof digests must match the current Final-Gate certificate expectation/result. Extraction outside admitted representations remains an explicit TCB boundary.
-
-## Structured Evidence And Sensitivity
-
-Every machine claim-bearing `structured_json_v2` Check needs same-Check Claim-related Counterfactual sensitivity backed by the compiled admitted observer; the project payload alone never supplies Actual. Population declares a real `universe_binding_key`; every universe carrier is an owning-Check `input_path`, and package observation proves exact universe = eligible = observed plus valid exclusions by entity id. Population never substitutes for the claim-local narrow semantic witness and host-derived target-runtime liveness required by an admitted process behavioral Claim. Artifacts and another Check never substitute for sensitivity.
-
-Outcome Counterfactual V2 names an Outcome `binding_key`; Global Counterfactual V2 resolves an Outcome-owned `binding_ref`. A Counterfactual mutates only a package-proven subset of implementation carriers, never Source, Context, runners, verification inputs, expected authority, evidence, reports or status. Behavioral witnesses use claim-local `replace_json_value` or `replace_text`, list their designated affected Fact/Assertion set, preserved Fact/liveness set and allowed fan-out set, and require package observations to establish the exact permitted actual changes.
-
-An `existing` mutation target must exist at Preflight/Compile and the JSON pointer/text fragment must resolve uniquely. An exact `planned` target, process root or argv dependency may be absent until implementation but must exist at Final Gate; materializing the declared path preserves compiled/Authority identity, while later content changes stale targeted Progress.
-
-Artifacts remain review material. They do not prove Claim sensitivity by themselves.