project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -19,11 +19,11 @@ A Codex-root `long-task` install may expose fixed package-owned `long_task_imple
 
 ## 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.
+Prevent false completion inside declared authority. Given complete Source, a meaning-preserving Contract projection, complete applicability and admitted machine/external authority boundaries, `AcceptedDeliveryTerminal` implies every declared obligation is fulfilled. Machine proof needs package-admitted Actual and Harness-owned comparison; unsupported proof needs a complete declared external route. Every requirement, Fact, proof obligation and independently falsifiable AC stays traceable, and every unproved item blocks.
 
 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.
+Only current-final-snapshot evidence may accept. `AcceptedDeliveryTerminal` is fresh `machine_accepted` with no blocking external fulfillment or fresh `delivery_accepted` after exact current fulfillment; every other or legacy status is non-closeable. Progress is repair evidence only and never acceptance authority; external records alone never accept. Final Gate alone carries Long-Task Engineering Quality Conformance, Architecture Conformance and terminal status for the declared 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.
 
 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.
 
@@ -54,7 +54,7 @@ A Draft Outcome is an Outcome before Authority Lock, not a new schema field or r
 
 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.
+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. Preflight classifies every blocking obligation as `machine_admitted`, `external_fulfillable` or `unreachable`; any unreachable row blocks before implementation. 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.
@@ -64,12 +64,12 @@ A Draft Outcome is an Outcome before Authority Lock, not a new schema field or r
 
 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.
+Status/resume frontiers and the Finding-derived Repair Frontier are non-persisted diagnostic projections only; they never accept, schedule or authorize protected semantic changes. 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 it. Final Gate ignores Progress and reruns all required Checks. Add no 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.
+Final Gate recompiles Source authority, rechecks the complete protected current snapshot, reruns every declared Check/control, revalidates exact current external records and rejects protected-input, workspace/tree or Active Authority drift. It trusts no historical result, cache, record, delegated report or Agent judgment. Use external commands only through the lifecycle reference. Before native Goal completion, perform its veto-only user/Goal-to-Source comparison; mismatch returns to Source/Contract repair without creating 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.
+Report implementation/risk, conformance, Claim/Stage/target/Gate results, exact terminal status, acceptance scope, external evaluations, Context and blockers. Keep verifier boundaries honest: incomplete Source and unsound Oracles are not mechanically repaired; local actor checks are not authentication; the host owns Goal/model; worker reports never accept. The observer remains Level 3; `observed_lifecycle_*` cannot replace complete total-cost ROI or the independent Level 4 audit.

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

@@ -65,16 +65,22 @@ Progress freshness binds Outcome authority, applicability, runner, verification
 
 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.
+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`, Stage status, live external-record evaluations and a non-persisted diagnostic Repair Frontier from current findings/bindings/Progress; they do not persist a Stage pass, repair queue or scheduler state. `target_state` remains `not_accepted` until a fresh Final Gate accepts, becomes `blocked_external` for a pending target blocker, or names the Contract's `implementation_complete`, `target_profile_usable` or `production_release_ready` state after `machine_accepted` or `delivery_accepted`. 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`.
+Final Gate is the sole Long-Task `Engineering Quality Conformance`/`Architecture Conformance` carrier; no parallel default conformance carrier runs for an active Long-Task.
 
