project-tiny-context-harness 0.8.13 → 0.8.17

package/README.md

@@ -8,7 +8,7 @@
 
 Translations: [Chinese (Simplified)](https://github.com/Seven128/project-tiny-context-harness/blob/main/README.zh-CN.md)
 
-Project Tiny Context Harness is repo-native project memory for AI coding agents, plus a narrow delivery harness for trustworthy long-task completion. The product principle is: keep the memory, drop the ceremony. It adds durable project memory behind `AGENTS.md` without becoming an agent scheduler or Git orchestrator.
+Project Tiny Context Harness is repo-native project memory for AI coding agents, plus a narrow delivery harness for trustworthy long-task completion. The product principle is: keep the memory, drop the ceremony. It adds durable project memory behind `AGENTS.md` without becoming an agent scheduler or Git orchestrator. It is designed to reduce drift between large plans, durable project truth, design intent, implementation and proof by keeping ownership recoverable and assurance proportional to the delivery.
 
 Public launch surfaces are English-first; localized documents are secondary entry points.
 
@@ -115,17 +115,17 @@ Use this route when an implementation delivery both genuinely needs new style-be
 1. Run `ty-context enable long-task` once.
 2. If Design Authority is absent and the scope is style-bearing, explicitly select `$design-system-authoring` to generate, select and adopt the canonical `DESIGN.md`, token source and provider binding. Skip it when Design Authority is already configured.
 3. Prepare a writable project-native initial proposal at a concrete path such as `docs/initial-proposal.md`. It may come from the user, an external service or an explicitly requested applicable proposal capability; `design-resource-authoring` does not author it, and no standalone intermediary authoring stage is required.
-4. Select `$design-resource-authoring` with that path plus the exact development scope and targets. Keep its reconciled proposal, validated residual `design-resource-handoff-v1`, and selected immutable canonical resources, manifest and dependencies.
-5. Select `$long-task-workflow` with the exact paths to all of those inputs. It authors the Source-bound Contract Draft. The first Compile/Authority Lock always ends the current turn before implementation and says `After handling the model change, send [continue].`; earlier model wording cannot skip this boundary and Harness cannot observe whether the host model changed. After the user resumes, the parent evaluates delegation suitability and delegates independent bounded work only when the host explicitly selects exact `long_task_implementation`; otherwise it executes in the parent without a generic substitute. The parent still owns authority, architecture, Context, integration, current-candidate checks and formal verification.
+4. Select `$design-resource-authoring` with that path plus the exact development scope and targets. For formal Web/App work it first reads real technical Source. Keep its reconciled proposal, validated residual `design-resource-handoff-v1`, separate implementation-feasibility input, and selected immutable canonical resources, manifest and dependencies.
+5. Select `$long-task-workflow` with the exact paths to all of those inputs, including feasibility Source. It authors the Source-bound Contract Draft. The first Compile/Authority Lock always ends the current turn before implementation and says `After handling the model change, reply exactly: model checkpoint cleared, continue`; a generic continuation does not satisfy the managed prompt protocol, earlier model wording cannot skip this boundary, and Harness cannot observe the next host message or whether the model changed. After the user resumes, the parent identifies qualifying bounded packets before profile/capacity. Absent an explicit user or host prohibition, a qualifying set requires actual host calls for multiple exact `long_task_implementation` workers; host results determine zero-start or partial fallback under the Skill's six-reason rule. Worker count stays dynamic, generic substitutes remain forbidden, and the parent alone owns Source, Contract, Authority, architecture, Context, packet selection, integration, current-candidate checks, formal verification, Final Gate, close and completion.
 
 ```text
 $design-system-authoring Generate, select and adopt the project design system for this style-bearing scope. Skip this request when DESIGN.md is already configured.
 
 Prepare a writable project-native initial proposal at docs/initial-proposal.md for <delivery scope>.
 
-$design-resource-authoring Use docs/initial-proposal.md for <exact development scope and targets>. Return the reconciled proposal path, validated design-resource-handoff-v1 path, and selected immutable canonical resource, manifest and dependency paths.
+$design-resource-authoring Use docs/initial-proposal.md for <exact development scope and targets>. Return the reconciled proposal path, validated design-resource-handoff-v1 path, implementation-feasibility Source path, and selected immutable canonical resource, manifest and dependency paths.
 
-$long-task-workflow Use docs/initial-proposal.md, <handoff.md>, and the selected canonical resources, manifest and dependencies as Source for one complete implementation delivery.
+$long-task-workflow Use docs/initial-proposal.md, <handoff.md>, <feasibility.json>, and the selected canonical resources, manifest and dependencies as Source for one complete implementation delivery.
 ```
 
 These paths are illustrative. Candidate images or editable explorations alone do not authorize fidelity; implementation uses the selected immutable canonical resources and their validated handoff.
@@ -189,7 +189,7 @@ npm ci
 npm run smoke:quickstart
 npm run preview:pack
 cd /path/to/your/test-repo
-npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.8.13.tgz
+npm install -D /path/to/project-tiny-context-harness/tmp/ty-context/source-preview/package/project-tiny-context-harness-0.8.17.tgz
 npx --no-install ty-context init --adopt
 make validate-context
 ```
@@ -244,6 +244,8 @@ When foundational machinery, a mature protocol/security boundary, a dependency/s
 
 Implementation order, methods and feedback cadence remain Goal-owned. The thin discipline is to reuse the owning service/facade/adapter and one source of truth, make the smallest complete change, preserve explicit failure/resource semantics and add abstraction only for a stable concept or evidenced change axis. Exact product/technical predicates remain owned by Semantic Facts and selected UI/UX values by selected-design closure.
 
+`context_development_engineer` is content-sensitive rather than generic-coding-sensitive: material owner/source-of-truth, architecture/dependency, API/schema/data/state/lifecycle, complex-alternative, concurrency/recovery, external-integration/shared-abstraction, performance/security/compatibility/migration or architecture-audit judgment loads its on-demand engineering reasoning; generic implement/fix/refactor wording, role/agent mentions and ordinary local code/test/docs/style work do not activate it merely by themselves. The reference separates facts/constraints/assumptions/unknowns, drivers/path dependence, material alternatives, counterfactuals and minimum experiments, then projects the decision into concrete owners, interfaces, data/state/lifecycle/failure and checks. It is not a mandatory method checklist or second workflow.
+
 After implementation and project verification, `Engineering Quality Conformance` includes `Architecture Conformance` and checks the current candidate for scope/path escape, owner/dependency violations, owner bypass, duplicate truth, undeclared boundary/lifecycle change, silent failure, applicable resource/concurrency/security/compatibility/operability defects, unsupported performance claims, missing declared checks and new or worsened debt. A performance claim requires workload, metric, baseline or budget, environment, comparator/tolerance and a project-owned benchmark/probe; static shape is not runtime proof. Any candidate or controlling-input change invalidates the result. Default work embeds this closure in Contract Conformance; Long-Task maps every material independently falsifiable invariant into existing Source-backed obligations/constraints/forbidden shortcuts, owners/paths/Bindings, executable Checks and separate Assertions where functional behavior could pass independently. Final Gate is the sole Long-Task carrier and proves only that declared project-check-bound set—not overall code quality. The two carriers never both run for one candidate.
 
 Contract Conformance asks whether current Source and Context reached implementation and verification; the separately named Context drift check asks whether implementation or a new decision made durable Context stale. New or worsened debt blocks handoff unless the project has an explicit bounded exception with owner, rationale, tracking and a removal condition. Unrelated legacy debt does not automatically expand task scope, but debt touched, relied on or worsened by the change cannot remain hidden.
@@ -258,7 +260,7 @@ Newly generated Harness configs default to `strict_except_generated`. Generated/
 
 ### Product Surface Contract
 
-`context_surface_contract` compiles durable screen/page/CLI responsibility using existing `contract`, area/subdomain and verification roles. `product-surface-contract.md` owns cross-surface/main-versus-drilldown responsibility; optional on-demand `screen-contract.md` goes deeper for one screen's entry/exit/shared state, information hierarchy, semantic regions, navigation/variants, material controls and target/verification references. This workflow must not add a new Context role or claim product-quality proof, and local style fixes do not require a Screen Contract.
+`context_surface_contract` compiles durable screen/page/CLI responsibility using existing `contract`, area/subdomain and verification roles. `product-surface-contract.md` owns cross-surface/main-versus-drilldown responsibility; optional on-demand `screen-contract.md` goes deeper for one screen's target user/context reference, primary task outcome/work object/loop, operation-object-feedback relationship, critical visible context, entry/exit/shared state, information hierarchy, semantic regions, repeated-scroll/context-switch boundary, client/size-class topology, navigation/variants, material controls and target/verification references. `context_uiux_design` may load a non-authoritative task-analysis method for material new-page/flow/complex-control, hierarchy/topology, task-feedback, client adaptation, recovery/state/accessibility or UI/UX audit reasoning, but durable Design Authority remains its only owner role and Surface/Screen Source still owns page duty. Analysis or Skill activation alone grants no write authority; an already-authorized implementation may update the smallest Surface owner only when the current Goal independently decides `Context Delta: required`. Local style/copy/icon/image fixes, exact-target local alignment and single-control previews remain lightweight.
 
 For material UI, **UI Authority Closure** reconciles each stable surface/control/target key as covered by existing Context, requiring a Context update, task-local, explicitly out of scope or genuinely decision-required. Design Source Projection sends durable cross-surface and Screen/Control/state meaning to existing Product Surface or Screen/interaction Context, durable visual-system/token/motion-policy/rationale meaning to `DESIGN.md`, exact composition/value/condition/asset facts to versioned targets, repeatable proof routes to verification Context and delivery-local coverage/provenance/blockers to task or Contract Source. Conflicts fail closed; current code, timestamps, YAML or implementation screenshots do not silently win.
 
@@ -278,12 +280,18 @@ This mechanism cannot discover intent the user never expressed or prove an arbit
 
 ### Visual Delivery Guidance
 
-Both development paths preserve selected design Source authority within its declared scope and conditions, but they do not share a formal proof level. Formal handoff preflight still proves complete machine-readable input; default work then opens affected targets/conditions, routes them to production owners and current-candidate project checks, and reports conditions not established. Long-Task additionally provides exact per-Fact/Rule machine closure. Neither route infers unexpressed behavior or proves that the user supplied every desired requirement. Open Design can produce implementation-rich HTML/CSS/JS, specifications, tokens and assets, but capability is not a per-run guarantee: for a selected Web/App implementation handoff, `design-resource-authoring` must explicitly commission and completely retrieve one machine-readable canonical entry plus its exact dependency closure, freeze every file with a digest and expose stable typed locators. Before `ready`, it exercises every declared verification method on those immutable bytes and blocks unresolved conflicts among code, specs, tokens and assets. That is source QA, not production acceptance. PNG may be a visual baseline, never the sole implementation source.
+Both development paths preserve selected design Source authority within its declared scope and conditions, but they do not share a formal proof level. Formal handoff preflight still proves complete machine-readable input; default work then opens affected targets/conditions and real-substrate feasibility Source, selects the production strategy in Architecture Deliberation, routes it to current-candidate project checks, and reports conditions not established. Long-Task additionally provides exact per-Fact/Rule machine closure through existing Source, bindings and its sole Final Gate. Neither route infers unexpressed behavior or proves that the user supplied every desired requirement. Open Design can produce implementation-rich HTML/CSS/JS, specifications, tokens and assets, but capability is not a per-run guarantee: for a selected Web/App implementation handoff, `design-resource-authoring` must explicitly commission and completely retrieve one machine-readable canonical entry plus its exact dependency closure, freeze every file with a digest and expose stable typed locators. Before formal publication, it exercises every declared verification method on those immutable bytes and blocks unresolved conflicts among code, specs, tokens and assets. That is source QA, not production acceptance. PNG may be a visual baseline, never the sole implementation source.
 
 The provider-neutral handoff is a residual semantic and binding layer, not a textual copy of CSS, another value authority or another complete Fact index. Before formal Web/App generation, `design-resource-authoring` derives an Expected Fact Universe from scope, adopted Design Authority and a frozen Inspector/Census obligation. The atomic unit is an applicable `subject × selected target × condition combination × variation combination × property` Fact Cell. Subjects include surfaces, regions, overlays, component families/instances, controls, every anatomy part/slot/primitive, text, icons, media, assets and relations. Conditions are first-class across 33 standard condition axes (platform/runtime/device/viewport/density/safe area/window/fold/display/color/localization/content/data/text scale/input/assistive and accessibility preferences/system UI/IME/permission/capability/connectivity/lifecycle); variation is first-class across five variation axes: `variant`, `state`, `interaction_phase`, `presence_phase` and `instance_case`. Properties use 217 standard atomic keys across geometry, layout, scroll, typography, color, decoration, content, icon, media, interaction/navigation, motion/feedback, responsive, accessibility, asset, system and relation families, plus explicitly defined custom properties.
 
 The generated canonical implementation source remains the sole owner of exact values. Its dependency closure contains a `design-resource-observable-fact-manifest-v1` with stable subject/property/Fact IDs, typed locators, located-value digests, units/rounding/pixel-snapping rules, token/effective-value lineage, dynamic population/relations/assets, required proof methods, comparator parameters/tolerance/mask, Oracle identity/capability and render environment. A frozen Inspector enumerates the complete resource/node/declaration/token/asset/relation/custom-property/variant/state/interaction/dynamic-population Census; complete-generation counts and digests prove that no sampling or truncation occurred. Each applicable Fact Cell is either covered by one atomic Fact or carries an explicit blocking/non-applicable disposition with Source/basis/rationale. Aggregate labels such as “all states” cannot stand for atomic values, and a default page/shared style cannot be used to infer another applicable combination.
 
+Formal Web/App handoff also indexes one separate `design-resource-implementation-feasibility-v1` JSON Source per target. It records current platform, framework/runtime, UI system, token/theming adapter, component-owner roots and route-owner roots; non-observed dispositions carry a reason instead of an invented value. Every material component-family × target × condition profile binds the complete matching V1 Fact or intersecting V2 Rule set and has capability/feasibility-Source-backed reuse/compose/extend/theme/create candidates or an explicit blocker. Composite multi-primitive strategies, per-platform candidates and authorized planned owners are valid. Browser-only capability cannot be relabeled as a native-App/React Native substrate. Exact design values remain canonical-resource owned and are rejected from feasibility prose; DRA cannot select a required production realization without independent technical authority. V1 uses an exact condition partition and symbolic V2 uses reachable, disjoint and exhaustive regions. New V1 bundle publication requires the input; direct preflight keeps legacy implementation handoffs readable and reports `technical feasibility not declared` when absent, while a `reference` target may omit it without that limitation.
+
+Unresolved substrate observations are target-wide: every `decision_required` or `unavailable` observation is named by an exact blocker in every material family × condition cell, blocker/projection observation-ref sets are equal, and zero-family vacuity fails. Candidate cells require observed component-owner roots. Exact motion or ambiguous time values remain canonical-resource data; explicit build/compile/test/startup/latency/timeout/network/benchmark/runtime-cost durations remain valid technical feasibility prose.
+
+Long-Task proves every `file`/`path_glob` target and carrier, every `verified` carrier and every planned non-empty carrier wholly inside observed component/route roots; partial or unknown containment fails. Empty component refs stay invalid under standalone Contract validation. Complete activation defers that check only for all-blocker-only surfaces with valid route and exact blocker closure; candidate, mixed, legacy, missing-feasibility and fake-binding cases fail. Open target-blocking External Confirmation reaches `blocked_external`, never `machine_accepted`, without changing the sole Final Gate.
+
 Ready handoff requires exact set equality: `Expected Fact Universe = Canonical Resource Facts = Handoff Indexed Facts`, together with complete material-with-facts or honestly supporting-only resource closure. The canonical per-target manifest is the sole complete Fact/Census/proof index. New authoring keeps the shipped `design-resource-handoff-v1` marker and adds `representation: manifest_backed`; YAML carries only residual Source/scope/resource/target/closure/coverage/proposal binding, and preflight hydrates the same complete V1 object from the frozen manifest. Older embedded V1 remains read-compatible. UI symbolic V2 is explicit opt-in; V1 remains the default. An opted-in target uses `design-resource-handoff-v2`, `representation: symbolic_rules_v2` and `design-resource-observable-rule-manifest-v2`; constant located expected values and mutually exclusive canonical regions preserve exact point meaning. Applicability either keeps legacy exact remainder rows or uses package-owned property profiles, frozen Inspector custom-property closure and explicit unique instance exceptions, while every logical subject-property point retains one disposition. Fact Rule, required-method semantic obligation and set-valued non-interference certificate identities remain separate. `ready` is emitted only after unresolved dispositions and blockers are absent, V1 proof policies pass, and an `exact_target`'s full-target layout and pixel region unions each cover the complete reachable domain. Omitted axes require 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. Preflight resolves immutable resources and exact locators, recomputes canonical DAG/region/certificate identity and rejects missing, overlapping, gapped, unresolved, unsupported, stale or value-conflicting input. Exploration remains schema-free.
 
 Every non-interference method requires a digest-identified frozen executable Oracle with the exact `symbolic_noninterference.<side>.<method>` capability. On the Source side, the complete Inspector input set contains exactly one canonical, non-executable `design-resource-symbolic-source-ir-v1` resource for each admitted scope. The package binds that IR to the current target, certificate and Rule scope, reparses its current bytes and derives the dependency DAG, canonical predicate or complete finite-domain evaluation itself. Submitted graph nodes, Rule roots, side/axis-erased predicates, evaluation claims and passed verdicts are only Oracle-output caches; preflight requires `current recomputation = artifact bytes = proof binding/cache`, and the artifact is not part of the semantic input closure. Static non-interference therefore cannot be accepted from an axis list or manufactured from Rule references. JavaScript, CSS cascade or implicit DOM semantics, executable templates, dynamic loading/fetch/import, reflection, computed access, unfrozen extensions and external runtime/device dependencies block until a package-owned complete extractor exists. The production side retains its conservative package-parsed static HTML plus inert JSON subset. Both sides bind Oracle implementation closure/version/capability, environment, every input path and declared/current digest, current Source-manifest or production-target snapshot, exact Rule/certificate scope, omitted axes, derived method result, artifact path/digest and attributable failure witness. Source and production proof digests enter certificate identity and the existing current Final-Gate certificate expectation/result; extraction outside the admitted representations remains an explicit TCB boundary.
@@ -298,7 +306,11 @@ The default Workflow performs UI Authority Closure and a conditional Design Auth
 
 For selected implementation handoff files, DSA first publishes the exact target set with `ty-context design-resource bundle`; both development paths rerun `ty-context design-resource preflight <handoff.md>` on every published file. Incomplete acquisition, missing or undeclared dependencies or targets, duplicate targets, unsafe paths, stale manifest/file digests, fictional locators, non-frozen or incomplete Census, sampled/truncated generation, aggregate axis values, mismatched Expected/Canonical/Handoff Fact sets, missing required methods, invalid comparator/Oracle/environment binding, unresolved design-system lineage, uncovered applicable cells, absent exact-target layout/pixel facts, unsupported evidence and unresolved meaning all fail closed. Each workflow must still open the resources and prove the production implementation on the real entry.
 
-For material work, `context_uiux_design` applies the projection above and keeps risk-proportional coverage reasoning task-local. `context_development_engineer` traces every affected selected target and declared condition through stable surface/control keys to the production route/component owner, cold-start real-user journey and applicable rendered/interactive checks. A first useful runnable production slice is a recommended real-entry feedback point when early localization is worth the cost, never an implementation gate; the final candidate always reruns the affected cold-start journey. Source-required combinations cannot be silently pruned, but default work reports conditions it did not establish instead of claiming exact machine closure. Resource hashes, manifests and counts prove integrity only; an implementation screenshot cannot become its own target or implementation-conformance proof.
+In Long-Task projection, every Claim-bearing Assertion remains single-Claim. For each selected-design verification method, the target's root conformance Assertion and that method's independent Assertion jointly cover the Source Claims referenced by its Facts or Rules; the union closes coverage without collapsing method capabilities, evidence, results or failure attribution.
+
+Repository patterns accept parentheses only as escaped literal route-group characters—never regex groups or extglob—while preserving existing `*`, `**`, `?` and rejecting unsupported `[]`/`{}` syntax.
+
+For material work under either existing execution route, `context_uiux_design` applies non-authoritative task-level UI/UX analysis and keeps risk-proportional coverage reasoning task-local. Product/Surface/Screen Source remains the durable owner of page duty and interaction topology, while `DESIGN.md` and selected exact-target/constraint Source own visual-system and selected-design facts. With a valid Long-Task binding, `long-task-workflow` alone owns Source/Contract lifecycle, formal verification, Final Gate and completion; the UI/UX Skill may also contribute Design Authority closure but creates no second plan, lifecycle, Authority, Gate or acceptance path. `context_development_engineer` traces every affected selected target and declared condition through stable surface/control keys to the production route/component owner, cold-start real-user journey and applicable rendered/interactive checks. A first useful runnable production slice is a recommended real-entry feedback point when early localization is worth the cost, never an implementation gate; the final candidate always reruns the affected cold-start journey. Source-required combinations cannot be silently pruned, but default work reports conditions it did not establish instead of claiming exact machine closure. Resource hashes, manifests and counts prove integrity only; an implementation screenshot cannot become its own target or implementation-conformance proof.
 
 An explicit Long-Task is the strong authority carrier of the same shared obligation. It resolves missing/conflicting UI authority before Compile, then closes all 22 canonical fields of every real Product Control through `field_coverage`; that semantic Control projection is independent of, and never caps, the finer design Fact universe. Selected targets freeze the canonical manifest identity/digest and project every atomic Fact/required-method pair into a `fact_expectations` row with subject/target/condition/variation/property identity, expected located-value digest, comparator/parameters/tolerance/mask, Oracle identity/capabilities, environment and sensitivity. Only a package-admitted observer may supply the matching `fact_results` Actual/comparison row. In the current slice, project `design_conformance`, `design_method` and `fact_results` records are diagnostic; affected UI/design obligations remain blocking External Confirmations rather than machine proof. Product `surface_bindings`, Control Claims/relations and root-entry journeys continue to carry product semantics, while existing Claim, Assertion, Check, Stage, Binding, revision and Final Gate mechanisms remain the sole Long-Task lifecycle and closure. Every blocker preserves exact Source-item/method/capability lineage and cannot be dismissed in-band; scope removal requires revised Source/Contract authority.
 
@@ -306,7 +318,7 @@ Combined design-and-implementation work may author candidates in ordinary Outcom
 
 `ty-context doctor` keeps its compatible `missing | unconfigured | configured` project-level status and adds advisory Design Authority Index, token-source and classified-reference signals. It explicitly does not infer surface implementation readiness; that requires the owning Screen/Control meaning, selected target/constraints and project-owned verification.
 
-Static guidance tests prove distribution, projection and canonical ownership, not Agent performance. The optional delivery-mechanism benchmark provides a fixed fresh-agent UI/UX Context/target-recovery task with routing gold and a hidden production oracle; only independent paired runs may support effectiveness or ROI conclusions.
+Static guidance tests prove routing text, positive/negative analysis rules, distribution, projection and canonical ownership—not real host Skill activation, Agent adherence, map-design quality, runtime cost, performance or ROI. The optional delivery-mechanism benchmark provides a fixed fresh-agent UI/UX Context/target-recovery task with routing gold and a hidden production oracle; only independent paired runs may support effectiveness or ROI conclusions.
 
 ### Explicit Design System Authoring
 
@@ -316,11 +328,13 @@ Use `design-system-authoring` only on an explicit request to initialize, generat
 
 Use `design-resource-authoring` only for an explicit request to generate, iterate or prepare standalone design resources, prepare resources for a named development scope, or use Open Design. It accepts raw notes or an initial proposal, product/technical plans, a visual brief, screenshots, existing resources or another pre-existing planning document. No standalone intermediary authoring document is either prerequisite or recommended middle stage.
 
-The Skill makes the explicit output or development content its hard ceiling; a local slice includes only necessary surrounding context. For an implementation handoff it accounts for material UI/UX meaning through relevant surfaces/flows/regions/components/controls and applicable visual/content, state, interaction/feedback/motion, responsive/platform/input, accessibility and asset conditions, then subtracts only explicit selected-source coverage. It discovers current Open Design capabilities and assigns every considered resource a reasoned `selected`, `optional`, `not-needed`, `unavailable` or `decision-required` disposition.
+The Skill makes the explicit output or development content its hard ceiling; a local slice includes only necessary surrounding context. Before page/flow/complex-control generation it separately consumes controlling Product/Surface/Screen Source for target user/context, client/host, page duty, primary task outcome, primary work object/task loop, operation-object-feedback and applicable state/recovery/accessibility meaning, and `DESIGN.md` plus selected exact-target/constraint Source for visual-system and selected-design conditions. Non-authoritative task-level UI/UX analysis may inform candidate comparison but cannot supply missing product or surface meaning. The Provider must not infer that meaning from a feature list, screenshot, route tree, component inventory or analysis output. For an implementation handoff it accounts for material UI/UX meaning through relevant surfaces/flows/regions/components/controls and applicable visual/content, state, interaction/feedback/motion, responsive/platform/input, accessibility and asset conditions, then subtracts only explicit selected-source coverage. It discovers current Open Design capabilities and assigns every considered resource a reasoned `selected`, `optional`, `not-needed`, `unavailable` or `decision-required` disposition.
+
+Inside that ceiling, DRA records selected existing coverage, new gaps and preservation obligations. An outside-ceiling effect returns existing `decision-required` with reason `scope-expansion-required`; only the user can expand the ceiling. A durable Product/Surface/Screen/Design change updates its actual owner before generation resumes. Style-bearing commissions carry Source-derived `style_application` fields only where needed plus an archetype-specific `quality_commission` for primary challenges, desired/avoided visual character, real copy/data, reference roles and design-side shared-family reuse. These are task-local Provider inputs, not files, states, scores, Authorities or routing records.
 
 Formal generation, a major design revision and critical regeneration use the highest eligible live model and that model's highest supported reasoning effort. Eligibility first preserves required tools, visual/context capability, authentication and data boundaries; provider capability ordering or documented replacement evidence establishes rank. The Skill never guesses from price, model name, release date or list order. An unrankable choice fails closed as `highest_performance_unverified`; an uncontrollable or unobservable provider result is reported with the same qualification and is never described as a confirmed highest-tier run. This policy creates no model registry, scheduler or persistent routing state.
 
-For formal Web/App implementation output, “complete” defaults to the finest applicable observable Fact granularity described above. The Skill builds the Expected Fact Universe and frozen Inspector/Census obligation before commissioning generation, passes that obligation and the adopted design-system identity into Open Design, and requires the returned canonical source/manifest to express every applicable cell. It does not defer missing anatomy-part, state, responsive/platform/text-scale, motion, accessibility or asset design decisions to downstream implementation.
+For formal Web/App implementation output, “complete” defaults to the finest applicable observable Fact granularity described above. Before commissioning generation, the Skill builds the Expected Fact Universe, freezes the Inspector/Census obligation, and reads real technical Source for the platform, framework/runtime, UI system, token/theming adapter, component owners and route owners. It passes those constraints and the adopted design-system identity into a live capability matched to the resource archetype, then requires the returned canonical source/manifest to express every applicable cell. It separately authors the feasibility document described above; every material family/condition has a candidate or blocker, while production-owner selection remains downstream. It does not defer missing anatomy-part, state, responsive/platform/text-scale, motion, accessibility, asset or basic implementability decisions to downstream implementation.
 
 High-fidelity/branded output, visual direction, typography/color/density, component visual treatment and production-style prototypes are style-bearing. If Design Authority is unconfigured or lacks one authored token source/direction, the Skill stops before project/run creation and tells the user to explicitly select `design-system-authoring`; it never auto-initializes. Low-fidelity structure, IA/flow and semantics-only state studies remain non-fidelity. Style-bearing Open Design projects pass the adopted ID through `create_project.designSystem` and verify `get_project.designSystemId`.
 
@@ -328,13 +342,15 @@ It commissions only the smallest sufficient artifact/file set through structured
 
 For implementation Web/App output, the Skill requires the complete canonical entry/dependency set and addressable declared facts described above. Figma remains useful when an existing design team needs native Components/Variables/Variants, shared libraries, Dev Mode or Code Connect; Penpot when open/self-hosted multi-user design infrastructure is itself required; OpenPencil as a local static-layout sidecar while its prototype/motion model remains incomplete. Default conversion from complete Open Design source to another representation is not required because it adds synchronization and operating cost without closing a new enforcement gap.
 
-Exploration returns a visible scoped candidate after minimal sanity review and requires no handoff schema. After explicit or delegated final selection for implementation, the Skill performs one consolidated idempotent proposal reconciliation and writes one provider-neutral marked Markdown Source per target. V1 manifest-backed authoring remains the default; only an explicit per-target symbolic opt-in emits the strict V2 Rule manifest/handoff. Shared preflight normalizes the declared representation and cannot call incomplete, unaddressable, unresolved, unsupported or stale input ready. There is no fixed directory, provider pack or one-file-per-control rule. The adapter is ordinary Source, not Design Authority or acceptance. Outside the one explicitly authorized proposal writeback target, the Skill never edits caller-owned planning/proposal Source, Context, `DESIGN.md`, production code or a Delivery Contract.
+Provider execution, Artifact readiness and Design suitability stay separate. Suitability inspects at least one real render for formal high-fidelity work and proportionally reviews scope/Source, mechanical integrity, Design-System application, visual craft/language, product distinctiveness, content realism, design-side component reuse, technical feasibility, state/condition coverage and preservation. A first candidate with no material grounded defect may proceed directly to selection; a material defect triggers the highest-impact smallest patch, rerender and affected re-review, never a cosmetic revision quota. Suitability never performs human selection or independently establishes readiness. Provider behavior relied on durably is pinned to an immutable version/tag/commit instead of a floating branch.
+
+Exploration returns a visible scoped candidate after minimal sanity review and requires no handoff schema. `Design Resource Review & Selection Stop` lets the user correct, select, reject, leave unresolved, expand scope or route a durable owner change; it is not an approval record, Gate, acceptance or formal-completeness claim. Ordinary conversational selection creates no persistent state; deterministic cross-interruption selection reuses existing marked Source, authority, selected-source and recovery-checkpoint owners. Selection binds the canonical selected-source digest, target, declared conditions and controlling Source/Design-Authority identity. Equivalent derived exports preserve selection; visible or semantic differences return to suitability and review. After a selected formal Web/App direction completes canonical source/dependency/Census/manifest/preflight closure, any newly visible decision returns to the same stop; only stable closure is followed by one consolidated idempotent proposal reconciliation and provider-neutral marked handoff. V1 manifest-backed authoring remains the default; only an explicit per-target symbolic opt-in emits the strict V2 Rule manifest/handoff. Shared preflight cannot call incomplete, unaddressable, unresolved, unsupported or stale input ready. Outside the one explicitly authorized proposal writeback target, the Skill never edits caller-owned planning/proposal Source, Context, `DESIGN.md`, production code or a Delivery Contract.
 
 Material DRA revision loops replay from a raw-digest-bound Base plus complete ordered Delta semantics. Deterministic accepted authority additionally requires a strict `ty-dra-authority-v1` projection inside the same digest-covered marked Source Item: explicit choices bind exact target/kind/origin/meaning digest, while delegation binds only its exact choice scope and never becomes a non-visual meaning Source. Every semantic target has at most one active accepted Delta owner; rejected, unresolved and superseded Deltas form an exact leakage universe. One v3 audit-expectations catalog freezes changed/unchanged/resource-decision/blast-radius/leakage rows plus selected-resource conditions, and current audit rows must be set-equal without duplicate identities. Exact-patch-v2 binds every active non-preserve `Delta × target` once to its Proposal text span and semantic digests; every such binding has exactly one `proposal-written` or structured, repository-readable `resource-owned-exact-visual` owner. A real cross-interruption need may explicitly `create` one ignored, task-local, non-authoritative checkpoint; `update` replaces it only through caller-supplied checkpoint digest CAS, while `inspect` and `preview` rederive current state. `apply` uses pre/post raw-byte CAS and reread reconciliation, reporting applied, idempotent, blocked or external-resource revalidation pending—not handoff readiness. `remove` fully deletes only after inventory proves the directory contains the digest-matched helper checkpoint; otherwise it returns `partial` and preserves unowned content. A simple preview creates no checkpoint, persisted bytes, pause, Provider run, formal handoff, Proposal write or helper transaction. The checkpoint and reconciliation are upstream recovery/diagnostic data, never Design Authority, Long-Task Source/Evidence or completion proof.
 
 Actual generation remains with configured Open Design/Product Design, Figma, image-generation, prototype or human systems. Their outputs enter the default Workflow or Long-Task as ordinary external Source. Candidates and inspiration authorize no fidelity. An adopted exact target/constraint becomes Context-reachable Source: owning Context/`DESIGN.md` maps its stable key to declared conditions, a stable immutable identity/digest and an editable upstream owner/locator/update route. `context_uiux_design` performs downstream UI Authority Closure; implementation renders and diffs remain evidence rather than self-authorizing targets.
 
-Maintainers may set `TY_CONTEXT_OPEN_DESIGN_MCP_COMMAND` plus optional `TY_CONTEXT_OPEN_DESIGN_MCP_ARGS_JSON` and run `npm run smoke:open-design` for an opt-in, read-only discovery smoke. Normal tests use a local mock MCP and do not depend on Open Design or nondeterministic output.
+Maintainers may set `TY_CONTEXT_OPEN_DESIGN_MCP_COMMAND` plus optional `TY_CONTEXT_OPEN_DESIGN_MCP_ARGS_JSON` and run `npm run smoke:open-design` for an opt-in, read-only discovery smoke. The source workspace's existing delivery-benchmark owner also contains an opt-in DRA visual diagnostic with eight fixed cases, five pinned routes, blinded randomized review and repeated descriptive observations; it has no admission, publication, ranking, routing or design-selection effect. Normal tests use a local mock MCP and do not depend on Open Design or nondeterministic output.
 
 ### Retired Standalone Authoring Compatibility
 
@@ -346,7 +362,7 @@ The explicit Long-Task Workflow uses one currently selected platform-native exec
 
 Its proof claim is conditional: complete and accurate Source at the declared observable granularity, meaning-preserving projection and complete applicability expansion make `AcceptedDeliveryTerminal`—exactly a fresh `machine_accepted` result with no pending External Confirmation—imply that no declared machine-observable drift remains only when every machine obligation has frozen Expected authority, package-admitted current Actual, Harness-computed comparison/verdict, attributable static-production or direct-process observation, causal Counterfactual evidence and current Final-Gate snapshot proof. `machine_accepted_external_pending` proves only the admitted machine scope. Harness cannot discover undeclared requirements or prove arbitrary physical/external observation sound.
 
-Compile derives an internal `CompiledObservationAuthority` for every machine Claim or Fact × required-method obligation; it is not a new Contract Authority, state or registry. `package_static_json_exact` reads plain exact implementation/configuration content only from a UTF-8 JSON production carrier that exists in the pre-run snapshot, retains its no-follow identity/digest after the runner, matches the Binding and is not Source/Context/Contract/expected/evidence/report/status/verifier output; prepare-all mutation observation plus pre/post identity/hash rejects transient/persistent swaps, and the adapter proves no runtime consumption. `package_process_json_exact` supports only a Source-backed `runtime_family: process`, `role: product` target and a direct root `project_binary` whose target and complete argv match that authority. Each required target has one canonical Source technical-obligation target covering key, role, family, root, complete argv and capabilities. Compile derives one declaration-stable runtime closure containing the exact Source-backed root, exact Claim/Counterfactual production carriers and only finite argv values that match a production Binding by exact path or pattern. It examines a standalone argument or explicit `--key=value`, resolves safe repository-relative values from declared `cwd`, supports glob-owned and extensionless files, and ignores unmatched safe relative values without copying them. Absolute paths, repository escapes, `file:` URLs and network URLs fail closed unless explicitly routed to the external boundary. Compile neither broadly role-scans nor copies all `input_paths`; role separation covers 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. Exact planned closure members may be absent through Compile but must materialize at Final Gate. The closure excludes Source/Context/Contract/canonical expected, verification inputs, expected outputs/artifacts, evidence/status/report/comparison/Receipt/Long-Task workdir and historical session/evidence. Harness copies only that closure into an OS-temporary snapshot and binds its identity into host attestation. Compatible Cross-Check and implicit-preserved Facts share one bounded `ty-context-product-observation-v1` stdout envelope while retaining independent result identities. An unsupported embedded dependency or Claim requires External Confirmation. Project results remain v3; no v4, general UI/native observer or language dependency parser is introduced.
+Compile derives an internal `CompiledObservationAuthority` for every machine Claim or Fact × required-method obligation; it is not a new Contract Authority, state or registry. `package_static_json_exact` reads plain exact implementation/configuration content only from a UTF-8 JSON production carrier that exists in the pre-run snapshot, retains its no-follow identity/digest after the runner, matches the Binding and is not Source/Context/Contract/expected/evidence/report/status/verifier output; prepare-all mutation observation plus pre/post identity/hash rejects transient/persistent swaps, and the adapter proves no runtime consumption. `package_process_json_exact` supports only a Source-backed `runtime_family: process`, `role: product` target and a direct root `project_binary` whose target and complete argv match that authority. Each required target has one canonical Source technical-obligation target covering key, role, family, root, complete argv and capabilities. Compile derives one declaration-stable runtime closure containing the exact Source-backed root, exact Claim/Counterfactual production carriers and only finite argv values that match a production Binding by exact path or pattern. Each argv member remains the exact child-visible token; the closed grammar examines an independent token or explicit `--name=value` without splitting spaces, stripping quotes or rewriting backslashes. Raw token and derived locator remain distinct. Quote-bearing, POSIX/UNC absolute, drive-prefixed, slash/backslash-platform-ambiguous, scheme-shaped colon prefixes outside the exact lowercase decimal `node:<number>` allowlist and unsupported compound forms fail closed unless explicitly routed to the external boundary. Cwd resolution precedes repository containment, so in-repository parent traversal is valid while a true escape is not. Glob-owned, extensionless and space-containing files remain valid; unmatched safe values and the exact lowercase decimal `node:<number>` and digits-only `<hours>:<minutes>` colon scalars are allowed but not copied. Compile neither broadly role-scans nor copies all `input_paths`; role separation covers 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. Exact planned closure members may be absent through Compile but must materialize at Final Gate. The closure excludes Source/Context/Contract/canonical expected, verification inputs, expected outputs/artifacts, evidence/status/report/comparison/Receipt/Long-Task workdir and historical session/evidence. Harness copies only that closure into an OS-temporary snapshot, binds its identity into host attestation and forwards unchanged argv. Compatible Cross-Check and implicit-preserved Facts share one bounded `ty-context-product-observation-v1` stdout envelope while retaining independent result identities. An unsupported embedded dependency or Claim requires External Confirmation. Project results remain v3; no v4, shell/URI/dependency parser or general UI/native observer is introduced.
 
 Project-submitted v3 actual/value digest, comparison, `passed`, verdict and capability records are compatibility diagnostics only and never own Actual or completion. Current package derivation covers exact/presence plus host `target_runtime`; `interaction_trace`, `state_delta`, `design_conformance` and every capability without package derivation require blocking External Confirmation. Custom/`named_external_tcb` Oracle, wrapper, browser/native/device, layout/pixel/accessibility/motion, protected, tolerance/mask and custom-locator observation are likewise unsupported. Machine Counterfactuals require package-admitted baseline/mutated observations with the same compiled closure identity, a mutation target in its production-carrier set, exact affected/preserved/allowed-fan-out accounting, equal obligation universes and host-derived process liveness; absence of admitted observation never skips validation. Migration never silently changes the observer choice, and target/closure TCB changes invalidate prior Active Authority, Progress, Evidence and Receipt acceptance.
 
@@ -360,19 +376,25 @@ Before the first successful formal Compile, `delivery-contract.yaml` is one non-
 
 The Long-Task Skill keeps objective/boundary/activity routing in its main file and loads one-level Source-bound Draft/Contract-mapping, evidence-design and authority-lifecycle references as applicable. Draft input repair and Contract mapping are concurrent activities, not serial phases. This is instruction packaging only, not a second authority. It performs the shared Architecture Deliberation and applicable-quality routing during Draft authoring. Declared independently falsifiable architecture or engineering-quality invariants use existing Source-backed obligations/constraints/forbidden shortcuts, owner/path/Binding boundaries, project-owned executable Checks and separate Assertions when functional behavior could pass independently. Final Gate is the sole Long-Task Engineering Quality/Architecture Conformance carrier and proves only that declared project-check-bound set.
 
-A Draft Outcome is simply an Outcome before Authority Lock. Outcomes decompose independently observable, decidable and target-verifiable results to project acceptance/verification readiness, localize failures, resume findings and invalidate stale results. `depends_on` means acceptance and intermediate-proof readiness, not implementation permission, and the Rolling Frontier is a temporary advisory projection. The current Goal chooses implementation order and may optionally use one or multiple platform-native agents/subagents; Harness creates no delegation runtime, scheduler, state or proof, agent reports are non-authoritative, and all accepted output converges into the selected verification workspace. An Outcome is not a Worker, scheduler task, queue or parallel unit. Outcome decomposes diagnosis and proof ownership, not completion authority, so one complete current-snapshot Final Gate remains mandatory.
+A Draft Outcome is simply an Outcome before Authority Lock. Outcomes decompose independently observable, decidable and target-verifiable results to project acceptance/verification readiness, localize failures, resume findings and invalidate stale results. `depends_on` means acceptance and intermediate-proof readiness, not implementation permission, and the Rolling Frontier is a temporary advisory projection. The current Goal chooses implementation order. After the checkpoint it applies the Skill's packet-first positive-default rule, including actual exact calls, six-reason zero-start handling and partial delegation; decomposition and count remain dynamic. Harness creates no delegation runtime, scheduler, state or proof, agent reports are non-authoritative, and all accepted output converges into the selected verification workspace. An Outcome is not a Worker, scheduler task, queue or parallel unit. Outcome decomposes diagnosis and proof ownership, not completion authority, so one complete current-snapshot Final Gate remains mandatory.
 
 When a declared result can pass on a proxy surface while failing in its target runtime, the earliest owning Outcome carries either an admitted direct-process root Check or blocking External Confirmation. A project payload, report, screenshot, binary, log, historical run, new session id or proxy cannot be runtime authority. Applicability and all Claim/proof cells remain independently attributable; project capability records are diagnostic, and only currently admitted exact/presence and host `target_runtime` results can satisfy their matching all-of cells. Every unsupported capability remains external. Every behavioral machine Assertion has a same-Check Counterfactual whose admitted affected Facts change, preserved Facts/liveness do not, other changes are explicit fan-out and obligation universes are equal. A Binding/path is not reachability proof: static mutation proves only that structure; runtime reachability requires Harness mutation → direct product-root execution → package-observed Actual change. Evidence/status/report/Receipt/verifier outputs cannot be production carriers. Existing minimal invalidation-envelope, targeted-feedback and current Final-Gate rules remain; no generic reachability scanner, implementation Gate, scheduler or state is added.
 
-Direct-process Compile uses one declaration-stable closure of the exact Source-backed root, exact production carriers and finite argv values that match a production Binding by exact path or pattern. It examines only a standalone argument or explicit `--key=value`, resolves safe repository-relative values from declared `cwd`, supports glob-owned and extensionless files, and ignores unmatched safe relative values without copying them. Absolute paths, repository escapes, `file:` URLs and network URLs fail closed unless explicitly routed to the external boundary. Compile neither broadly role-scans nor copies all `input_paths`; role separation covers 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. Exact planned closure members may be absent during Preflight/Compile but must exist at Final Gate. Compatible Cross-Check Facts reuse one Raw Execution/stdout envelope while keeping independent exact results.
+Direct-process Compile uses one declaration-stable closure of the exact Source-backed root, exact production carriers and finite argv values that match a production Binding by exact path or pattern. Every argv member stays the exact child-visible token. The closed grammar examines an independent token or explicit `--name=value`, never splits whitespace, unwraps quotes or rewrites backslashes, and keeps the raw token separate from its cwd-resolved repository locator. Quote-bearing, POSIX/UNC absolute, drive-prefixed, platform-ambiguous, scheme-shaped colon prefixes outside the exact lowercase decimal `node:<number>` allowlist and unsupported compound forms fail closed unless explicitly routed to the external boundary. Cwd-contained parent traversal, glob-owned, extensionless and space-containing paths remain valid; unmatched safe values and the exact lowercase decimal `node:<number>` and digits-only `<hours>:<minutes>` colon scalars are allowed without copying. Compile neither broadly role-scans nor copies all `input_paths`; role separation covers 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. Exact planned closure members may be absent during Preflight/Compile but must exist at Final Gate. Compatible Cross-Check Facts reuse one Raw Execution/stdout envelope while keeping independent exact results.
 
 Global and Outcome applicability profiles bind the exact target, journey role, atomic dimensions, Given condition/input/state refs and ordered When refs. Every Claim-bearing Assertion remains local to one matching profile and every actually applicable proof-surface cell remains mandatory.
 
-Long-Task Anti-Degradation Assurance protects current causal-chain truth, cross-version interception strength and the adjacent `F = Implementation Freedom Boundary`. Current-implementation Context must match the indexed code/runtime, which must still realize the two necessary meaning-capture and fail-closed final-proof responsibilities under the explicit theorem boundary. `F` is an efficiency/anti-process-bloat invariant, not a third responsibility or theorem premise: within Source/Contract, architecture, safety, forbidden-shortcut and irreversible/external-action boundaries, implementation order, methods, feedback cadence and optional one-agent or multi-agent/subagent execution remain Goal-owned. Harness adds no development phase/method Gate, per-edit mandate, agent scheduler/state or delegation proof. Weakening the protected purpose, key logic, either responsibility, theorem boundary or `F` requires an explicit project-owner design-purpose decision and replacement proof. A new development-stage constraint must also close a distinct path that final proof or a lighter project-owned check cannot cover and demonstrate positive net ROI—specifically evidenced high total-cost ROI and high efficiency—after the hard safety and proof constraints. High means a significant stable margin, not a global/local optimum. Once validity, relative non-degradation, must-allow behavior, structural-cost limits and applicable measured total-cost thresholds close, construction stops unless a new real counterexample, repeated material cost hot spot or evidence of significant additional net benefit appears. Existing Context, indexes, tests, critical sentinels, routing and parity gates carry this assurance without another Authority, Gate or state; they cannot infer omitted requirements or guarantee immutability against deliberate fully authorized joint weakening.
+Long-Task Anti-Degradation Assurance protects current causal-chain truth, cross-version interception strength and the adjacent `F = Implementation Freedom Boundary`. Current-implementation Context must match the indexed code/runtime, which must still realize the two necessary meaning-capture and fail-closed final-proof responsibilities under the explicit theorem boundary. `F` is an efficiency/anti-process-bloat invariant, not a third responsibility or theorem premise: within Source/Contract, architecture, safety, forbidden-shortcut and irreversible/external-action boundaries, implementation order, methods, feedback cadence, concrete packet decomposition and dynamic worker count remain Goal-owned. The current positive-default rule requires multiple exact workers only for the bounded qualifying predicate above and otherwise requires one admitted solo reason; Harness adds no development phase/method Gate, per-edit mandate, fixed allocation, agent scheduler/state or delegation proof. Weakening the protected purpose, key logic, either responsibility, theorem boundary or `F` requires an explicit project-owner design-purpose decision and replacement proof. A new development-stage constraint must also close a distinct path that final proof or a lighter project-owned check cannot cover and demonstrate positive net ROI—specifically evidenced high total-cost ROI and high efficiency—after the hard safety and proof constraints. High means a significant stable margin, not a global/local optimum. Once validity, relative non-degradation, must-allow behavior, structural-cost limits and applicable measured total-cost thresholds close, construction stops unless a new real counterexample, repeated material cost hot spot or evidence of significant additional net benefit appears. Existing Context, indexes, tests, critical sentinels, routing and parity gates carry this assurance without another Authority, Gate or state; they cannot infer omitted requirements or guarantee immutability against deliberate fully authorized joint weakening.
+
+Mechanism/release claims progress only through designed, implemented, known-counterexample protection, and high-quality realization within an explicit TCB. This observer revision remains Level 3. R9/R10 each preserve unused non-closure must-allow, non-closure-read runtime-isolation rejection and explicit bound-closure role-conflict Compile rejection as three independent proofs. The raw-argv incident is instead owned by its focused regression, complete current-candidate lifecycle matrix and independent audit; the historical ROI workload does not prove it and adds no `CASE_ID`. A complete committed attack candidate plus owner diagnostic proves the Compile boundary; a legal-neighbor Authority followed by freshness rejection on that same candidate separately proves Final-Gate non-reuse. `active_task_missing`, dirty-candidate rejection and a fresh Compile rejection are not substitutes. The current machine report owns the exact attack/control population without another registry. Level 4 keeps the unchanged complete total-cost ROI theorem, independent capability-audit requirement and separate explicit project-owner promotion. No surrogate tokenizer, prose, test count, fresh-Agent pair, observed lifecycle win or sanitized fixture can promote it.
 
-Mechanism/release claims progress only through designed, implemented, known-counterexample protection, and high-quality realization within an explicit TCB. This observer revision remains Level 3. R9/R10 each preserve unused non-closure must-allow, non-closure-read runtime-isolation rejection and explicit bound-closure role-conflict Compile rejection as three independent proofs. A complete committed attack candidate plus owner diagnostic proves the Compile boundary; a legal-neighbor Authority followed by freshness rejection on that same candidate separately proves Final-Gate non-reuse. `active_task_missing`, dirty-candidate rejection and a fresh Compile rejection are not substitutes. The current machine report owns the exact attack/control population without another registry. Level 4 keeps the unchanged complete total-cost ROI theorem and independent capability-audit requirement. No surrogate tokenizer, prose, test count, fresh-Agent pair, observed lifecycle win or sanitized fixture can promote it.
+The repository-owned eight-Fact A/B/C benchmark records each fixture's committed candidate identity and requires it to remain clean and unchanged. Real-process v5 always collects all five A/B/C repeat orders. One package materializer alone performs detached checkout, install, build, source-parity verification and script-disabled pack and binds exact commit/tree/lockfile/runtime. Workload/collection owns only raw and `observed_lifecycle_*` facts; aggregate/attestation status is `not_evaluated`; the formal-v2 packet maps paths only. After validating the actual manifest-v2 run set, the existing verifier creates the immutable artifact index and alone derives evidence admission, normalization, exclusive event ownership, `total_roi_supported`, `total_roi_positive` and formal status. Packet-authored bytes, roles, digests, verification flags, normalized values, monetary incident totals or event IDs are rejected. The verifier binds exact A/B/C materialized-package, benchmark implementation, acquisition runtime/TCB, scenario, collector, precollection, retention and redaction identities. The delivery-specific policy uses 1 NCU=CNY 1, CNY 200/50 hourly active/wait proxies, a ten-delivery cycle, five-pair median projection for repeatable costs, once-per-cycle maintenance/recovery, once-only introduction/adoption/migration and one controlled-incident benefit median. Provider/compute/storage derive from prelocked invoice/official-price sources and incident benefit from raw time/usage. Benefit must be at least 1.25 times positive incremental cost; at least 4/5 paired nets must be positive and sample CV at most 20%. Missing evidence remains unsupported. Provider-event v1-v2, the other listed formal v1 schemas, real-process v1-v4 and manifest v1 require recollection; machine measurement, independent audit and explicit project-owner promotion remain separate.
 
-The repository-owned eight-Fact A/B/C benchmark records each fixture's committed candidate identity, binds it to parsed raw HEAD/tree/status command records before and after lifecycle execution, and requires a clean unchanged candidate. It may expose versioned, recomputable `observed_lifecycle_*` facts, but those facts have no admission meaning and never use `qualified_positive_*`. Complete total-cost support requires independently attributable verified Authoring, Runtime, State, Recovery, maintenance, test, process, introduction, adoption and migration evidence. The current v2 implementation has no independent formal-cost evidence ingestion and admits no self-attested `verified` row; any missing, unverified or unadmitted category forces `total_roi_supported=false` and forbids `total_roi_positive=true`. Machine measurement and independent governance admission remain separate, and schema changes require a new version or an explicit tested compatibility reader that preserves missing evidence.
+The exact current schema matrix is accounting-policy, evidence-packet, precollection-plan, raw-event, scenario-catalog and source-manifest v2; Provider event v3; real-process v5; and run-set manifest v2. Provider-event v1-v2, the other listed formal v1 schemas, real-process v1-v4 and manifest v1 require recollection; `next` is unassigned.
+
+Formal collection prelocks one fixed eleven-scenario catalog as the sole source/zero-policy owner; collectors declare capabilities only and sources are only `required|forbidden`. Human time comes from a runner interaction recorder, compute from the complete Job-contained process tree, State from an exact runner payload/ledger plus prefrozen retention, and Provider usage from invocation-bound Provider correlation. A module-private-branded acquisition runtime constructs those owners and rejects missing sources, sampling/default-zero proxies, ordinary-spawn fallback and stream overflow. Every event binds a unique raw output and the scenario gold comparison remains verifier-owned. Provider acquisition now captures the exact prompt in the parent and launches only the candidate-owned isolated Node worker through a sanitized, runtime-TCB-v2-bound envelope. The worker alone owns `node:https`, bounded response streaming and the fixed parser; protocol-owned request/response/stdout/stderr/deadline/abort/output-token limits and complete temporary-root cleanup fail closed. The event binds response digest plus parser/worker identities without claiming an independent reparse of unretained response bytes. Provider readiness means only that local configuration, credential presence and launch support permit one controlled attempt.
+
+The catalog derives 86 executions and 586 formal artifacts. Formal capacity is 650 files/364.625 MiB and complete run-set capacity is 4,379 files/974.3125 MiB. The Evidence Candidate freezes every code/schema/Context/test/package-version/protocol byte. Its Promotion Commit must be the direct child, add only four fixed package-/TCB-external governance records and preserve materialized-package, benchmark and runtime/TCB identities. Real collection is `external_pending` until authorized original/sanitized incident provenance, invocation-bound Provider/price evidence and a State-retention Source exist; synthetic fixtures cannot promote Level 3. Package 0.8.15 is the historical frozen Evidence Candidate identity. Package 0.8.17 is the current Level-3 package candidate, inherits none of that evidence, production-checks the finite benchmark local-dependency closure—including `npm_command_spec.mjs`, the Provider protocol/worker sources and the Promotion commit-boundary owner—and requires collection/Promotion verifier execution from the exact repository checkout. This completes the scoped Level-4 mechanism logic only: capability remains Level 3, `level_4_claimed=false`, no formal-positive or Promotion exists, public `independent_evidence_admitted` means packet structure/source binding only, and complete/positive ROI remain owned by `total_roi_supported`/`total_roi_positive`.
 
 The mechanism's own Final-Gate Oracle consumes fixed-test-ID machine reports and compares complete wrong-candidate and correct-control workflow statuses. Runtime capability requires `wrong candidate != machine_accepted` and `correct candidate == machine_accepted` through the real lifecycle; command exit plus token/string presence proves documentation consistency only. A separate ROI verifier never contributes to a safety Fact verdict.
 
@@ -390,22 +412,22 @@ The first successful Compile creates Authority Lock and returns:
     "required": true,
     "phase": "post_authority_lock_pre_implementation",
     "action": "change_model_in_host_then_continue",
-    "resume_token": "continue",
+    "resume_token": "model checkpoint cleared, continue",
     "turn_boundary": "end_current_turn",
     "blocked_until_resume": ["product_implementation", "file_edits", "build", "test_execution"],
     "model_change_owner": "host_or_user",
     "model_change_observable_by_harness": false,
-    "generic_continue_satisfies": true,
-    "message": "After handling the model change, send [continue]."
+    "generic_continue_satisfies": false,
+    "message": "After handling the model change, reply exactly: model checkpoint cleared, continue."
   }
 }
 ```
 
-This is an unconditional terminal-turn boundary. The Agent performs no product implementation, file edit, build or test after that result, says `After handling the model change, send [continue].` and ends the turn. Earlier model wording never skips the boundary; a later ordinary `continue` resumes execution, while Harness neither observes nor verifies whether the host model changed. Later Compile revisions return `{ "required": false }` and do not repeat it.
+This is an unconditional terminal-turn boundary. The Agent performs no product implementation, file edit, build or test after that result, says `After handling the model change, reply exactly: model checkpoint cleared, continue` and ends the turn. Earlier model wording never skips the boundary and a generic continuation does not satisfy the package-managed prompt protocol. Harness observes neither the next host message nor whether the model changed, so this remains manual host guidance rather than a machine-enforced unlock. Later Compile revisions return `{ "required": false }` and do not repeat it.
 
-Harness cannot switch the host-selected model. It creates no checkpoint file, acknowledgement state, model route, model-tier scheduler or automatic model switch. The checkpoint is a one-time host affordance enabled by locked Authority and Final Gate protection; it is not acceptance evidence. Once resumed, the parent judges Delegation Suitability and proactively uses the fixed worker for independent bounded work whose benefit exceeds coordination cost; multiple disjoint instances are allowed, while the parent retains every authority, integration and formal-verification responsibility.
+Harness cannot switch the host-selected model. It creates no checkpoint file, acknowledgement state, model route, model-tier scheduler or automatic model switch. The checkpoint is a one-time host affordance enabled by locked Authority and Final Gate protection; it is not acceptance evidence. Once resumed, the parent applies the Skill's packet-first positive-default rule: a qualifying set requires actual calls for multiple exact `long_task_implementation` workers, while host results determine zero-start or partial fallback. Count remains dynamic, and the parent retains every authority, architecture, Context, integration, current-candidate check, formal-verification, Final-Gate, close and completion responsibility.
 
-Post-lock revisions separate authority change from user decision while retaining exact identity, old-Authority continuity, compare-and-swap adoption, evidence invalidation and the complete Final Gate. Formally monotonic strengthening; raw Source/Context snapshot changes with unchanged locked Claims/targets/proof obligations; operational Runner/input/environment repair; repository-bound scope expansion; risk strengthening; and equivalent Counterfactual coverage with the same carrier, mutation and Check and no lost Claim/assertion-failure coverage auto-adopt. Product/Source Claim/target/external-confirmation changes, lost scenario/Claim/Evidence Capability/failure interception, forbidden or owner-Context removal, runner type/effect changes, verifier-kernel changes and unknown reasons are preview-only and require the exact revision identity; risk downgrade is rejected. `diagnose-revision` remains side-effect-free and can exercise eligible scope candidates, so withdrawn/replaced candidates coalesce in the same `delivery-contract.yaml` and never ask. The final pending decision begins with a plain-language Authority Revision introduction and separates `user_decision_reasons` from mechanically bounded changes. Present it first. An explicit current-task instruction that exactly covers every listed decision reason may be mechanically relayed without a second question; generic continue, blanket approval, recommendation or Agent inference does not count. Exact identity, previous-Authority continuity, evidence invalidation and the complete Final Gate apply to every adoption, which reports `delivery_completed_by_this_event: false`, returns to rolling implementation or repair and never means delivery completion.
+Post-lock revisions separate authority change from user decision while retaining exact identity, old-Authority continuity, compare-and-swap adoption, evidence invalidation and the complete Final Gate. Formally monotonic strengthening; raw Source/Context snapshot changes with unchanged locked Claims/targets/proof obligations; operational Runner/input/environment repair; repository-bound scope expansion; risk strengthening; and equivalent Counterfactual coverage with the same carrier, mutation and Check and no lost Claim/assertion-failure coverage auto-adopt. Product/Source Claim/target/external-confirmation changes, lost scenario/Claim/Evidence Capability/failure interception, forbidden or owner-Context removal, runner type/effect changes, verifier-kernel changes and unknown reasons are preview-only and require the exact revision identity; risk downgrade is rejected. A verifier-content identity change invalidates prior evidence and remains fail-closed when semantic preservation lacks independent previous-Authority or trusted release proof, but the digest delta alone is not reported as a concrete acceptance/proof reduction; the brief names changed verifier files and the unproven-preservation boundary. `diagnose-revision` remains side-effect-free and can exercise eligible scope candidates, so withdrawn/replaced candidates coalesce in the same `delivery-contract.yaml` and never ask. The final pending decision begins with a plain-language Authority Revision introduction and separates `user_decision_reasons` from mechanically bounded changes. Present it first. An explicit current-task instruction that exactly covers every listed decision reason may be mechanically relayed without a second question; generic continue, blanket approval, recommendation or Agent inference does not count. Exact identity, previous-Authority continuity, evidence invalidation and the complete Final Gate apply to every adoption, which reports `delivery_completed_by_this_event: false`, returns to rolling implementation or repair and never means delivery completion.
 
 ```text
 ty-context long-task init <workdir>
@@ -474,6 +496,7 @@ npm run typecheck --workspace project-tiny-context-harness
 npm run build --workspace project-tiny-context-harness
 npm run test:affected:list
 npm run test:affected
+npm run verify:active-source-portability
 npm run test:long-task:trust
 npm run test:long-task-performance --workspace project-tiny-context-harness
 npm test
@@ -486,9 +509,11 @@ make validate-harness
 
 `test:affected` is the edit/fix loop. In inferred local discovery it reports and omits only untracked `.work_products/**`; tracked and explicit paths still route fail safe. `test:long-task:trust` is the frozen-candidate high-impact boundary gate used by pull-request CI. Reviewed Trust/focused/hotspot budgets prevent silent feedback-tier growth, while complete discovery remains exhaustive. `npm test` is the complete release regression retained on `main` and publish; do not rerun it after every small repair. Controlled Ubuntu CI uses generous per-suite catastrophic time ceilings, but local timing stays diagnostic. Explicit delivery-contract and complete Long-Task gates remain available as package workspace scripts.
 
+`verify:active-source-portability` scans only declared current owners: managed guidance/assets, public executable docs, durable Context, source mappings and runtime-resolved Source. Add a current delivery file with `-- --active-source <repository-relative-file>`. It rejects real machine user-home locators without enumerating all Git files, rewriting frozen Contracts/Receipts/fixtures or deleting anything.
+
 The modularity gate is the capability-aware `ty-context check-modularity`. Scoped waivers require `owner`, `introduced_at`, `reason`, `tracking_issue` and `expiry_condition`; unsupported metrics never appear as passing zeroes.
 
-The synchronized local preview tarball is named `project-tiny-context-harness-0.8.13.tgz`.
+The synchronized local preview tarball is named `project-tiny-context-harness-0.8.17.tgz`.
 
 ## Community And Further Reading
 
@@ -507,7 +532,7 @@ For concrete examples, see the [fresh-agent recovery walkthrough](https://github
 
 ## Honest Limits
 
-Tiny Context does not create or restore a platform Goal, prove that every requirement was declared, guarantee bounded keyword search finds every synonym or indirect dependency, switch the host-selected model, provide a parallel mutation/delegation runtime, observe platform tokens/model calls, or own Git/PR/CI/deployment/human product confirmation. The default Workflow provides model-led, evidence-bounded conformance, not exact declared-scope zero-drift proof or machine completion authority; unverified and externally pending scope must remain explicit. A platform Goal may use opaque implementation delegation, but Harness does not persist or accept it as evidence. The installed package verifier and Git metadata are trusted; external platforms own network isolation, and deliberate same-user/admin tampering remains outside the local threat model.
+Tiny Context does not create or restore a platform Goal, prove that every requirement was declared, guarantee bounded keyword search finds every synonym or indirect dependency, switch the host-selected model, provide a parallel mutation/delegation runtime, observe platform tokens/model calls, or own Git/PR/CI/deployment/human product confirmation. The default Workflow provides model-led, evidence-bounded conformance, not exact declared-scope zero-drift proof or machine completion authority; unverified and externally pending scope must remain explicit. When the package-managed Skill's bounded predicate holds, the platform Goal must make actual host calls for multiple exact `long_task_implementation` workers; Harness never allocates, persists or treats that dispatch as evidence. The installed package verifier and Git metadata are trusted; external platforms own network isolation, and deliberate same-user/admin tampering remains outside the local threat model.
 
 ## License