@starci/skills 1.1.0

package/operators/frontend-direction-decide/validate.mjs

@@ -0,0 +1,146 @@
+// frontend.direction.decide's own law over one branch, on top of the shared step check: the intent and the
+// change level agree; the selection policy and the approval agree; the receipt names exactly one
+// selected candidate, falsifies every candidate it formed, and rejects the others by name; a refine
+// forms no structural candidate and consults no external reference; more than one candidate is
+// rendered; and COVERAGE-1 holds, meaning the coverage enumerates every action, region, state and
+// responsive branch the UI contract declares.
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { validateStep } from '../../scripts/validate-step.mjs';
+import { tableUnder } from '../../scripts/validate-response.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const empty = (v) => v === undefined || v === null || v === '' || v === '—';
+const list = (v) => (Array.isArray(v) ? v : empty(v) ? [] : [v]);
+
+// COVERAGE-1 (knowledge/ui/composition): a decided direction enumerates what a later operator has to
+// exercise. Every element the UI contract declares is covered, every pending path settles, every
+// meaning has its own carrier, and every responsive branch has one owner.
+export function coverageErrors(coverage, declared, at) {
+  const errors = [];
+  const need = (kind) => declared.filter((d) => d.kind === kind).map((d) => d.element);
+  const actions = need('action');
+  if (actions.length) {
+    if ((coverage.actions ?? []).length === 0) errors.push(`${at}: COVERAGE-1: actions must enumerate every declared action`);
+    const covered = (coverage.actions ?? []).map((a) => a.action);
+    for (const action of actions) if (!covered.includes(action)) errors.push(`${at}: COVERAGE-1: action is not covered: ${action}`);
+    for (const entry of coverage.actions ?? []) for (const p of entry.pendingPaths ?? []) if (!p.settlement) errors.push(`${at}: COVERAGE-1: pending path without a settlement: ${entry.action}`);
+  }
+  const regions = need('region');
+  if (regions.length) {
+    if ((coverage.regions ?? []).length === 0) errors.push(`${at}: COVERAGE-1: regions must enumerate every declared region`);
+    const covered = (coverage.regions ?? []).map((r) => r.region);
+    for (const region of regions) if (!covered.includes(region)) errors.push(`${at}: COVERAGE-1: region is not covered: ${region}`);
+    for (const region of covered) if (!regions.includes(region)) errors.push(`${at}: COVERAGE-1: coverage names a region the UI contract does not declare: ${region}`);
+  }
+  const states = need('state');
+  if (states.length) {
+    if ((coverage.states ?? []).length === 0) errors.push(`${at}: COVERAGE-1: states must enumerate every named meaning`);
+    const covered = (coverage.states ?? []).map((s) => s.meaning);
+    for (const state of states) if (!covered.includes(state)) errors.push(`${at}: COVERAGE-1: state is not covered: ${state}`);
+    const carriers = (coverage.states ?? []).map((s) => s.carrier);
+    if (new Set(carriers).size !== carriers.length) errors.push(`${at}: COVERAGE-1: two meanings share one carrier`);
+  }
+  const responsive = need('responsive');
+  if (responsive.length) {
+    if ((coverage.responsive ?? []).length === 0) errors.push(`${at}: COVERAGE-1: responsive must enumerate every responsive branch`);
+    const covered = (coverage.responsive ?? []).map((b) => b.branch);
+    for (const branch of responsive) if (!covered.includes(branch)) errors.push(`${at}: COVERAGE-1: responsive branch is not covered: ${branch}`);
+    if (new Set(covered).size !== covered.length) errors.push(`${at}: COVERAGE-1: a responsive branch is named twice, so it has more than one owner`);
+  }
+  return errors;
+}
+
+export async function validateDirectionStep(branchDir, root = ROOT) {
+  const base = await validateStep(root, branchDir);
+  const errors = [...base.errors];
+  const { response, requirements = {}, present = new Set() } = base;
+  if (!response || response.operatorId !== 'frontend.direction.decide') return { errors };
+  const has = (f) => existsSync(path.join(branchDir, f));
+  const read = (f) => readFile(path.join(branchDir, f), 'utf8');
+
+  const intent = requirements.intent ?? 'modify';
+  const changeLevel = requirements.changeLevel;
+  const candidates = Number(requirements.candidates ?? 1);
+  const preview = requirements.preview ?? 'no';
+  const policy = requirements.selectionPolicy ?? 'automatic';
+  const approval = empty(requirements.approval) ? null : requirements.approval;
+  const references = list(requirements.references);
+
+  if (intent === 'create' && changeLevel !== 'new') errors.push('request.json: intent create requires changeLevel new');
+  if (changeLevel === 'new' && intent !== 'create') errors.push('request.json: changeLevel new requires intent create');
+  if (!(candidates >= 1 && candidates <= 3)) errors.push(`request.json: candidates must be 1, 2 or 3, not ${requirements.candidates}`);
+  if (policy === 'automatic' && approval !== null) errors.push('request.json: approval is bound under automatic policy; supplying both hides which one decided');
+
+  const artifacts = new Set(list(response.fields?.candidates));
+  if (response.status === 'done') {
+    if (candidates > 1 && artifacts.size === 0) errors.push('response/response.json: more than one candidate was formed but none was rendered');
+    if (preview === 'yes' && artifacts.size === 0) errors.push('response/response.json: preview was asked for but no candidate page was rendered');
+    if (candidates === 1 && preview === 'no' && artifacts.size > 0) errors.push('response/response.json: one candidate under no preview renders no page');
+  }
+
+  let coverage = null;
+  if (present.has('ui-coverage') && has('response/data/coverage.json')) {
+    try { coverage = JSON.parse(await read('response/data/coverage.json')); } catch { coverage = null; }
+  } else if (response.status === 'done') errors.push('response/data/coverage.json: a done branch needs the coverage enumeration');
+
+  if (present.has('frontend-direction-decision') && has('response/response.md')) {
+    const text = await read('response/response.md');
+    const at = 'response/response.md';
+    const decision = Object.fromEntries((tableUnder(text, '## Decision') ?? []).map(([k, v]) => [k, v]));
+    if (!empty(requirements.target) && decision.Target !== requirements.target) errors.push(`${at}: Target differs from the request`);
+    if (decision.Intent !== intent) errors.push(`${at}: Intent ${decision.Intent} differs from the request's ${intent}`);
+    if (decision['Change level'] !== changeLevel) errors.push(`${at}: Change level ${decision['Change level']} differs from the request's ${changeLevel}`);
+    if (!empty(requirements.ownerCeiling) && decision['Owner ceiling'] !== requirements.ownerCeiling) errors.push(`${at}: Owner ceiling differs from the request`);
+    if (decision['Selection policy'] !== policy) errors.push(`${at}: Selection policy ${decision['Selection policy']} differs from the request's ${policy}`);
+    if (changeLevel === 'refine' && decision.Classification !== 'locked-refine') errors.push(`${at}: a refine is classified locked-refine, not ${decision.Classification}`);
+    if (changeLevel !== 'refine' && decision.Classification === 'locked-refine') errors.push(`${at}: locked-refine requires change level refine`);
+
+    // Exactly one candidate is selected, every candidate formed is falsified, and every candidate
+    // that was not selected is rejected by name.
+    const attacks = tableUnder(text, '## Falsification') ?? [];
+    const formed = new Set(attacks.map((r) => r[1]));
+    const rejected = new Set((tableUnder(text, '## Why not the others') ?? []).map((r) => r[0]));
+    const selected = decision['Selected candidate'];
+    if (response.status === 'done') {
+      if (empty(selected)) errors.push(`${at}: a decided direction names one selected candidate`);
+      else if (!formed.has(selected)) errors.push(`${at}: the selected candidate ${selected} carries no falsification row`);
+      if (formed.size !== candidates) errors.push(`${at}: Falsification covers ${formed.size} candidates, the request asked for ${candidates}`);
+      for (const candidate of formed) {
+        if (candidate === selected) continue;
+        if (!rejected.has(candidate)) errors.push(`${at}: candidate ${candidate} was not selected and is not rejected by name`);
+      }
+      if (rejected.has(selected)) errors.push(`${at}: the selected candidate ${selected} is also listed under Why not the others`);
+      for (const [, candidate, verdict] of attacks) {
+        if (candidate === selected && verdict === 'fails') errors.push(`${at}: the selected candidate ${selected} fails an attack, so the direction is not decided`);
+      }
+    }
+    if (policy === 'approval-required' && response.status === 'done') {
+      if (approval === null) errors.push('response/response.json: approval-required with no approval cannot end done; DIRECTION_CHOICE_REQUIRED terminates here');
+      else if (approval !== selected) errors.push(`${at}: the receipt selects ${selected} but approval names ${approval}`);
+    }
+
+    // A refine moves elements inside the approved structure and consults no external reference.
+    const refs = tableUnder(text, '## References') ?? [];
+    if (changeLevel === 'refine' && refs.length) errors.push(`${at}: a refine works from the family idioms alone, so References carries no row`);
+    if (references.length && refs.length === 0) errors.push(`${at}: the person supplied references and none of them is recorded`);
+    const contract = (tableUnder(text, '## UI contract') ?? []).map(([element, kind]) => ({ element, kind }));
+    if (coverage) {
+      errors.push(...coverageErrors(coverage, contract, 'response/data/coverage.json'));
+      if (!empty(decision['Direction id']) && coverage.directionId !== decision['Direction id']) {
+        errors.push(`response/data/coverage.json: directionId ${coverage.directionId} differs from the receipt's ${decision['Direction id']}`);
+      }
+    }
+  }
+  return { errors };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const target = process.argv[2];
+  if (!target) { process.stderr.write('usage: node validate.mjs <session>/step-N/parallel-M\n'); process.exit(2); }
+  const { errors } = await validateDirectionStep(path.resolve(target));
+  if (errors.length) { process.stderr.write(`${errors.join('\n')}\n`); process.exitCode = 1; } else process.stdout.write('valid frontend.direction.decide branch\n');
+}