-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 Final Gate, complete Context/code/tests and create a clean candidate commit. Final Gate first verifies the accepted compiled authority is still fresh, recompiles Source authority and records semantic plus raw protected-input identity for the Contract/fragments, Source-embedded semantic manifest, every Source file, full Controlling Context, verifier/runner, recursively frozen local verifier dependencies, `verification_inputs`, workdir inputs and external state. It validates the common-dir record/marker, creates one Git-tree snapshot and runs every Check and sensitivity control exactly once. Non-UI semantic evidence reproduces every compiled machine Fact × method expectation; selected-design evidence reproduces its exact admitted result universe. Blocking External Record v2 validation includes schema/content hash, protected Source-bound Ed25519 identity, current challenge and signature, exact actor/target/environment/applicability/obligation/result-kind sets, whole-candidate identity, immutable artifact snapshots, objective comparator or Source-backed judgment and passed per-obligation results. Ed25519 proves possession of the bound key, not real-world identity beyond that binding.
+
+After the long execution phase, Final Gate enters one short `withActiveAuthorityLock("finalize")` phase and does not rerun machine Checks. It re-reads Active Authority and CAS identity, candidate HEAD/tree/workspace fingerprint, compiled/verifier freshness, every external record/challenge/signature/artifact/evaluation and the complete `FinalizationIdentityV1`. `finalizeDeliveryGateCas` compares that identity, binds `finalization_identity_sha256` into Receipt v3 and publishes atomically. `final-gate` uses `close_on_accept=false`; Stop/close use `true`, so an accepted Receipt and Authority cleanup commit together, while a blocked/failed result keeps Authority. Any candidate, Authority, record, challenge, signature or artifact race is non-accepted, preserves Authority and cannot leave a fresh accepted Receipt. Final Gate remains the sole Engineering Quality/Architecture Conformance, semantic, selected-design and terminal carrier; it proves only its declared project-check-bound set, not overall code quality. Receipt v3 reports `machine_accepted`, `delivery_accepted`, `blocked_external` or `needs_work`; historical v3 Receipts without the Finalization Identity are audit-readable and stale.
+
+Use exactly `ty-context long-task external prepare <workdir> [--confirmation <key>]`, `external submit <workdir> --confirmation <key> --record <path>`, `external status <workdir>`, `external rotate <workdir> --confirmation <key>` and `external revoke <workdir> --confirmation <key>`. Preparation creates or reuses the current challenge, emits the exact whole-candidate signable packet and may batch only compatible actor/target/environment/journey/evidence rows without merging logical obligation identity. Submit validates Authority/freshness, v2 schema, candidate, challenge, actor, detached Ed25519 signature, exact obligation/result-kind set, immutable artifact snapshots and comparator before atomic storage. Status re-evaluates identity/signature/challenge/artifact integrity; rotate changes the challenge; revoke removes the named record and rotates its challenge. None runs a Gate or accepts a delivery, and Harness never reads the actor's private key or signs v2 records.
+
+Authority commit/migration, external submit/rotate/revoke, finalization, clear and abandon share the applicable active-state integrity/lock boundary. Stop/close rerun the Live Final Gate and clear only the identity accepted in that same Finalization CAS as `machine_accepted` or `delivery_accepted`. `blocked_external`, `needs_work`, Record v1, declared-only identity and legacy `machine_accepted_external_pending` never clear or close. Final Gate/Stop/close identify `acceptance_scope: declared_delivery_authority` and `native_goal_effect: none`; close additionally identifies `closed_scope: complete_long_task_authority`. The Stop Hook emits the same scope as one non-blocking message for either accepted terminal. 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.
+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. A missing `completion_authority` alone deterministically defaults to `machine_only`; migration never infers `declared_authorities`. Exact unchanged Fragment projections may be preserved, but changed or missing projections receive current refs/digests plus `decision_required`, no inferred Fact/support/polarity/supersession/exclusion, and stale anchors/provenance are removed. Every blocking external route must be re-authored from Source with actor Ed25519 identity assurance/public-key authority, exact target/environment/scenario/evidence/obligations and Source-backed judgment basis where applicable; migration never generates a signature. Record v1, Receipt v2 and Receipt v3 without `finalization_identity_sha256` remain audit-readable only and cannot be upgraded into acceptance. Run `upgrade --check`, repair every `manual_required` item, recompile and rerun the current Final Gate. 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

