project-tiny-context-harness 0.8.17 → 0.11.0

package/assets/runtime/windows-job-supervisor/formal_process_supervisor_native_types.cs

@@ -0,0 +1,215 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public sealed class FormalProcessSupervisorResult
+{
+    public string RequestId { get; set; }
+    public int ProcessId { get; set; }
+    public int ExitCode { get; set; }
+    public bool TimedOut { get; set; }
+    public bool OutputOverflow { get; set; }
+    public bool DescendantsCleaned { get; set; }
+    public long StdoutBytes { get; set; }
+    public long StderrBytes { get; set; }
+    public long StartedUnixMs { get; set; }
+    public long CompletedUnixMs { get; set; }
+    public string MonotonicStartedNs { get; set; }
+    public string MonotonicCompletedNs { get; set; }
+    public string MonotonicClockId { get; set; }
+    public string WallClockId { get; set; }
+    public long UserCpu100Ns { get; set; }
+    public long KernelCpu100Ns { get; set; }
+    public long TotalCpu100Ns { get; set; }
+    public uint TotalProcesses { get; set; }
+    public uint ActiveProcessesAtResult { get; set; }
+    public uint TotalTerminatedProcesses { get; set; }
+    public string AccountingSourceKind { get; set; }
+    public string Error { get; set; }
+}
+
+public static partial class FormalProcessSupervisor
+{
+    private const uint CREATE_SUSPENDED = 0x00000004;
+    private const uint CREATE_NO_WINDOW = 0x08000000;
+    private const uint CREATE_UNICODE_ENVIRONMENT = 0x00000400;
+    private const uint STARTF_USESTDHANDLES = 0x00000100;
+    private const uint HANDLE_FLAG_INHERIT = 0x00000001;
+    private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    private const int JobObjectBasicAccountingInformation = 1;
+    private const int JobObjectExtendedLimitInformation = 9;
+    private const uint STILL_ACTIVE = 259;
+    private const int CleanupWaitMilliseconds = 5000;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct SECURITY_ATTRIBUTES
+    {
+        public int nLength;
+        public IntPtr lpSecurityDescriptor;
+        [MarshalAs(UnmanagedType.Bool)] public bool bInheritHandle;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct STARTUPINFO
+    {
+        public int cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public uint dwX;
+        public uint dwY;
+        public uint dwXSize;
+        public uint dwYSize;
+        public uint dwXCountChars;
+        public uint dwYCountChars;
+        public uint dwFillAttribute;
+        public uint dwFlags;
+        public short wShowWindow;
+        public short cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct PROCESS_INFORMATION
+    {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public uint dwProcessId;
+        public uint dwThreadId;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct JOBOBJECT_BASIC_LIMIT_INFORMATION
+    {
+        public long PerProcessUserTimeLimit;
+        public long PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint PriorityClass;
+        public uint SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct IO_COUNTERS
+    {
+        public ulong ReadOperationCount;
+        public ulong WriteOperationCount;
+        public ulong OtherOperationCount;
+        public ulong ReadTransferCount;
+        public ulong WriteTransferCount;
+        public ulong OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+    {
+        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+        public IO_COUNTERS IoInfo;
+        public UIntPtr ProcessMemoryLimit;
+        public UIntPtr JobMemoryLimit;
+        public UIntPtr PeakProcessMemoryUsed;
+        public UIntPtr PeakJobMemoryUsed;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
+    {
+        public long TotalUserTime;
+        public long TotalKernelTime;
+        public long ThisPeriodTotalUserTime;
+        public long ThisPeriodTotalKernelTime;
+        public uint TotalPageFaultCount;
+        public uint TotalProcesses;
+        public uint ActiveProcesses;
+        public uint TotalTerminatedProcesses;
+    }
+
+    private sealed class CaptureState
+    {
+        public long CombinedBytes;
+        public int Overflow;
+        public long Limit;
+        public IntPtr Job;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool SetInformationJobObject(
+        IntPtr job,
+        int informationClass,
+        ref JOBOBJECT_EXTENDED_LIMIT_INFORMATION information,
+        uint informationLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool QueryInformationJobObject(
+        IntPtr job,
+        int informationClass,
+        out JOBOBJECT_BASIC_ACCOUNTING_INFORMATION information,
+        uint informationLength,
+        IntPtr returnLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool TerminateJobObject(IntPtr job, uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CreatePipe(
+        out IntPtr readPipe,
+        out IntPtr writePipe,
+        ref SECURITY_ATTRIBUTES attributes,
+        uint size);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool SetHandleInformation(
+        IntPtr handle,
+        uint mask,
+        uint flags);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CreateProcessW(
+        string applicationName,
+        StringBuilder commandLine,
+        IntPtr processAttributes,
+        IntPtr threadAttributes,
+        [MarshalAs(UnmanagedType.Bool)] bool inheritHandles,
+        uint creationFlags,
+        IntPtr environment,
+        string currentDirectory,
+        ref STARTUPINFO startupInfo,
+        out PROCESS_INFORMATION processInformation);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern uint ResumeThread(IntPtr thread);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool TerminateProcess(IntPtr process, uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CloseHandle(IntPtr handle);
+}

package/assets/runtime/windows-job-supervisor/windows_job_process_supervisor.ps1

@@ -0,0 +1,117 @@
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$utf8 = New-Object System.Text.UTF8Encoding($false)
+[Console]::InputEncoding = $utf8
+[Console]::OutputEncoding = $utf8
+
+if ([System.Environment]::OSVersion.Platform -ne [System.PlatformID]::Win32NT) {
+    throw 'formal_process_supervisor_platform_unsupported'
+}
+
+$nativeSources = @(
+    Join-Path $PSScriptRoot 'formal_process_supervisor_native_types.cs'
+    Join-Path $PSScriptRoot 'formal_process_supervisor_native_run.cs'
+    Join-Path $PSScriptRoot 'formal_process_supervisor_native_helpers.cs'
+)
+Add-Type -Path $nativeSources
+
+function Get-ExactProperty {
+    param(
+        [Parameter(Mandatory = $true)] [object] $Object,
+        [Parameter(Mandatory = $true)] [string] $Name
+    )
+    $matches = @($Object.PSObject.Properties | Where-Object { $_.Name -ceq $Name })
+    if ($matches.Count -ne 1) { throw 'formal_process_supervisor_request_shape' }
+    return $matches[0]
+}
+
+while (($line = [Console]::In.ReadLine()) -ne $null) {
+    if ([string]::IsNullOrWhiteSpace($line)) { continue }
+    $request = $null
+    $requestId = $null
+    $requestStage = 'json'
+    try {
+        [FormalProcessSupervisor]::AssertUniqueJsonObjectKeys($line)
+        $request = $line | ConvertFrom-Json
+        if ($null -eq $request -or $request -is [System.Array] -or $request -is [string]) {
+            throw 'formal_process_supervisor_request_shape'
+        }
+        $expected = @('schema_version', 'request_id', 'executable', 'argv', 'cwd', 'stdout_path', 'stderr_path', 'timeout_ms', 'combined_output_limit_bytes', 'environment')
+        $actual = @($request.PSObject.Properties | ForEach-Object { $_.Name } | Sort-Object)
+        $requestStage = 'fields'
+        if (@(Compare-Object ($expected | Sort-Object) $actual -CaseSensitive).Count -ne 0) {
+            throw 'formal_process_supervisor_request_shape'
+        }
+        $requestStage = 'properties'
+        $schemaVersion = (Get-ExactProperty $request 'schema_version').Value
+        $requestId = (Get-ExactProperty $request 'request_id').Value
+        $executable = (Get-ExactProperty $request 'executable').Value
+        $argv = (Get-ExactProperty $request 'argv').Value
+        $cwd = (Get-ExactProperty $request 'cwd').Value
+        $stdoutPath = (Get-ExactProperty $request 'stdout_path').Value
+        $stderrPath = (Get-ExactProperty $request 'stderr_path').Value
+        $timeoutMs = (Get-ExactProperty $request 'timeout_ms').Value
+        $combinedOutputLimit = (Get-ExactProperty $request 'combined_output_limit_bytes').Value
+        $environmentObject = (Get-ExactProperty $request 'environment').Value
+        $requestStage = 'values'
+        if ($schemaVersion -isnot [string] -or $schemaVersion -cne 'formal-process-supervisor-request-v1' -or
+            $requestId -isnot [string] -or $executable -isnot [string] -or $cwd -isnot [string] -or
+            $stdoutPath -isnot [string] -or $stderrPath -isnot [string] -or
+            $argv -isnot [System.Array] -or
+            (($timeoutMs -isnot [int]) -and ($timeoutMs -isnot [long])) -or
+            (($combinedOutputLimit -isnot [int]) -and ($combinedOutputLimit -isnot [long])) -or
+            $null -eq $environmentObject -or $environmentObject -is [System.Array] -or $environmentObject -is [string]) {
+            throw 'formal_process_supervisor_request_shape'
+        }
+        foreach ($argument in $argv) {
+            if ($argument -isnot [string]) { throw 'formal_process_supervisor_request_shape' }
+        }
+        $requestStage = 'environment'
+        $seenEnvironment = @{}
+        $environment = @(
+            $environmentObject.PSObject.Properties |
+                Sort-Object Name |
+                ForEach-Object {
+                    $environmentName = [string]$_.Name
+                    if ($seenEnvironment.ContainsKey($environmentName)) {
+                        throw ('formal_process_supervisor_request_shape:environment_duplicate:{0}' -f $environmentName)
+                    }
+                    if ([string]::IsNullOrEmpty($environmentName) -or
+                        $environmentName.IndexOf([char]61) -ge 0 -or
+                        $environmentName.IndexOf([char]0) -ge 0 -or
+                        $environmentName.IndexOf([char]13) -ge 0 -or
+                        $environmentName.IndexOf([char]10) -ge 0) {
+                        throw ('formal_process_supervisor_request_shape:environment_name:{0}' -f $environmentName)
+                    }
+                    if ($_.Value -isnot [string]) {
+                        throw ('formal_process_supervisor_request_shape:environment_value:{0}:{1}' -f $environmentName, $_.Value.GetType().FullName)
+                    }
+                    $seenEnvironment[$environmentName] = $true
+                    '{0}={1}' -f $environmentName, $_.Value
+                }
+        )
+        $requestStage = 'native_run'
+        $result = [FormalProcessSupervisor]::Run(
+            [string]$requestId,
+            [string]$executable,
+            [string[]]$argv,
+            [string]$cwd,
+            [string]$stdoutPath,
+            [string]$stderrPath,
+            [int]$timeoutMs,
+            [long]$combinedOutputLimit,
+            [string[]]$environment
+        )
+        [Console]::Out.WriteLine(($result | ConvertTo-Json -Compress -Depth 8))
+        [Console]::Out.Flush()
+    }
+    catch {
+        $failure = [ordered]@{
+            RequestId = if ($requestId -is [string]) { [string]$requestId } else { $null }
+            Error = '{0}:{1}' -f $requestStage, [string]$_.Exception.Message
+        }
+        [Console]::Out.WriteLine(($failure | ConvertTo-Json -Compress))
+        [Console]::Out.Flush()
+    }
+}

package/assets/skills/design-resource-authoring/SKILL.md

@@ -12,6 +12,7 @@ Commission the smallest sufficient resource set for the user's explicit output/d
 - A raw proposal, plan, brief, screenshot or existing resource is valid input. Never require or create a special intermediary planning format, and never rewrite caller-owned Source except for the one explicitly selected proposal reconciliation.
 - The explicit output/development scope is a hard ceiling. Necessary surrounding context may orient the slice but cannot expand it. Report an outside-ceiling effect as existing `decision-required` with reason `scope-expansion-required`; only explicit user expansion changes the ceiling.
 - Candidates are ordinary external Source. They do not select themselves, become `exact-target`, update `DESIGN.md`/Context or prove implementation acceptance.
+- A selected task design does not update the project design system. DRA may emit only the non-authoritative Authority Delta Assessment; it never invokes Design System Authoring, selects a system candidate or adopts Authority.
 - Keep candidate effects in a task-local buffer. Only after explicit selection or explicitly delegated selection may accepted decisions be reconciled once and idempotently into the initial proposal; never write rejected/unresolved meaning as accepted.
 - Never mutate `project_context/**`, `DESIGN.md`, a Delivery Contract, production code or tests as a resource-authoring side effect.
 - Do not require a prototype, fidelity pair, provider-native file, fixed directory, variant count, resource pack or one artifact per control. Reuse selected component families and group repeated controls.
@@ -26,8 +27,9 @@ Commission the smallest sufficient resource set for the user's explicit output/d
 1. Always read [resource-selection.md](references/resource-selection.md) to fix the scope ceiling, authoritative product/surface inputs, intent, input roles, style dependency and minimum commission.
 2. Read [open-design-provider.md](references/open-design-provider.md) only before live capability discovery, provider execution, Design Authority binding, source acquisition or recovery.
 3. Read [downstream-handoff.md](references/downstream-handoff.md) only when selection, proposal reconciliation or downstream handoff is material. A simple unselected preview may stop without it.
-4. Read [implementation-feasibility.md](references/implementation-feasibility.md) before commissioning or publishing a Web/App implementation handoff against a real repository substrate. Reference-only and non-implementation resources never load it.
-5. Read [formal-selected-web-app-handoff.md](references/formal-selected-web-app-handoff.md) completely only for an explicitly final selected Web/App implementation handoff. Exploration, unselected previews, reference-only resources and non-Web/App commissions never load this reference.
+4. Read [authority-delta-assessment.md](references/authority-delta-assessment.md) after task-direction selection whenever a downstream handoff is being prepared. It owns the lightweight post-DRA system-delta judgment and explicit DSA stop.
+5. Read [implementation-feasibility.md](references/implementation-feasibility.md) before commissioning or publishing a Web/App implementation handoff against a real repository substrate. Reference-only and non-implementation resources never load it.
+6. Read [formal-selected-web-app-handoff.md](references/formal-selected-web-app-handoff.md) completely only for an explicitly final selected Web/App implementation handoff. Exploration, unselected previews, reference-only resources and non-Web/App commissions never load this reference.
 
 For simple-preview overhead accounting, the requested preview is neither additional Provider generation nor an added tool action.
 
@@ -44,6 +46,7 @@ For simple-preview overhead accounting, the requested preview is neither additio
 7. Bind style-bearing provider work to the adopted design-system identity, send only the scoped product/resource commission and keep provider execution, model-selection verification, Artifact readiness, Design suitability, human selection and authority adoption distinct.
 8. Iterate within scope. Re-review applicable suitability checks after every material revision. A first render with no material Source, feasibility or suitability defect may be selected directly; never require a revision merely to satisfy process. Exploration returns a visible candidate after minimal sanity review. When direction review or selection is material, use the downstream owner's `Design Resource Review & Selection Stop`; it is not approval, acceptance, formal completeness or persistent state. Do not burden exploration with handoff schema, hashes, complete Fact closure or downstream validation.
 9. After direction selection, preserve canonical immutable identity and editable-upstream provenance. For a selected formal Web/App handoff, complete the formal reference's closure first and return to the review stop if it exposes a new visible decision. Reconcile accepted proposal effects once only after stable formal closure; non-formal small requests retain their one-turn option.
+10. Before downstream handoff, perform the reference-owned Authority Delta Assessment against the complete current Design Authority closure. `consistent_with_current_authority` continues without DSA; a task-only variance declares forbidden precedent; a reusable local variance requires its durable owner decision; an `authority_delta_candidate` returns a non-authoritative packet and stops for a separate explicit `$design-system-authoring` invocation. After adoption, rebind the handoff to the new closure identity and rerun affected validation.
 
 ## Conditional Design Authority stop
 
@@ -57,4 +60,4 @@ Style-bearing design resources require an adopted project design system. Explici
 
 Route durable system adoption/repair to `context_uiux_design`, surface responsibility to `context_surface_contract`, ordinary implementation to the default Workflow Contract/current Goal, and machine-assurance delivery to an explicitly selected/resumed `long-task-workflow`.
 
-Report intent-sized results: scope/context/exclusions, style gate, input roles, resource dispositions, provider/binding status, visible artifacts/locators, selection basis, immutable/editable provenance, limitations/decision gaps and proposal-reconciliation status. A formal handoff additionally reports exactly what its dedicated reference requires. Never call a failing, unresolved, incomplete or unselected result ready.
+Report intent-sized results: scope/context/exclusions, style gate, input roles, resource dispositions, provider/binding status, visible artifacts/locators, selection basis, immutable/editable provenance, limitations/decision gaps, proposal-reconciliation status and exactly one Authority Delta Assessment when a handoff is prepared. A formal handoff additionally reports exactly what its dedicated reference requires. Never call a failing, unresolved, incomplete or unselected result ready.

package/assets/skills/design-resource-authoring/references/authority-delta-assessment.md

@@ -0,0 +1,52 @@
+# Authority Delta Assessment
+
+Run this lightweight assessment only after the task resource direction is selected and, for a formal Web/App handoff, its selected-source closure is stable. It asks whether the selected task design changes durable Design Authority. It is neither Proposal–Resource reconciliation nor an acceptance/adoption Gate.
+
+## Bind the current Authority
+
+Read the complete current project Design Authority closure. A new style-bearing or mixed handoff binds the exact `repository-closure` identity: `format_version`, root `DESIGN.md`, optional `design_system/authority.manifest.json`, closure digest and human revision diagnostic. Bundle format additionally requires the exact body-leading `<!-- ty-context-design-authority-format: bundle-v1 -->` declaration; marker/manifest mismatch is invalid rather than legacy. Legacy omission is only backward compatibility for a true unmarked one-file project. Never compare revision alone.
+
+If the closure changed after resource selection, re-read it and reassess the selected task design. Do not reuse a stale assessment.
+
+## Exactly three assessments
+
+### `consistent_with_current_authority`
+
+Use only when concrete current tokens/components/rules cover the selected task design and `observed_variances` is empty. Cite exact token keys, component keys and local Authority rule anchors. This is evidence-backed Agent judgment, not machine acceptance, and it does not invoke Design System Authoring.
+
+### `task_local_variance`
+
+Use for a deliberate deviation that must not silently become a system rule.
+
+- A one-task deviation declares `durability: task_only` and `precedent: forbidden`. It may remain in the task handoff, creates no cross-task memory and is never reused as precedent.
+- A reusable local rule declares `durability: cross_task_candidate` and one required Screen Contract owner. Before handoff, the user must explicitly update that owner, explicitly start Design System Authoring for a system-level rule, or abandon the durable claim. DRA changes neither owner automatically.
+
+State scope, reason and affected current rule anchors. Do not accumulate ownerless exceptions.
+
+### `authority_delta_candidate`
+
+Use only when the selected task design proposes a reusable long-lived Token, component, pattern, motion or platform change. Produce a non-authoritative packet based on the exact current closure identity, with keyed proposed changes/rationales, supporting resource anchors and representative scenarios. At least one proposal and one representative scenario are required.
+
+DRA stops after producing the packet. Tell the user to explicitly invoke `$design-system-authoring` in `reconcile` mode. DRA never invokes it, selects a system candidate or adopts Authority.
+
+## Strict data boundary
+
+When a replayable assessment file is warranted, use the package `design-authority-delta-assessment-v1` JSON shape and validate it read-only:
+
+```text
+ty-context design-resource authority-delta validate <assessment.json> --json
+```
+
+The codec accepts only:
+
+- `consistent_with_current_authority` with concrete evidence and no variance;
+- `task_local_variance` with exactly one durability branch;
+- `authority_delta_candidate` with the complete proposed-change categories.
+
+It rejects `status`, `passed`, `selected`, `adopted`, `authority_updated` and unknown fields. Validation proves structural integrity and current base identity only. It performs no write, selection, DSA invocation, adoption or production conformance.
+
+## Handoff consequence
+
+For `consistent_with_current_authority` and a valid task-only variance, return the assessment with the normal DRA handoff. A cross-task candidate blocks an unqualified durable-memory claim until its owner decision closes. An Authority delta candidate blocks system-adoption claims and waits for explicit DSA; the selected task resource may continue only as a user-approved task-only variance or after adoption/rebinding.
+
+After a DSA adoption, bind the DRA handoff to the new complete closure identity and rerun affected preflight/resource verification before downstream handoff. Page/resource selection never implies system adoption.

package/assets/skills/design-resource-authoring/references/downstream-handoff.md

@@ -8,6 +8,8 @@ Generated resources remain ordinary external Source. Preserve enough identity an
 - **Selection:** explicit user/team choice, or explicit delegation with known criteria; it permits proposal reconciliation and selected-source preparation.
 - **Authority adoption:** later UI Authority Closure reconciles selected Source with surface/interaction Context and `DESIGN.md` and binds implementation/verification to declared conditions.
 
+Task-resource selection is not design-system adoption. Before downstream handoff, load the dedicated Authority Delta Assessment reference. DRA can classify the selected task design as current-system-consistent, a bounded local variance or a system-delta candidate; none of those classifications adopts Authority.
+
 This Skill may preserve an input already classified `exact-target`; it cannot promote its own candidate. Unknown coverage remains unknown. Resource hashes, provider success and previews establish neither selection nor production conformance.
 
 A selection binds the canonical selected-source digest, target identity, declared conditions and controlling Source/Design-Authority identity. Preview URLs, names, PNGs, export archives and wrappers are derived artifacts, not the selection identity. A derived artifact proved equivalent to that canonical source under the bound target/conditions preserves selection; a visible or semantic difference requires fresh Design suitability review and another user choice.
@@ -52,11 +54,13 @@ Exploration returns the visible candidate, scope, dispositions, obvious limitati
 
 A non-formal selected-source handoff preserves target/resource classification, conditions, immutable identity, editable-upstream route, coverage/limitations and proposal identity in a project-native location authorized by the user. It remains ordinary Source.
 
+Every prepared style-bearing or mixed handoff also binds the complete current project Design Authority closure, not only a human revision label or raw `DESIGN.md` digest. If a subordinate owner changes, the old handoff is stale even when revision text is unchanged. Legacy omission is backward compatibility only for a true one-file Authority.
+
 For an explicitly selected Web/App implementation handoff, stop here and read [implementation-feasibility.md](implementation-feasibility.md) followed by [formal-selected-web-app-handoff.md](formal-selected-web-app-handoff.md). UI symbolic V2 is explicit opt-in; V1 remains the default. Those references own the real-substrate feasibility Source, strict manifest-backed V1/symbolic V2, Census/Fact/method and bundle/preflight rules. If closure exposes a new visible decision, return here for suitability review and the Review & Selection Stop; only stable closure returns for the one Proposal reconciliation. Do not approximate formal rules from this lightweight reference.
 
 ## Downstream routing
 
-The default Workflow opens every affected selected `exact-target` or `constraint` plus current feasibility Source, routes design meaning through owning surface/Design Authority, selects an allowed implementation strategy during Architecture Deliberation, implements through the real production entry, runs applicable current-candidate checks, and reports blockers or unestablished conditions. It does not require machine-unique binding selection. When no reliable project-native check observes a production claim, report it as `Unverified`; preflight or model judgment cannot promote it. It does not rebuild a per-Fact proof ledger.
+The default Workflow opens every affected selected `exact-target` or `constraint` plus current feasibility Source, routes design meaning through owning surface/Design Authority, selects an allowed implementation strategy during Architecture Deliberation, implements through the real production entry, runs applicable current-candidate checks, and reports blockers or unestablished conditions. It does not infer system adoption from a selected task resource or require machine-unique binding selection. When no reliable project-native check observes a production claim, report it as `Unverified`; preflight or model judgment cannot promote it. It does not rebuild a per-Fact proof ledger.
 
 An active Long-Task uses its one Source/Contract/Authority/Final Gate lifecycle. Existing component bindings must uniquely derive an allowed realization for every candidate-bearing cell and must all be attributed back to an allowing candidate-bearing cell; shared bindings are attributed across the complete surface, not forced onto each target. A surface with empty component refs is admitted only by complete Source-aware activation when every target is all-blocker-only; standalone structure validation, candidate/mixed/legacy targets and fake component bindings remain strict failures. Every `file`/`path_glob` target and carrier, every `verified` carrier and every non-empty planned carrier must be a proven subset of an observed component or route root; partial or unknown containment fails. Exact `path#source-item-key` Claims carry selected planned-owner/required-realization decisions, while every blocker is either `decision_required` or an open/closed target-blocking External Confirmation over affected current-target Claims. An open confirmation may project only its externally blocked design Assertions from machine execution and reaches `blocked_external`, never `machine_accepted`; it does not mutate the Contract or create a second Gate. The resource handoff, feasibility document and controlling technical authority are Source and bind only through existing Contract surfaces; this Skill creates no Contract Draft, Outcome, Progress, Evidence, Receipt, Check result or Gate. Historical Provider, preflight, DRA-audit or project-check results never replace current-candidate evidence in the existing Final Gate.
 

package/assets/skills/design-system-authoring/SKILL.md

@@ -1,21 +1,23 @@
 ---
 name: design-system-authoring
-description: Use only when the user explicitly asks to initialize, generate, choose, adopt, replace or repair a project design system or design style with Open Design; asks for “初始化设计系统”, “生成设计系统”, “确定设计风格”, “采纳 Open Design 设计系统”, or explicitly invokes design-system-authoring in a Minimal Context Harness project. This cold-start capability never runs merely because DESIGN.md is missing, a project is new, another Skill needs visual style, or ordinary UI work begins.
+description: Use only when the user explicitly asks to bootstrap, revise, reconcile, choose, adopt, replace or repair a project design system or design style with Open Design; asks for “初始化设计系统”, “生成设计系统”, “确定设计风格”, “采纳 Open Design 设计系统”, explicitly promotes a DRA Authority delta candidate, or invokes design-system-authoring in a Minimal Context Harness project. This capability never runs merely because DESIGN.md is missing, a project is new, DRA found a candidate delta, another Skill needs visual style, or ordinary UI work begins.
 ---
 
 # Design System Authoring
 
-Generate or select an Open Design design system, obtain an explicit selection, and adopt that selection into the project's existing durable Design Authority. The user invokes this Skill at project cold start or later repair time; installation only makes it available.
+Bootstrap, revise or reconcile an Open Design design-system candidate, obtain an explicit selection, then require a separate explicit adoption confirmation before changing the project's durable Design Authority. Installation only makes the Skill available.
 
 ## Hard boundaries
 
 - Run only from an explicit user request. Never auto-run from `init`, `sync`, the default Workflow, `design-resource-authoring`, a missing/starter `DESIGN.md`, or a new-project inference.
+- A DRA `authority_delta_candidate` is non-authoritative input, not permission to invoke this Skill or adopt anything. The user must explicitly start `reconcile` mode.
 - A combined explicit user request to initialize the system and then generate resources authorizes that sequence; a resource gate alone does not.
 - Open Design owns generation, revision, previews and its catalogue. Use its live structured capabilities; do not copy its prompts, emulate its generator, vendor a catalogue or invent provider IDs.
-- Keep candidate generation, human/delegated selection and authority adoption distinct. A successful job or attractive preview is not selected and is not project authority.
-- Project `DESIGN.md` and its one declared authored exact-value token source or generation direction are canonical. An Open Design design-system record and project binding are provider synchronization, not a second authority.
+- Keep candidate generation, human/delegated selection, and the later explicit adoption confirmation distinct. A successful job, attractive preview, selected task resource or selected system candidate is not project authority.
+- Root `DESIGN.md` is the unique Authority entry and revision owner. In this bundle version its supported front matter remains the editable exact Token authority; `design_system/tokens.json` is deterministic generated output, and a sparse `design_system/authority.manifest.json` owns closure membership/digest only. Bundle adoption must insert the exact `<!-- ty-context-design-authority-format: bundle-v1 -->` line at the fixed first non-empty Markdown body position and create the manifest in the same adoption. None is a second independently editable Authority.
+- Create subordinate component/pattern/motion/platform owners only for real reusable durable rules. Never scaffold a mandatory full taxonomy.
 - Put durable surface, information-architecture and interaction facts in their owning `project_context/**`; put visual-system semantics, rationale, token direction and reference interpretation in `DESIGN.md`. Do not duplicate facts across owners.
-- Do not create a design registry, receipt, workflow state, Contract, acceptance gate or provider runtime inside Tiny Context.
+- Do not create a design registry, receipt, workflow state, Contract, acceptance gate or provider runtime inside Tiny Context. The package's local `@google/design.md` adapter and Authority codecs are deterministic lint/export/validation tools, not Open Design generation.
 - Do not persistently install/configure MCP, plugins, authentication or disclosure paths without separate authorization. Task-local use of an already available Open Design MCP/daemon is allowed.
 - Do not implement production UI or claim downstream fidelity, accessibility, product correctness or acceptance.
 
@@ -26,19 +28,21 @@ Generate or select an Open Design design system, obtain an explicit selection, a
 
 ## Core workflow
 
-1. **Confirm explicit intent and scope.** Identify whether the user wants a new system, selection from existing systems, repair, or replacement; capture the product/brand purpose, supported surface/platform, accessibility needs, required modes and supplied references. Ask only when an unresolved aesthetic or brand choice materially changes the candidates and the user has not delegated selection.
-2. **Inspect current authority.** Read core Context, relevant surface/interaction Context, `DESIGN.md`, its declared token source/generation direction and any recorded Open Design provenance. Classify the project as `unconfigured`, `configured`, or `configured-but-inconsistent`; this is a task-local finding, not new state.
-3. **Discover live Open Design capabilities.** Prefer structured MCP. List/read `od://design-systems/<id>/DESIGN.md`, inspect tool schemas, and feature-detect design-system creation/revision/acceptance plus project binding. Record the live provider/MCP version and any fallback used.
-4. **Reuse or generate candidates.** Reuse an existing provider system only when its identity and meaning fit. If a live MCP creation capability exists, use it. Otherwise use the official daemon generation-job API described in the provider reference. Keep every output a candidate until selection.
-5. **Review and iterate.** Inspect `DESIGN.md`, generated token files, preview/showcase and relevant workspace files. Use provider revision jobs for scoped feedback, poll boundedly, preserve diagnostics and keep pending revisions non-authoritative.
-6. **Obtain selection.** Require an explicit user/team selection, or an explicit instruction delegating selection with known criteria. Record the selection basis, provider design-system ID, selected revision when applicable and immutable content digest/snapshot. Reject or leave other candidates unselected.
-7. **Adopt once.** Reconcile the selected system through the authority-adoption procedure. Update root `DESIGN.md`, establish exactly one authored token source/generation direction, update only owning Context facts, and record provider provenance without making it authoritative.
-8. **Synchronize Open Design.** Accept the selected pending revision when applicable. Confirm MCP can read the adopted provider system. For later style-bearing resource work, create or verify an Open Design project with `create_project.designSystem` equal to the adopted provider ID.
-9. **Validate and report.** Run project-owned Context/design lint and source/package checks appropriate to the repository. Separately report provider execution, artifact readiness, selection, authority adoption, provider synchronization, verification and unresolved issues.
+1. **Confirm explicit mode and scope.** Use `bootstrap` for an unconfigured project, `revise` for an explicit current-system change, or `reconcile` for a user-promoted DRA Authority delta candidate. Capture product/brand purpose, supported surfaces/platforms, accessibility, modes, immutable constraints and supplied references. Ask only when an unresolved aesthetic or brand choice materially changes candidates and selection was not delegated.
+2. **Inspect the complete current authority.** Read core and relevant surface Context, root `DESIGN.md`, optional sparse manifest/subordinate owners, generated Tokens and provider provenance. Run read-only closure inspection. Classify `unconfigured`, `configured` or `configured-but-inconsistent` as a task-local finding, not state.
+3. **Validate reconcile input.** In `reconcile`, require the strict non-authoritative Authority Delta Assessment, validate that its `based_on` closure is still current, then use only its proposed changes, supporting resources, representative scenarios and immutable constraints. A stale packet returns to DRA reassessment.
+4. **Discover live Open Design capabilities.** Prefer structured MCP. List/read `od://design-systems/<id>/DESIGN.md`, inspect tool schemas, and feature-detect creation/revision/acceptance plus project binding. Record live provider/MCP version and fallback.
+5. **Reuse or generate candidates.** Reuse an existing provider system only when identity and meaning fit. Otherwise use a live structured creation/revision capability or the official daemon fallback. In `revise`/`reconcile`, generate bounded deltas against the current closure rather than an unrelated replacement. Keep every output a candidate.
+6. **Review representative scenarios and iterate.** Inspect candidate `DESIGN.md`, exact Token delta, sparse owner delta, preview/showcase and representative scenes. Preserve immutable constraints, migration impact, provider diagnostics and provenance. Pending revisions remain non-authoritative.
+7. **Obtain system-candidate selection.** Require explicit user/team selection, or explicit delegated selection with known criteria. Record basis, provider ID/revision and immutable digest/snapshot. Reject or leave other candidates unselected.
+8. **Stop for separate adoption confirmation.** Present the exact project-owner diff, migration impact, new/removed subordinate owners, generated Token change and affected DRA resources. Ask the user to explicitly confirm adoption of this selected system candidate. Candidate selection or an earlier page-resource approval does not satisfy this confirmation.
+9. **Adopt once after confirmation.** Follow the authority-adoption reference: update root `DESIGN.md`, insert/preserve the canonical body-leading `bundle-v1` marker, update only necessary sparse subordinate owners, deterministic generated Tokens, closure-only manifest/digest, owning Context and provider provenance. Create or remove marker and manifest only as one explicit Authority-format change. Do not copy revision or Token values into the manifest.
+10. **Rebind and synchronize.** Calculate the new complete closure identity. Rebind affected DRA resources/handoffs to it and rerun affected preflight/representative verification. Accept the selected provider revision when applicable, confirm it is readable, and verify downstream provider project binding.
+11. **Validate and report.** Run project-owned closure, Token, Context/design lint, source/package and affected DRA checks. Separately report mode, provider execution, artifact readiness, selection, explicit adoption confirmation, changed owners, old/new closure identities, rebinding, provider synchronization, verification and unresolved issues.
 
 ## Readiness classification
 
-Treat Design Authority as unconfigured when `DESIGN.md` is absent, explicitly says `Design authority status: unconfigured`, remains an unedited starter, contains only style adjectives/inspiration, or lacks one authored exact-value token source/generation direction. A configured visual system still does not make every surface implementation-ready; selected exact/constraint targets and declared coverage remain separate.
+Treat Design Authority as unconfigured when `DESIGN.md` is absent, explicitly says `Design authority status: unconfigured`, remains an unedited starter, contains only style adjectives/inspiration, or lacks supported authored exact Token values. A configured visual system still does not make every surface implementation-ready; selected exact/constraint targets and declared coverage remain separate.
 
 If authority is already configured and the user did not ask to replace or repair it, prefer reuse and explain the current system. Never generate a competing system as filler.
 
@@ -47,10 +51,12 @@ If authority is already configured and the user did not ask to replace or repair
 Report:
 
 - requested operation and design-system scope;
+- `bootstrap`, `revise` or `reconcile` mode and the exact base closure identity;
 - Open Design transport/version and capabilities actually used;
 - candidate IDs and review performed;
-- explicit or delegated selection basis;
-- adopted `DESIGN.md`, token source and Context owners changed;
+- explicit or delegated selection basis and separate adoption confirmation;
+- adopted `DESIGN.md`, sparse subordinate owners, generated Tokens, manifest and Context owners changed;
+- new closure identity and affected DRA rebinding/revalidation;
 - provider ID, revision/digest and project-binding verification;
 - validations run, limitations and decisions still required.