package/operators/frontend-presentation-resolve/errors.json

@@ -0,0 +1,42 @@
+{
+  "schemaVersion": 9,
+  "note": "Stop codes frontend.presentation.resolve emits. Same entry shape as operators/errors.json, scope implicit. Shared codes (INVALID_INPUT, SOURCE_DRIFT, NO_PROGRESS) come from operators/errors.json. OWNER_CONFLICT and UNKNOWN_RULE are defined here and also emitted by frontend.source.apply and frontend.surface.audit; they belong in operators/errors.json with a scope list.",
+  "codes": {
+    "KNOWLEDGE_UNBOUND": {
+      "domain": "knowledge",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A presentation property is present in the tree and no knowledge topic is bound for it.",
+        "vi": "Một thuộc tính trình bày có trong cây mà không topic kiến thức nào được bind cho nó."
+      },
+      "resume": {
+        "en": "Bind the missing topic.",
+        "vi": "Bind topic còn thiếu."
+      }
+    },
+    "RULE_MISSING": {
+      "domain": "knowledge",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "No published case matches the observed condition on a node.",
+        "vi": "Không case nào đã publish khớp điều kiện quan sát được trên một node."
+      },
+      "resume": {
+        "en": "The knowledge owner publishes the case, and the tree is resolved again.",
+        "vi": "Chủ knowledge publish case, rồi cây được resolve lại."
+      }
+    },
+    "GRAMMAR_UNPUBLISHED": {
+      "domain": "grammar",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The Grammar package is unpublished or the bound fingerprint is stale.",
+        "vi": "Gói Grammar chưa publish hoặc fingerprint đã bind là cũ."
+      },
+      "resume": {
+        "en": "A person publishes the exact Grammar package.",
+        "vi": "Người publish đúng gói Grammar."
+      }
+    }
+  }
+}