@@ -26,7 +26,7 @@ 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;
+- `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 to the exact Claim/applicability/Fact/proof/method/proof-surface/target/obligation tuple; `impact_claims` validates the declared Claim set but never selects authority or removes machine proof;
 - 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.
 
@@ -36,9 +36,9 @@ The exact invariants are:
 
 `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.
+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. Derive every floor from the closed method and standard-property profiles plus observation-scope, quantifier, Claim-kind and Control-field requirements; prose keyword matches are advisory only. A new standard property without a profile fails closed. A `custom.*` method or custom property without a standard profile requires External Confirmation. Every non-structure broad requirement, technical obligation, forbidden shortcut, non-completing or product-result Claim binds at least one Semantic Fact and inherits the union of all same-applicability Fact floors. 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.
+Compile first derives machine and external candidate routes for each exact obligation, then one central resolver requires exactly one legal owner. One admitted machine route is machine-owned; no machine plus one valid external route is external-owned; machine plus blocking external is `machine_external_authority_conflict`; duplicate same-kind routes are `authority_route_ambiguous`; no route is `no_admitted_proof_route`. A mixed machine/external Assertion must be split rather than partially trimmed. Current machine 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
 
@@ -71,7 +71,7 @@ Declare cheap machine-checkable prerequisites through existing environment requi
 - 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.
+- `task.target_profile` declares `required_state`, a non-empty duplicate-free `required_target_refs`, and `completion_authority: machine_only | declared_authorities`. Legacy omission normalizes to `machine_only` with an actionable compatibility diagnostic; do not rely on omission for new authoring. Each target 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
@@ -112,7 +112,7 @@ A proxy check, project-verifier payload, static repository shape, tracked status
 
 - 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.
+- External Confirmation coverage is exact for ordinary/global Claims and Semantic Fact Claims; it creates no machine Assertion or result. Under `declared_authorities`, every blocking confirmation declares exact actor id/role/kind and `identity_assurance: { scheme: ed25519, key_id, public_key_ref }`, owner, target, environment identity, keyed Given/When scenario, non-empty evidence requirements and one exact obligation row per Claim/applicability/Fact/proof/method/capability/Expected-authority cell. The public key must be protected controlling Source/Context and its digest enters compiled identity; the private key never enters repository/workdir/package/verification inputs or a Harness signing command. Externalization changes only the Actual or explicitly Source-backed `subjective_preference | expert_assessment | authorization` judgment supplier; objective/recomputable or machine-admitted obligations cannot become judgment, and Expected/applicability/comparator/method/capabilities/granularity never weaken. A fully unsupported Outcome sets `success_path_required: false`, omits machine Checks, includes every affected Claim in `impact_claims` and binds each exact proof to the confirmation. A Stage Gate may omit its machine Check only when a blocking confirmation owns the exact gate-result obligation. Preflight requires exactly one legal route and blocks conflicts, ambiguities and no-route rows. A valid unfulfilled route is `blocked_external`; only an authenticated current whole-candidate Record v2 plus the complete Final Gate can yield `delivery_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

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

@@ -4,7 +4,7 @@ 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.
+- Every machine-path Outcome has at least one executable semantic Check and one non-Result atomic Claim. A fully external Outcome may omit machine Checks only under the exact blocking-confirmation rules in Contract authoring.
 - 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`.
@@ -30,12 +30,14 @@ Everything else is unsupported and therefore a blocking External Confirmation: c
 ## 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.
+- Every Assertion declares a non-empty all-of `evidence_capabilities` set. Proof adequacy follows the declared semantic boundary: existence needs `presence`; interaction needs `interaction_trace + state_delta`; product-result effect additionally needs `input_variation`; a boundary call needs `boundary_invocation + actual_provenance`; persistence needs `durable_readback`; identity/data-state semantics need `distinct_identity + data_state`; a complete population needs `population_coverage` and exact-set semantics; failure/recovery needs `failure_injection + recovery`; selected visual/design meaning needs `visual_render + design_conformance`; and runtime reachability needs `target_runtime`. `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.
+- `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`, `actual_provenance`, `external_side_effect`, `failure_injection`, `recovery`, `input_variation`, `distinct_identity`, `data_state`, `population_coverage`, `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.
 
+A Check with zero Claim-bearing Assertions is `diagnostic`; it may run and localize a repair but contributes no Claim/Fact proof, Stage acceptance or terminal status. A blocking obligation backed only by a diagnostic Check blocks Preflight/Compile. Claim-bearing Expected must resolve through `expected_ref` or `expected_authority_ref`, or equal the compiled Expected of its bound semantic Fact/proof obligation. Inline Expected is permitted only for diagnostic Assertions; implementation, test output and the Actual producer cannot become Expected authority.
+
 ## 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.
@@ -56,6 +58,15 @@ Result identities and primary observations are duplicate-free. One aggregate Boo
 
 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.
 
+## Authenticated External Evidence
+
+- Only `long-task-external-confirmation-record-v2` may fulfill a blocking external obligation. The Contract actor uses the closed `ed25519` identity-assurance scheme with a key id and protected controlling Source/Context public-key ref; its digest is part of compiled identity. Harness verifies possession of that bound key but does not independently establish real-world identity beyond the Source binding. `declared_only` actors and Record v1 are advisory/audit-only.
+- `external prepare` creates or reuses one current challenge and emits exact whole-candidate identity, actor/key binding, signable canonical payload digest, obligation Expected/method/capabilities and evidence requirements. Preparation creates no acceptance, Progress or pending completion state. Only explicit `external rotate` or revoke rotates the challenge.
+- The detached Ed25519 signature covers the canonical Record v2 payload excluding only `attestation.signature_base64`; `record_sha256` separately covers content integrity and is never called authentication. The actor-held private key must stay outside the repository, workdir, package, Agent-readable verification inputs and Harness commands. Harness provides no v2 signing helper or CLI.
+- Every result is set-equal to the exact compiled external obligation universe. `actual` is required for objective or recomputable comparison. `judgment` is legal only for a Source-backed `subjective_preference`, `expert_assessment` or `authorization` basis with matching actor, rationale and evidence; an external system, objective Fact or machine-admitted obligation cannot be relabeled judgment.
+- On submit, every declared evidence artifact passes bounded regular-file/no-link path safety, is hashed and copied into the existing content-addressed external-confirmation artifact store. Record v2 references only the immutable snapshot identity. Status and Final Gate reread those bytes and reject mutation, missing content or digest mismatch. This store is part of the existing record lifecycle, not a registry.
+- Every blocking record uses `whole_candidate`: any HEAD, tree or workspace snapshot change stales it. No bounded carry-forward is admitted. Submit, rotate, revoke and finalization share the same Active Authority lock; revoke removes the record and rotates its challenge so the old signed record cannot replay.
+
 ## 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.

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

@@ -72,13 +72,15 @@ For every non-UI delivery, the authoring default is the finest independently dec
 
 Before implementation and formal Compile:
 