package/operators/frontend-presentation-resolve/operator.json

@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 9,
+  "id": "frontend.presentation.resolve",
+  "domain": "frontend",
+  "job": "Resolve every application-owned presentation property on one already-composed tree to exactly one published rule, emit its class and verifiable contract claim, and stop at the smallest owning gap instead of inventing a value.",
+  "package": "operator.md",
+  "errors": "errors.json",
+  "validator": "validate.mjs",
+  "selfTest": "self-test.mjs",
+  "resources": {
+    "profile": "luna",
+    "grammarBound": true,
+    "tools": {
+      "@tools/fileread": "context-aliases",
+      "@tools/git": "read",
+      "@tools/registry": "read"
+    }
+  }
+}

package/operators/frontend-presentation-resolve/operator.md

@@ -0,0 +1,142 @@
+# frontend.presentation.resolve
+
+## Job
+
+Resolve every application-owned presentation property on one already-composed tree to exactly one
+published rule, emit its class and its verifiable contract claim, and stop at the smallest owning gap
+instead of inventing a value.
+
+## Structure arrives decided
+
+Structure, element order, Grammar component selection, copy, data and behaviour arrive decided, and
+so does the owner ceiling: it is carried by the direction this branch resolves, never re-declared
+here. This operator only answers, for each node the application owns, which value each presentation
+property takes and which rule authorizes it. It changes nothing about what the tree renders.
+
+## No fabricated rule
+
+A rule exists only if the bound knowledge topic publishes its identifier, and that inventory is
+frozen for the whole run. An emitted identifier absent from the inventory is `UNKNOWN_RULE`. A class
+that contradicts its identifier is rejected: the rule number is an ordinal on the value scale, so
+`GAP-5` renders `gap-6` and `PADDING-5` renders `p-6`, and writing the ordinal as the step is the
+defect this check exists to catch. When no published case matches the observed condition the run
+stops with `RULE_MISSING` naming that node; it does not choose a nearby value, round to the closest
+step, or copy a neighbouring node. The operator never edits knowledge: a missing case goes back to
+the knowledge owner, and the same tree is resolved again once the case is published.
+
+## Grammar is read as published, and consulted first
+
+The owned relationships come from the published package's own data-contract claims, never from
+Grammar source. A property a component already owns resolves to that component, emits no application
+class, and names the rule the component satisfies; that ordering makes reimplementation impossible
+rather than merely discouraged. An application class that reimplements an owned relationship,
+overrides Grammar anatomy or sits off the closed scale is removed with its own row, per node and
+never silently.
+
+## A forbidden class is removed, not ruled
+
+When the only case that names an application class states a condition the node does not meet (an
+accent foreground that `SURFACE-4` allows solely inside a raised band, written on an unraised row),
+the property is not missing a rule: the rule has answered, and the answer is no. The class is removed
+in the removal step, the property falls back to what the node inherits, and the removal is recorded
+with the case that refused it. `RULE_MISSING` is reserved for a property no published case addresses
+at all.
+
+## A missing public path is a gap, not a stop
+
+When Common exposes no public path for a relationship the application legitimately needs, the node
+keeps its application class and the branch records a row under `## Gaps` naming the node, the
+property and the missing path. The branch does not stop: a recorded workaround is visible to the
+family owner and to the next audit, while a stop here would only trade one silent value for a
+blocked chain.
+
+## The contract is a claim, not a verdict
+
+Every application-owned node publishes the identifiers it claims. `data-contract` records which
+rules a node claims to satisfy and never asserts that the node passes; the claim exists so a later
+audit can contradict it, and one rule stays selectable as `[data-contract~="GAP-4"]`. With emission
+off the tree carries nothing and the receipt alone holds the claims.
+
+## The loop is counted
+
+An audit that sends its findings back here starts another round, and a round that repeats itself is
+not progress. The number of audit receipts this session has fed back is counted at the gate, and a
+run beyond `maxRounds` stops with `NO_PROGRESS` rather than resolving the same tree a third time.
+
+## Boundary
+
+Context is read-only. The operator writes only `response/` of its own branch: the resolution receipt,
+the inventory and the resolved tree. It does not change DOM structure, element order, Grammar
+component selection, copy or behaviour, write a class for a property a Grammar component already
+owns, reach into Grammar anatomy with a selector or a passed class, edit knowledge, publish Grammar,
+write product source, or record a verdict, score or pass claim on any node.
+
+## Context
+
+| Alias | Bind | Required |
+| --- | --- | --- |
+| `@knowledge/ui/presentation` | the closed rule inventory read at its fingerprint; the only source of valid identifiers | yes |
+| `@grammar/core` | the published package's owned relationships, read as published and never from Grammar source | yes |
+| `@workspaces/fe` | the routed checkout the composed tree belongs to, read at the frozen head | yes |
+
+## Inputs
+
+| Kind | From | Required |
+| --- | --- | --- |
+| `frontend-direction-decision` | `frontend.direction.decide`, the intent and the owner ceiling this resolution works inside; never a source of presentation values | yes |
+| `frontend-surface-audit` | `frontend.surface.audit`, the findings that opened this round; present only when this is a loop | no |
+
+## Requirements
+
+| Field | Type | Default | Ask |
+| --- | --- | --- | --- |
+| `maxRounds` | number | 2 | How many audit-to-resolve rounds this surface may take before the loop is called off |
+| `contractEmission` | choice | on | `on` writes the claim token list onto the tree, `off` leaves the receipt as the record |
+| `resume` | token | null | The blocked branch's token when re-entering after a stop |
+
+## Steps
+
+| # | Step | Params | Reads | Writes | Stops with |
+| --- | --- | --- | --- | --- | --- |
+| 1 | Validate the gate and resume, and count the audit rounds | `resume`, `maxRounds` | `request/request.json`, input `frontend-surface-audit` when this is a loop, @workspaces/fe at the frozen head | — | `INVALID_INPUT`, `SOURCE_DRIFT`, `NO_PROGRESS` |
+| 2 | Bind the authority | — | @knowledge/ui/presentation (every topic with its fingerprint and rule inventory), @grammar/core (the published package's owned relationships), @workspaces/fe (the routed head and the frozen tree), input `frontend-direction-decision`, @tools/git, @tools/registry | — | `KNOWLEDGE_UNBOUND`, `GRAMMAR_UNPUBLISHED` |
+| 3 | Walk the tree once under the owner ceiling the direction carries | — | @workspaces/fe (the frozen tree, in document order), input `frontend-direction-decision` | — | `OWNER_CONFLICT` |
+| 4 | Determine the owner of every present property | — | @grammar/core (the owned relationships), @workspaces/fe (the properties the node presently carries) | `response/data/inventory.json` | — |
+| 5 | Select one presentation rule per remaining application-owned property | — | @knowledge/ui/presentation (the cases the bound topic publishes) | — | `RULE_MISSING` |
+| 6 | Classify a missing public path as a Grammar gap | — | @grammar/core (the relationship under question), @knowledge/ui/presentation (the capability-gap marking) | — | — |
+| 7 | Remove what the tree should not carry | — | @workspaces/fe (the application classes on the node), @grammar/core (Grammar anatomy and the closed scale) | — | — |
+| 8 | Emit the contract claims onto the application-owned nodes | `contractEmission` | @knowledge/ui/presentation (the frozen rule inventory) | — | `UNKNOWN_RULE` |
+| 9 | Emit | — | everything above | `response/artifacts/<target>.resolved.tsx`, `response/data/inventory.json`, `response/response.md`, `response/response.json` | — |
+
+The walk visits every node in document order and records a stable node path; a node outside the
+ceiling the direction carries is observed and never mutated. Steps 4 to 8 run per node, so a single
+tree yields one decision per node and property. The receipt authorizes a later audit to measure the
+rendered result against the claims; it proves nothing about how the tree renders.
+
+## Outputs
+
+| Kind | File | Type | Required |
+| --- | --- | --- | --- |
+| `frontend-presentation-resolution` | `response/response.md` | md | yes |
+| `inventory` | `response/data/inventory.json` | data | yes |
+| `resolved-tree` | `response/artifacts/<target>.resolved.tsx` | artifact | yes |
+
+## Stops
+
+| Code | Disposition |
+| --- | --- |
+| `INVALID_INPUT` | terminate |
+| `SOURCE_DRIFT` | terminate |
+| `OWNER_CONFLICT` | terminate |
+| `KNOWLEDGE_UNBOUND` | terminate |
+| `UNKNOWN_RULE` | terminate |
+| `RULE_MISSING` | terminate |
+| `GRAMMAR_UNPUBLISHED` | terminate |
+| `NO_PROGRESS` | terminate |
+
+## Next
+
+| When | Operator |
+| --- | --- |
+| the tree is resolved and its values must be written into product source | `frontend.source.apply` |
+| a gap needs a family component before the next round, so a person publishes it and the same tree is resolved again | `frontend.presentation.resolve` |

package/operators/frontend-presentation-resolve/operator.vi.md

@@ -0,0 +1,140 @@
+# frontend.presentation.resolve
+
+## Việc
+
+Resolve mọi thuộc tính trình bày do ứng dụng sở hữu trên một cây đã compose sẵn về đúng một luật đã
+publish, phát ra class và lời khai contract kiểm chứng được của nó, và dừng ở khoảng trống có chủ nhỏ
+nhất thay vì bịa ra một giá trị.
+
+## Cấu trúc đến nơi là đã quyết xong
+
+Cấu trúc, thứ tự phần tử, việc chọn component Grammar, chữ, dữ liệu và hành vi đến nơi là đã quyết
+xong, và trần owner cũng vậy: nó do chính cái hướng mà nhánh này resolve mang theo, không bao giờ
+được khai lại ở đây. Operator này chỉ trả lời, cho từng node ứng dụng sở hữu, mỗi thuộc tính trình
+bày nhận giá trị nào và luật nào uỷ quyền cho giá trị ấy. Nó không đổi gì về thứ cây render ra.
+
+## Không có luật bịa
+
+Một luật chỉ tồn tại khi topic kiến thức được bind publish đúng identifier của nó, và kho luật ấy
+đóng băng suốt lần chạy. Một identifier phát ra mà không có trong kho là `UNKNOWN_RULE`. Một class
+chỏi với identifier của nó bị từ chối: số hiệu luật là số thứ tự trên thang giá trị, nên `GAP-5`
+render ra `gap-6` và `PADDING-5` render ra `p-6`, và viết số thứ tự thành bước thang chính là lỗi mà
+phép kiểm này sinh ra để bắt. Khi không case nào đã publish khớp điều kiện quan sát được, lần chạy
+dừng với `RULE_MISSING` gọi tên đúng node đó; nó không chọn giá trị gần, không làm tròn về bước gần
+nhất, không chép của node bên cạnh. Operator không bao giờ sửa knowledge: case còn thiếu được trả về
+cho chủ knowledge, và chính cây ấy được resolve lại sau khi case được publish.
+
+## Grammar đọc ở bản đã publish, và được hỏi trước
+
+Các quan hệ đã sở hữu lấy từ chính lời khai data-contract của gói đã publish, không bao giờ lấy từ
+source của Grammar. Một thuộc tính mà component đã sở hữu sẽ resolve về component ấy, không phát class
+ứng dụng nào, và gọi tên luật mà component thoả; thứ tự đó làm việc hiện thực lại thành bất khả thi
+chứ không chỉ là điều bị khuyên can. Một class ứng dụng hiện thực lại quan hệ đã có chủ, đè lên giải
+phẫu Grammar hay nằm ngoài thang đóng sẽ bị bỏ kèm một dòng ghi của chính nó, theo từng node và không
+bao giờ im lặng.
+
+## Class bị cấm thì gỡ, không phải thiếu rule
+
+Khi case duy nhất gọi tên một class của ứng dụng nêu điều kiện mà node không thoả (foreground accent
+mà `SURFACE-4` chỉ cho phép trong một dải raised, lại viết lên một hàng không raised), thuộc tính đó
+không thiếu rule: rule đã trả lời, và câu trả lời là không. Class bị gỡ ở bước gỡ bỏ, thuộc tính rơi
+về giá trị node kế thừa, và việc gỡ được ghi kèm case đã từ chối nó. `RULE_MISSING` chỉ dành cho thuộc
+tính không case nào đã publish nhắc tới.
+
+## Thiếu đường công khai là một khoảng trống, không phải một lần dừng
+
+Khi Common không mở đường công khai nào cho một quan hệ mà ứng dụng cần một cách chính đáng, node giữ
+lại class ứng dụng của nó và nhánh ghi một dòng vào `## Gaps` gọi tên node, thuộc tính và đường còn
+thiếu. Nhánh không dừng: một cách chữa cháy có ghi sổ thì chủ họ và lượt audit sau đều thấy, còn dừng
+ở đây chỉ đổi một giá trị im lặng lấy một chuỗi bị chặn.
+
+## Contract là lời khai, không phải phán quyết
+
+Mọi node do ứng dụng sở hữu đều công bố các identifier nó khai. `data-contract` ghi lại node khai
+thoả những luật nào và không bao giờ khẳng định node đó pass; lời khai tồn tại để một lượt audit sau
+có thể phản bác, và một luật vẫn chọn được trực tiếp bằng `[data-contract~="GAP-4"]`. Khi tắt chế độ
+phát, cây không mang gì và một mình biên nhận giữ lời khai.
+
+## Vòng lặp được đếm
+
+Một lượt audit gửi phát hiện ngược về đây là mở thêm một vòng, và một vòng lặp lại chính nó thì không
+phải tiến triển. Số biên nhận audit mà phiên này đã đẩy ngược về được đếm ngay ở gate, và một lần
+chạy vượt `maxRounds` sẽ dừng với `NO_PROGRESS` thay vì resolve cùng một cây tới lần thứ ba.
+
+## Ranh giới
+
+Context chỉ đọc. Operator chỉ ghi `response/` của nhánh mình: biên nhận resolution, bản kiểm kê và
+cây đã resolve. Nó không đổi cấu trúc DOM, thứ tự phần tử, việc chọn component Grammar, chữ hay hành
+vi, không viết class cho thuộc tính mà một component Grammar đã sở hữu, không thò tay vào giải phẫu
+Grammar bằng selector hay class truyền vào, không sửa knowledge, không publish Grammar, không ghi
+source sản phẩm, và không ghi phán quyết, điểm số hay tuyên bố pass lên bất kỳ node nào.
+
+## Context
+
+| Alias | Bind | Bắt buộc |
+| --- | --- | --- |
+| `@knowledge/ui/presentation` | kho luật đóng, đọc ở fingerprint của nó; nguồn duy nhất của identifier hợp lệ | có |
+| `@grammar/core` | các quan hệ đã sở hữu của gói đã publish, đọc ở bản publish chứ không bao giờ từ source Grammar | có |
+| `@workspaces/fe` | checkout được route mà cây đã compose thuộc về, đọc ở head đóng băng | có |
+
+## Đầu vào
+
+| Kind | Từ đâu | Bắt buộc |
+| --- | --- | --- |
+| `frontend-direction-decision` | `frontend.direction.decide`, ý đồ và trần owner mà lượt resolve này làm việc bên trong; không bao giờ là nguồn giá trị trình bày | có |
+| `frontend-surface-audit` | `frontend.surface.audit`, các phát hiện mở ra vòng này; chỉ có mặt khi đây là một vòng lặp | không |
+
+## Yêu cầu
+
+| Field | Kiểu | Mặc định | Hỏi |
+| --- | --- | --- | --- |
+| `maxRounds` | number | 2 | Bề mặt này được đi bao nhiêu vòng audit rồi resolve trước khi gọi dừng vòng lặp |
+| `contractEmission` | choice | on | `on` ghi danh sách token lời khai lên cây, `off` để một mình biên nhận làm bằng |
+| `resume` | token | null | Token của nhánh bị chặn khi vào lại sau một mã dừng |
+
+## Các bước
+
+| # | Bước | Tham số | Đọc | Ghi | Dừng với |
+| --- | --- | --- | --- | --- | --- |
+| 1 | Kiểm gate, chạy lại, và đếm số vòng audit | `resume`, `maxRounds` | `request/request.json`, đầu vào `frontend-surface-audit` khi đây là vòng lặp, @workspaces/fe ở head đóng băng | — | `INVALID_INPUT`, `SOURCE_DRIFT`, `NO_PROGRESS` |
+| 2 | Bind thẩm quyền | — | @knowledge/ui/presentation (mọi topic kèm fingerprint và kho luật), @grammar/core (các quan hệ đã sở hữu của gói đã publish), @workspaces/fe (head được route và cây đã đóng băng), đầu vào `frontend-direction-decision`, @tools/git, @tools/registry | — | `KNOWLEDGE_UNBOUND`, `GRAMMAR_UNPUBLISHED` |
+| 3 | Đi hết cây một lượt dưới trần owner mà hướng mang theo | — | @workspaces/fe (cây đóng băng, theo thứ tự tài liệu), đầu vào `frontend-direction-decision` | — | `OWNER_CONFLICT` |
+| 4 | Xác định chủ của từng thuộc tính đang có | — | @grammar/core (các quan hệ đã sở hữu), @workspaces/fe (thuộc tính node đang mang) | `response/data/inventory.json` | — |
+| 5 | Chọn một luật trình bày cho mỗi thuộc tính ứng dụng còn sở hữu | — | @knowledge/ui/presentation (các case topic được bind publish) | — | `RULE_MISSING` |
+| 6 | Xếp một đường công khai còn thiếu thành khoảng trống Grammar | — | @grammar/core (quan hệ đang xét), @knowledge/ui/presentation (dấu khoảng trống năng lực) | — | — |
+| 7 | Bỏ những gì cây không nên mang | — | @workspaces/fe (class ứng dụng trên node), @grammar/core (giải phẫu Grammar và thang đóng) | — | — |
+| 8 | Phát lời khai contract lên các node do ứng dụng sở hữu | `contractEmission` | @knowledge/ui/presentation (kho luật đã đóng băng) | — | `UNKNOWN_RULE` |
+| 9 | Phát | — | mọi thứ ở trên | `response/artifacts/<target>.resolved.tsx`, `response/data/inventory.json`, `response/response.md`, `response/response.json` | — |
+
+Lượt đi thăm mọi node theo thứ tự tài liệu và ghi một node path ổn định; node nằm ngoài trần mà hướng
+mang theo thì chỉ quan sát chứ không bao giờ bị sửa. Bước 4 đến 8 chạy theo từng node, nên một cây cho
+đúng một quyết định cho mỗi cặp node và thuộc tính. Biên nhận uỷ quyền cho một lượt audit sau đo kết
+quả render đối chiếu với lời khai; nó không chứng minh gì về việc cây render ra sao.
+
+## Đầu ra
+
+| Kind | File | Kiểu | Bắt buộc |
+| --- | --- | --- | --- |
+| `frontend-presentation-resolution` | `response/response.md` | md | có |
+| `inventory` | `response/data/inventory.json` | data | có |
+| `resolved-tree` | `response/artifacts/<target>.resolved.tsx` | artifact | có |
+
+## Dừng
+
+| Code | Xử lý |
+| --- | --- |
+| `INVALID_INPUT` | terminate |
+| `SOURCE_DRIFT` | terminate |
+| `OWNER_CONFLICT` | terminate |
+| `KNOWLEDGE_UNBOUND` | terminate |
+| `UNKNOWN_RULE` | terminate |
+| `RULE_MISSING` | terminate |
+| `GRAMMAR_UNPUBLISHED` | terminate |
+| `NO_PROGRESS` | terminate |
+
+## Kế tiếp
+
+| Khi | Operator |
+| --- | --- |
+| cây đã resolve và các giá trị của nó phải được ghi vào source sản phẩm | `frontend.source.apply` |
+| một khoảng trống cần component của họ trước vòng sau, nên một người publish nó rồi chính cây ấy được resolve lại | `frontend.presentation.resolve` |