-1. Inventory every material request fragment, attachment, controlling Context unit, canonical schema/specification, selected external constraint, repository-preservation source and delegated instruction with stable identity, digest, disposition and basis. Ordinary Material Source is `non_ui_material` and must contribute Fact lineage. A validated design handoff may classify its independently closed visual facts as `ui_design`; `supporting_only` and `excluded_by_scope` need exact rationale/basis and cannot hide a requirement.
-2. Explicitly disposition every standard semantic family for every Outcome and add custom families discovered from Source/repository/domain structure. The standard floor covers goal/scope/glossary; actors/roles/tenants/entitlements; business rules/calculations; data; operations/workflows/state/time; validation/output/error/API/protocol/event/job; persistence/cache/search/transactions/consistency/concurrency/idempotency; fault/retry/degradation/recovery/backup; configuration/flags/secrets; compatibility/migration/rollout; performance/capacity/cost/reliability/SLO; security/privacy/safety/compliance; observability/deployment/operations; integrations/notification/file/media/localization/commercial; hardware; AI/ML; architecture ownership/boundaries/debt.
-3. Give every applicable outcome, actor, policy, entity/field/relation, operation, state/transition, interface/message/job, store/index/transaction/cache, configuration/migration/deployment/dependency, security/privacy boundary, SLO/signal/alert/runbook, device/AI/custom unit a stable subject/relation/population identity. Preserve hierarchy, owner, cardinality, causality, ordering, producer/consumer, source-of-truth and dependency relations. Static/dynamic populations need exact universe/partition/enumeration/exclusion identity.
-4. Disposition every standard and custom condition axis. Enumerate each atomic applicable value and exact combination across actors/roles/tenants/jurisdictions/environments/regions/platforms/versions/features/configuration/entitlements/permissions/consent/sessions/states/input/boundary/data volume/locale/time/concurrency/repetition/dependency health/connectivity/failure/retry/consistency/freshness/migration/rollout/topology/threat/mode. Continuous domains use explicit ranges/boundaries; invariance/equivalence may share execution only while retaining distinct Fact identity and verdict. No aggregate, representative, pairwise or default-path substitute.
-5. Disposition every standard and custom atomic property per unit and condition. One specified cell creates one Fact with typed value semantics, exact Source locator/digest, owner, quantifier, observation boundary, sensitivity and provenance. Every N/A/exclusion names exact affected identities, basis and rationale; `decision_required`, `unavailable`, unreadable or conflicting meaning remains blocking.
-6. Expand every Fact into all required proof methods—exact/schema/decision-table/formula/invariant/transition/sequence/durable roundtrip/boundary/external effect/population/concurrency/idempotency/fault/recovery/migration/compatibility/performance/capacity/security/privacy/audit/observability/deployment/structure or custom TCB method. Freeze comparator, parameters, tolerance/mask, Oracle identity/capability, environment, observer and protected-value policy. Reach the furthest independently failing boundary; request issuance, parser success, self-reported success, artifact existence or a nearer proxy does not prove downstream persistence/effect/recovery.
-7. Embed one complete `semantic-fact-manifest-v1` in declared Source. Its Inspector Census and collection counts/identity digests prove deterministic complete generation with no truncation or sampling. Require `Expected Semantic Facts = Source Indexed Facts`; later Contract authoring requires exact Fact and Fact×method projection. Values remain in Source/Context; Contract receives identities, located digests and comparison authority only.
+1. Inventory every material request fragment, attachment, controlling Context unit, canonical schema/specification, selected external constraint, repository-preservation source and delegated instruction with stable identity, digest, disposition and basis. Derive one internal material-text view from the existing Semantic Fact Manifest for every Source item and every strict-UTF-8 material attachment, canonical specification, repository-preservation input, external constraint, delegated instruction and textual design resource. Do not infer text from an extension. Unreadable, invalid-UTF-8 or ambiguous content blocks; binary/design content continues only through its formal handoff route. Deterministically derive headings, paragraphs, nested list items, table rows, quotations, Given/When/Then steps, fenced code/configuration and textual HTML, then prove that every nonblank line belongs to exactly one Fragment or one allowed pure-separator line with no overlap. Each Fragment has exactly one explicit `fact_bearing`, `supporting_basis`, `superseded`, `decision_required` or `scope_excluded` disposition; missing, duplicate, conflicting and dangling dispositions block. Migration may generate current refs/digests plus `decision_required`, but never infer Fact lineage, support, polarity, supersession or exclusion.
+2. Classify every Fragment and Fact as `delivery_semantic` or `source_integrity`, and derive its `product`, `technical`, `design`, `acceptance` or `external` authority domain. A `fact_bearing` Fragment requires owning-Source and reverse Fragment provenance, exact Claim/applicability, complete anchor coverage and matching modal polarity. A `supporting_basis` produces no independent Fact and is legal only when reverse delivery-Fact provenance mechanically carries every modal and high-signal value; an empty, integrity-only or merely same-domain target cannot hide a requirement. Supersession requires an authorized new Source and successor Facts in the same semantic cell (`Outcome + unit + family + condition + property + value-kind`); Expected may change, but subject/condition/property/domain may not. Scope exclusion names the exact Fragment plus excluded Fact/Claim/obligation, same-domain owner and rationale. A design/presentation statement cannot exclude or supersede product/technical meaning without that exact same-domain authority.
+3. Derive and conserve high-signal code spans, API/route paths, versions, enum/symbol names, filenames/schema/config keys, numbers/ranges/units, exact quoted text, modal terms and frozen provider/protocol identifiers. Classify `must/shall/required/必须/应当` as positive-required and `must not/shall not/forbidden/never/不得/禁止/不可/只能/仅可` as negative-required; each maps to a Claim with matching `required_polarity`, and independent modals require split or an explicit compound cell. Every anchor maps to a delivery-semantic Fact, exact supersession, `decision_required` or exact scope exclusion; integrity-only coverage does not count. Reuse the existing Source inventory and Semantic Fact Manifest—never create a second Source ledger or generic NLP registry.
+4. Explicitly disposition every standard semantic family for every Outcome and add custom families discovered from Source/repository/domain structure. The standard floor covers goal/scope/glossary; actors/roles/tenants/entitlements; business rules/calculations; data; operations/workflows/state/time; validation/output/error/API/protocol/event/job; persistence/cache/search/transactions/consistency/concurrency/idempotency; fault/retry/degradation/recovery/backup; configuration/flags/secrets; compatibility/migration/rollout; performance/capacity/cost/reliability/SLO; security/privacy/safety/compliance; observability/deployment/operations; integrations/notification/file/media/localization/commercial; hardware; AI/ML; architecture ownership/boundaries/debt.
+5. Give every applicable outcome, actor, policy, entity/field/relation, operation, state/transition, interface/message/job, store/index/transaction/cache, configuration/migration/deployment/dependency, security/privacy boundary, SLO/signal/alert/runbook, device/AI/custom unit a stable subject/relation/population identity. Preserve hierarchy, owner, cardinality, causality, ordering, producer/consumer, source-of-truth and dependency relations. Static/dynamic populations need exact universe/partition/enumeration/exclusion identity.
+6. Disposition every standard and custom condition axis. Enumerate each atomic applicable value and exact combination across actors/roles/tenants/jurisdictions/environments/regions/platforms/versions/features/configuration/entitlements/permissions/consent/sessions/states/input/boundary/data volume/locale/time/concurrency/repetition/dependency health/connectivity/failure/retry/consistency/freshness/migration/rollout/topology/threat/mode. Continuous domains use explicit ranges/boundaries; invariance/equivalence may share execution only while retaining distinct Fact identity and verdict. No aggregate, representative, pairwise or default-path substitute.
+7. Disposition every standard and custom atomic property per unit and condition. One specified cell creates one Fact with typed value semantics, exact Source locator/digest, owner, quantifier, observation boundary, sensitivity and provenance. Every N/A/exclusion names exact affected identities, basis and rationale; `decision_required`, `unavailable`, unreadable or conflicting meaning remains blocking.
+8. Expand every Fact into all required proof methods—exact/schema/decision-table/formula/invariant/transition/sequence/durable roundtrip/boundary/external effect/population/concurrency/idempotency/fault/recovery/migration/compatibility/performance/capacity/security/privacy/audit/observability/deployment/structure or custom TCB method. Freeze comparator, parameters, tolerance/mask, Oracle identity/capability, environment, observer and protected-value policy. Reach the furthest independently failing boundary; request issuance, parser success, self-reported success, artifact existence or a nearer proxy does not prove downstream persistence/effect/recovery.
+9. Embed one complete `semantic-fact-manifest-v1` in declared Source. Its Inspector Census and collection counts/identity digests prove deterministic complete generation with no truncation or sampling. Require `Expected Semantic Facts = Source Indexed Facts`; later Contract authoring requires exact Fact and Fact×method projection. Values remain in Source/Context; Contract receives identities, located digests and comparison authority only.
 
 This expansion cannot invent a real product/legal/security/commercial/safety choice. A defensible delegated choice must first become traceable Material Source; an unsupported or user-reserved choice remains a blocker or typed External Confirmation. The named Inspector/Oracle is an explicit trusted-computing boundary, and custom extensions are mandatory when the standard catalog cannot observe the domain.
 
@@ -118,6 +120,7 @@ Before Preflight/Compile confirm:
 10. Every material UI Fact and Control can be mapped to a production target/owner, real-user entry journey and independently attributable acceptance route, while every declared design blocker has an explicit machine or target-blocking external-confirmation disposition. Removing one from scope requires an explicit Source revision; Contract prose cannot waive it.
 11. The Source is self-contained enough to own every mapped Draft semantic and names every still-required external artifact.
 12. At least one marked `technical_obligation` carries `aspect=architecture`, preserves the selected owner/dependency/debt conclusion, and maps to an independently falsifiable architecture obligation rather than only a Result Claim.
-13. The one `semantic-fact-manifest-v1` exactly inventories all material non-UI inputs and complete standard/custom family, unit/relation/population, condition, property, Fact and proof-obligation universes; every ordinary Material Source Item contributes exact Fact lineage, all generation collections have complete count/digest closure, and no aggregate/sample/ungrounded N/A/unresolved row is hidden.
+13. Every derived material fragment and high-signal anchor has exactly one allowed disposition and content-semantic coverage; cross-domain exclusion and implicit/unsupported supersession are absent.
+14. The one `semantic-fact-manifest-v1` exactly inventories all material non-UI inputs and complete standard/custom family, unit/relation/population, condition, property, Fact and proof-obligation universes; every ordinary Material Source Item contributes exact Fact lineage, all generation collections have complete count/digest closure, and no aggregate/sample/ungrounded N/A/unresolved row is hidden.
 
 Complete non-rendering `ty-source-item:start/end` markers in the real Markdown Source without rewriting direct text, wrap only recognized Markdown structure or structured provenance in uniquely keyed and reasoned `ty-source-background:start/end` blocks, retain at most one schema-valid `design-resource-handoff-v1` formal block, and finish the corresponding Contract mapping in the same loop. Unclassified text, arbitrary prose inside background, a background block used to hide material meaning, unresolved Control coverage or missing applicability blocks Preflight/Compile. Neither markers nor this audit delay opening the Draft.

package/assets/tools/context_rules.json

@@ -0,0 +1,53 @@
+{
+  "context_schema_version": 4,
+  "roles": [
+    "global",
+    "architecture",
+    "area",
+    "domain",
+    "subdomain",
+    "foundation",
+    "archive",
+    "contract",
+    "verification",
+    "deployment",
+    "implementation-index",
+    "decision-rationale"
+  ],
+  "role_aliases": {
+    "implementation_index": "implementation-index",
+    "decision_rationale": "decision-rationale"
+  },
+  "read_policies": [
+    "default",
+    "on-demand",
+    "always",
+    "optional",
+    "never-default"
+  ],
+  "legacy_read_policies": [
+    "always",
+    "optional",
+    "never-default"
+  ],
+  "top_level_fields": [
+    "areas",
+    "context"
+  ],
+  "area_fields": [
+    "id",
+    "root",
+    "context",
+    "kind",
+    "default",
+    "forbidden_runtime_dependencies"
+  ],
+  "context_fields": [
+    "path",
+    "role",
+    "read_when",
+    "read_policy",
+    "triggers",
+    "default_children"
+  ]
+}