@starci/skills 1.1.0 → 1.2.0

package/operators/uat-verify/operator.vi.md

@@ -13,8 +13,21 @@ cổng. Không có gì ở operator này là thường lệ: nó đăng nhập n
 vào một runtime dùng chung và để lại một hồ sơ lượt chạy vĩnh viễn, nên thứ khởi động nó là một con
 người, không bao giờ là lịch hẹn, mặc định của chain hay sự tiện tay của một agent khác. `runId` và
 `lease` cũng không phải câu hỏi dành cho người: orchestrator sinh mã lượt chạy và cấp lease độc quyền
-trên thư mục luồng trước khi nhánh bắt đầu, và một lần gọi đến mà thiếu chúng là `INVALID_INPUT` chứ
-không phải một lời hỏi.
+trên thư mục luồng trước khi nhánh bắt đầu, và một lần gọi đến mà thiếu chúng là `INVALID_INPUT` ở bước 1 chứ
+không phải một lời hỏi. Vì thế Mặc định của chúng là `—`: một ô Mặc định ghi "mã lượt chạy của
+orchestrator" là lời văn chứ không phải một giá trị cổng dùng được, và một cổng chấp nhận lời văn là
+một cổng chấp nhận ô rỗng. `LEASE_INVALID` là một thất bại khác và giữ chỗ riêng của nó: đó là cái
+lease có tồn tại nhưng đã hết hạn, thuộc về nơi khác, hoặc đang ràng vào một lượt chạy khác, và nó bị
+phát hiện ở bước 6 trên chính thư mục luồng mà lượt chạy này đang giữ.
+
+## Endpoint là cái đã ràng, không phải cái suy lại
+
+Luồng được lái theo endpoint mà đầu vào `route` mang, chính cái mà nhánh `workspace.bind` của chuỗi
+này đã quan sát và đóng lại. Operator này không suy lại sự sẵn sàng từ sổ đăng ký runtime: một sổ
+đăng ký báo `ready` trong khi không ai lắng nghe đúng là nguồn đẩy trình duyệt vào một cổng chết, và
+bước ràng đã từ chối một cổng chỉ-lắng-nghe thay cho chuỗi này rồi. Khi endpoint đã ràng không trả
+lời, mã dừng là `RUNTIME_UNAVAILABLE` trên một endpoint có tên, chứ không phải một phỏng đoán xem
+origin nào mới là origin được nhắc tới.
 
 ## Mật khẩu là một cái tên, không bao giờ là một giá trị
 
@@ -80,8 +93,8 @@ lượt chạy, và không xoá bất cứ thứ gì ngoài namespace fixture c
 | Alias | Bind | Bắt buộc |
 | --- | --- | --- |
 | `@worktrees/uat/<flow>/<case>` | thư mục luồng: `flow.md`, `account.json`, `seed/`, lịch sử chỉ-thêm `runs/<runId>/` và con trỏ `latest`, bind theo fingerprint từng file và chỉ ghi khi giữ lease độc quyền | có |
-| `@worktrees/_templates` | khuôn luồng UAT dùng để tạo thư mục luồng mới; tiêu thụ, không sửa | có |
-| `@worktrees/sessions/central-runtime` | chủ runtime đã sẵn sàng, generation và các origin chính xác của nó; sự sẵn sàng phải được chứng minh, không được giả định | có |
+| `@worktrees/_templates` | khuôn luồng UAT dùng để tạo thư mục luồng mới, đúng ba thứ mà bước 4 đọc: `uat/flow.md` với các case và những khẳng định có tên của chúng, `uat/account.json` với username, vai, tên thông tin đăng nhập và đường dẫn file niêm phong, không trường nào có thể chứa bí mật, và `uat/seed/` với các bản ghi mà một lượt chạy đặt namespace lên; tiêu thụ, không sửa | có |
+| `@worktrees/sessions/central-runtime` | generation của chủ runtime đứng sau endpoint đã ràng; sự sẵn sàng do đầu vào `route` chứng minh, không bao giờ suy lại từ sổ đăng ký này | có |
 | `@workspaces/device-state` | sổ thông tin đăng nhập niêm phong; mật khẩu UAT dùng chung được giải theo tên ở đây lúc đăng nhập và không đọc ở đâu khác | có |
 | `@workspaces/be` | checkout backend được route tại commit đã ghim, nơi luồng kiểm hành vi và nơi store giữ các bản ghi có namespace | có |
 
@@ -91,6 +104,7 @@ lượt chạy, và không xoá bất cứ thứ gì ngoài namespace fixture c
 | --- | --- | --- |
 | `frontend-surface-audit` | lượt soi bề mặt kết luận frontend sạch, lấy tại commit đã ghim | có |
 | `quality-verification` | cổng chất lượng đã xanh, lấy tại đúng commit đã ghim ấy | có |
+| `route` | `workspace.bind` ở vai fe; route đã ràng mà lượt chạy này lái theo endpoint của nó | có |
 
 ## Yêu cầu
 
@@ -100,8 +114,8 @@ lượt chạy, và không xoá bất cứ thứ gì ngoài namespace fixture c
 | `feature` | id | — | Khoá feature dùng để địa chỉ hoá thư mục luồng |
 | `flow` | id | — | Luồng sản phẩm duy nhất mà lần gọi này kiểm chứng |
 | `cases` | list `caseId` | every case of the flow | Chạy những case đã đóng băng nào; mặc định là mọi case `flow.md` khai, theo đúng thứ tự của nó |
-| `runId` | id | the orchestrator's run id | Không hỏi người: orchestrator sinh ra nó và nó namespace mọi bản ghi lượt chạy này ghi ra |
-| `lease` | token | the orchestrator's lease | Không hỏi người: orchestrator cấp lease độc quyền trên thư mục luồng trước khi nhánh bắt đầu |
+| `runId` | id | — | Không hỏi người: orchestrator điền nó, và nó namespace mọi bản ghi lượt chạy này ghi ra |
+| `lease` | token | — | Không hỏi người: orchestrator điền nó, cấp lease độc quyền trên thư mục luồng trước khi nhánh bắt đầu |
 | `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
@@ -113,7 +127,7 @@ lượt chạy, và không xoá bất cứ thứ gì ngoài namespace fixture c
 | 3 | Preflight runtime: thông tin đăng nhập niêm phong giải được theo tên, tài khoản tồn tại, store trả lời | — | @workspaces/device-state để lấy thông tin đăng nhập mà `account.json` nêu tên, @worktrees/sessions/central-runtime để lấy generation và các origin, @tools/secrets, @tools/http | — | `PROVISIONING_UNAVAILABLE` |
 | 4 | Đóng băng snapshot từ `flow.md`, `account.json` và `seed/` | `feature`, `flow`, `cases` | @worktrees/uat/<flow>/<case>, @worktrees/_templates để lấy khuôn luồng | @worktrees/uat/<flow>/<case> (snapshot), `response/data/snapshot.json`, @tools/sourcewrite | `CANONICAL_WRITE_DENIED` |
 | 5 | Gieo các bản ghi đã đóng băng vào namespace lượt chạy | `runId` | `response/data/snapshot.json`, @workspaces/be | @tools/database | `FIXTURE_VIOLATION` |
-| 6 | Chạy các case đã đóng băng theo thứ tự trên worktree phiên tại commit đã ghim | — | `response/data/snapshot.json`, @worktrees/sessions/central-runtime để lấy origin và generation, @workspaces/device-state để lấy thông tin đăng nhập chỉ lúc đăng nhập, @tools/browsercontrol, @tools/websearch | — | `LEASE_INVALID`, `RUNTIME_UNAVAILABLE` |
+| 6 | Chạy các case đã đóng băng theo thứ tự trên endpoint mà route đã ràng mang, tại commit đã ghim | — | `response/data/snapshot.json`, đầu vào `route` để lấy endpoint lượt chạy này lái theo, @worktrees/sessions/central-runtime để lấy generation đứng sau endpoint đó, @workspaces/device-state để lấy thông tin đăng nhập chỉ lúc đăng nhập, @tools/browsercontrol, @tools/websearch | — | `LEASE_INVALID`, `RUNTIME_UNAVAILABLE` |
 | 7 | Capture tại từng khẳng định có tên với ô mật khẩu đã che, rồi ghép tấm sheet | — | `response/data/snapshot.json`, @worktrees/sessions/central-runtime để lấy bằng chứng runtime trực tiếp nhất | `response/data/captures/<case>.json`, `response/artifacts/<case>.png`, `response/artifacts/sheet.png`, @tools/visualize | `EVIDENCE_UNAVAILABLE` |
 | 8 | Xét ba làn tách rời nhau | — | `response/data/captures/<case>.json` | `response/data/verdicts.json` | — |
 | 9 | Kiểm chỉ-đọc, rồi xoá namespace lượt chạy và không gì khác | `runId` | @workspaces/be để lấy các bản ghi mang `is_uat=true` và namespace này, `response/data/verdicts.json` | @tools/database | — |

package/operators/uat-verify/self-test.mjs

@@ -25,6 +25,7 @@ const CASES = ['pay-and-enrol', 'abandon-checkout'];
 const ASSERTIONS = { 'pay-and-enrol': ['entry', 'commitment', 'terminal'], 'abandon-checkout': ['entry', 'recovery'] };
 const AUDIT_IN = 'step-1/parallel-1/response/response.md';
 const QUALITY_IN = 'step-2/parallel-1/response/response.md';
+const ROUTE_IN = 'step-1/parallel-2/response/data/route.json';
 // The placeholder this operator's law forbids anywhere it writes.
 const LEAK = 'UAT-SHARED-PASSWORD';
 
@@ -118,7 +119,7 @@ const requestJson = ({ extra = {}, inputs, cases = [...CASES] } = {}) => ({
   schemaVersion: 9, operatorId: 'uat.verify', step: 3, parallel: 1, sessionId: 's-test',
   contexts: [{ alias: '@workspaces/be', head: COMMIT }, { alias: '@worktrees/uat/enrollment/paid-enrollment', head: null }],
   requirements: { requestedBy: 'the product owner', feature: FEATURE, flow: FLOW, cases, runId: RUN, lease: `uat-lease://s-test/${FLOW}`, resume: null, ...extra },
-  inputs: inputs ?? { 'frontend-surface-audit': AUDIT_IN, 'quality-verification': QUALITY_IN },
+  inputs: inputs ?? { 'frontend-surface-audit': AUDIT_IN, 'quality-verification': QUALITY_IN, route: ROUTE_IN },
   resume: null,
 });
 
@@ -142,11 +143,11 @@ function writeBranch(files, history = 'match') {
   const session = mkdtempSync(path.join(tmpdir(), 'uat-session-'));
   const branch = path.join(session, 'step-3', 'parallel-1');
   for (const d of ['request', 'response/data/captures', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
-  for (const input of [AUDIT_IN, QUALITY_IN]) {
+  for (const input of [AUDIT_IN, QUALITY_IN, ROUTE_IN]) {
     mkdirSync(path.dirname(path.join(session, input)), { recursive: true });
-    writeFileSync(path.join(session, input), '# admitting receipt\n');
+    writeFileSync(path.join(session, input), input.endsWith('.json') ? '{}\n' : '# admitting receipt\n');
   }
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['3/1']], steps: { '3/1': 'uat.verify' }, current: '3/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['3/1']], steps: { '3/1': 'uat.verify' }, current: '3/1', status: 'running' }));
   for (const c of CASES) writeFileSync(path.join(branch, 'response', 'artifacts', `${c}.png`), 'png');
   writeFileSync(path.join(branch, 'response', 'artifacts', 'sheet.png'), 'png');
 
@@ -222,7 +223,7 @@ await expectError({ ...baseline(), 'response/response.json': { ...responseJson()
 await expectValid({ ...blocked(), 'response/response.json': { schemaVersion: 9, operatorId: 'uat.verify', step: 3, parallel: 1, status: 'blocked', stop: 'RUNTIME_UNAVAILABLE', fallbacks: [], fields: {}, commits: [], next: [] } }, 'blocked on the shared RUNTIME_UNAVAILABLE code');
 await expectError({ ...baseline(), 'request/request.json': requestJson({ extra: { password: 'x' } }) }, 'requirements.password is not a field', 'a credential has nowhere to go in a request');
 await expectError({ ...baseline(), 'request/request.json': requestJson({ extra: { requestedBy: '' } }) }, 'required field requestedBy has no value', 'a run nobody asked for');
-await expectError({ ...baseline(), 'request/request.json': requestJson({ inputs: { 'frontend-surface-audit': AUDIT_IN } }) }, 'required input quality-verification is absent', 'a run admitted by one receipt only');
+await expectError({ ...baseline(), 'request/request.json': requestJson({ inputs: { 'frontend-surface-audit': AUDIT_IN, route: ROUTE_IN } }) }, 'required input quality-verification is absent', 'a run admitted by one receipt only');
 
 // Admission at the pinned commit.
 await expectError({ ...baseline(), 'response/data/snapshot.json': snapshot({ admission: [{ kind: 'frontend-surface-audit', ref: AUDIT_IN, commit: COMMIT }, { kind: 'quality-verification', ref: QUALITY_IN, commit: OTHER_COMMIT }] }) }, 'ADMISSION_MISSING — quality-verification was taken at', 'an admission from another commit');

package/operators/uat-verify/validate.mjs

@@ -33,12 +33,19 @@ export async function validateUatStep(branchDir, root = ROOT) {
 
   // UAT is never routine: a run exists because a person asked for it, and the run identifier and the
   // exclusive lease arrive from the orchestrator rather than from a person.
-  if (empty(requirements.requestedBy)) errors.push('request.json: UAT runs only when a person asked; requestedBy has no value');
+  if (decided && empty(requirements.requestedBy)) errors.push('request.json: UAT runs only when a person asked; requestedBy has no value');
   if (decided && empty(requirements.runId)) errors.push('request.json: the orchestrator supplies runId; a decided run cannot namespace its records without one');
   if (decided && empty(requirements.lease)) errors.push('request.json: the orchestrator supplies the exclusive lease; a decided run cannot write the flow directory without one');
 
   const pinned = (request?.contexts ?? []).find((c) => c.alias === '@workspaces/be')?.head ?? null;
 
+  // A branch that never froze a snapshot is judged on its admissions too: the code that names the
+  // missing receipt is the one whose resume instruction is right for a person, and it must be
+  // reachable on the branch that blocked before any snapshot existed.
+  for (const kind of ADMISSIONS) {
+    if (request?.inputs?.[kind] === undefined) errors.push(`request.json: ADMISSION_MISSING — input ${kind} is absent`);
+  }
+
   let snapshot = null;
   if (present.has('uat-snapshot') && has('response/data/snapshot.json')) {
     try { snapshot = JSON.parse(await read('response/data/snapshot.json')); } catch { snapshot = null; }
@@ -65,8 +72,7 @@ export async function validateUatStep(branchDir, root = ROOT) {
       if (!entry) { errors.push(`response/data/snapshot.json: ADMISSION_MISSING — ${kind} is absent from the admission record`); continue; }
       if (entry.commit !== snapshot.commit) errors.push(`response/data/snapshot.json: ADMISSION_MISSING — ${kind} was taken at ${entry.commit}, not at the pinned commit ${snapshot.commit}`);
       const given = request?.inputs?.[kind];
-      if (given === undefined) errors.push(`request.json: ADMISSION_MISSING — input ${kind} is absent`);
-      else if (entry.ref !== given) errors.push(`response/data/snapshot.json: ${kind} admits ${entry.ref}, but the request handed in ${given}`);
+      if (given !== undefined && entry.ref !== given) errors.push(`response/data/snapshot.json: ${kind} admits ${entry.ref}, but the request handed in ${given}`);
     }
 
     // The frozen order is declared in advance, not discovered while running.
@@ -164,7 +170,7 @@ export async function validateUatStep(branchDir, root = ROOT) {
   } else if (decided) errors.push('response/response.md: a done branch needs the verification receipt');
 
   // Custody is proved on the written bytes, not asserted in prose.
-  const scanned = ['response/response.md', 'response/data/snapshot.json', 'response/data/verdicts.json', ...asList(response.fields?.['uat-capture'])];
+  const scanned = ['response/response.md', 'response/response.json', 'response/data/snapshot.json', 'response/data/verdicts.json', ...asList(response.fields?.['uat-capture'])];
   for (const f of scanned) {
     if (!has(f)) continue;
     if (PASSWORD_LEAK.test(await read(f))) errors.push(`${f}: the shared UAT password appears in a file this operator writes; the credential is resolved by name at login and is never recorded`);

package/operators/workspace-bind/operator.md

@@ -51,7 +51,13 @@ anything: this operator does not stash, clean, or reset a working tree to make a
 The businesses authority root is derived as `<git root>/.worktrees/businesses` when that worktree
 exists on a source checkout and is absent otherwise; it is never accepted from the person, because a
 typed authority root is how a second business tree is born. Provenance and freshness are not a step
-of their own: they are written inside the emit, next to the binding they describe.
+of their own: they are written inside the emit, next to the binding they describe. The head a hydrated
+route recorded is a record of the hydration and never route authority: the observed head wins, and a
+hydration head two commits behind the checkout is not a stop.
+
+A blocked branch emits no receipt and no route: `response.json` is the whole record, and `reason`
+carries the observation that justified the stop, including the registry generation, the endpoints
+probed and what each answered.
 
 ## Boundary
 
@@ -87,7 +93,7 @@ workspace, or provisions an account. It makes no product decision and carries no
 | --- | --- | --- | --- |
 | `project` | id | — | The project to bind |
 | `role` | choice | — | `fe` or `be`: the role of that project to bind |
-| `gitPolicy` | list of `{worktreeBranches, mutationBranch}` | the policy the route declaration carries | The branch law this binding is verified against; `forbidden` keeps every write on the mutation branch |
+| `gitPolicy` | list of `{worktreeBranches, mutationBranch}` | the policy the route declaration carries; a declaration that carries none is `INVALID_INPUT` at step 1, never a guessed policy | The branch law this binding is verified against; `forbidden` keeps every write on the mutation branch |
 | `declaredWriteRoots` | list | empty | The only paths later work may write; anything dirty outside them is `CHECKOUT_DIRTY` |
 | `runtimeNeed` | choice | none | `none` binds no runtime and skips step 5; `consume` binds the owner's endpoints as a consumer |
 | `resume` | token | null | The blocked branch's token when re-entering after a stop |
@@ -106,8 +112,15 @@ workspace, or provisions an account. It makes no product decision and carries no
 Step 5 recomputes nothing: the endpoint fingerprint either matches the closed projection or the
 branch stops. Under `worktreeBranches` set to forbidden, a route binds only on the mutation branch and
 records `WORKTREE_BRANCH_FORBIDDEN`; under `session-only` it binds on the mutation branch or on a
-`session/<sessionId>` worktree branch, the only shape a source-writing operator may commit to; a redacted conversation head records `PROVENANCE_HEAD_BOUND`, and
-a cached receipt matching the same identity tuple and fingerprints records `CACHED_ROUTE_REUSED`. A
+`session/<sessionId>` worktree branch, the only shape a source-writing operator may commit to, and
+records `WORKTREE_BRANCH_SESSION_ONLY`, because a policy that opens a write path is exactly the
+finding a later reader looks for; a redacted conversation head records `PROVENANCE_HEAD_BOUND`, and
+a cached receipt matching the same identity tuple and fingerprints records `CACHED_ROUTE_REUSED`. `mutationReadiness` is
+`ready` when the observed branch is one the routed policy permits a write on — the mutation branch, or
+a `session/<sessionId>` branch under `session-only` — and the working tree is clean outside the
+declared write roots; it is `read-only` in every other case, including a route bound with no declared
+write roots. It is derived here and never accepted from the request, because a readiness a caller can
+assert is a readiness nobody measured. A
 resume begins again at step 1, reuses only unchanged fingerprinted observations, and consumes the
 exact delta; a republished route arrives as a new route fingerprint, because the same fingerprint
 cannot yield a different binding.
@@ -146,3 +159,4 @@ cannot yield a different binding.
 | the runtime owner is missing or not ready and one coordination request must be raised | `platform.operate` |
 | the route is bound and a frontend surface must be decided inside it | `frontend.direction.decide` |
 | the route is bound and a published head must be verified before it ships | `quality.verify` |
+| the route is bound and a served surface must be observed | `frontend.surface.audit` |

package/operators/workspace-bind/operator.vi.md

@@ -50,7 +50,13 @@ operator này không stash, không clean, không reset cây làm việc để m
 thẩm quyền businesses được suy ra là `<gốc git>/.worktrees/businesses` khi worktree ấy tồn tại trên
 một checkout source và vắng mặt nếu không; nó không bao giờ được nhận từ người, vì một gốc thẩm quyền
 do người gõ vào chính là cách cây business thứ hai ra đời. Provenance và độ tươi không phải một bước
-riêng: chúng được ghi ngay trong bước phát, cạnh binding mà chúng mô tả.
+riêng: chúng được ghi ngay trong bước phát, cạnh binding mà chúng mô tả. Head mà một route đã hydrate
+ghi lại chỉ là hồ sơ của lần hydrate ấy chứ không bao giờ là thẩm quyền của route: head quan sát được
+mới thắng, và một head hydrate chậm hơn checkout hai commit không phải một mã dừng.
+
+Một nhánh bị chặn không phát biên nhận và không phát route: `response.json` là toàn bộ hồ sơ, còn
+`reason` mang quan sát đã biện minh cho lần dừng, gồm generation của sổ đăng ký, các endpoint đã dò và
+mỗi endpoint đã trả lời ra sao.
 
 ## Ranh giới
 
@@ -87,7 +93,7 @@ và không mang phán quyết nào.
 | --- | --- | --- | --- |
 | `project` | id | — | Project cần ràng |
 | `role` | choice | — | `fe` hay `be`: vai của project ấy cần ràng |
-| `gitPolicy` | list `{worktreeBranches, mutationBranch}` | the policy the route declaration carries | Luật nhánh mà binding này được kiểm theo; `forbidden` giữ mọi lần ghi trên nhánh mutation |
+| `gitPolicy` | list `{worktreeBranches, mutationBranch}` | the policy the route declaration carries; a declaration that carries none is `INVALID_INPUT` at step 1, never a guessed policy | Luật nhánh mà binding này được kiểm theo; `forbidden` giữ mọi lần ghi trên nhánh mutation |
 | `declaredWriteRoots` | list | empty | Những đường dẫn duy nhất mà việc sau được ghi; bẩn ngoài chúng là `CHECKOUT_DIRTY` |
 | `runtimeNeed` | choice | none | `none` không ràng runtime và bỏ qua bước 5; `consume` ràng endpoint của chủ với vai tiêu thụ |
 | `resume` | token | null | Token của nhánh bị chặn khi vào lại sau một mã dừng |
@@ -105,9 +111,14 @@ và không mang phán quyết nào.
 
 Bước 5 không tính lại gì cả: fingerprint endpoint hoặc khớp phép chiếu đóng, hoặc nhánh dừng. Dưới
 `worktreeBranches` đặt là forbidden, một route chỉ ràng trên nhánh mutation và ghi
-`WORKTREE_BRANCH_FORBIDDEN`; một head hội thoại đã che ghi `PROVENANCE_HEAD_BOUND`, và một biên nhận Đặt là `session-only` thì route ràng trên nhánh mutation hoặc trên nhánh worktree
+`WORKTREE_BRANCH_FORBIDDEN`, và khi đặt là `session-only` thì ghi `WORKTREE_BRANCH_SESSION_ONLY`, bởi
+một chính sách mở ra đường ghi đúng là phát hiện mà người đọc sau đi tìm; một head hội thoại đã che ghi `PROVENANCE_HEAD_BOUND`, và một biên nhận Đặt là `session-only` thì route ràng trên nhánh mutation hoặc trên nhánh worktree
 `session/<sessionId>`, hình dạng duy nhất mà operator ghi source được commit lên;
-cache khớp cùng bộ định danh và fingerprint ghi `CACHED_ROUTE_REUSED`. Chạy lại thì bắt đầu lại từ
+cache khớp cùng bộ định danh và fingerprint ghi `CACHED_ROUTE_REUSED`. `mutationReadiness` là `ready` khi nhánh quan sát được là nhánh mà chính sách được route cho phép ghi
+lên — nhánh mutation, hoặc một nhánh `session/<sessionId>` dưới `session-only` — và cây làm việc sạch
+ngoài các gốc ghi đã khai; mọi trường hợp khác là `read-only`, kể cả một route ràng mà không khai gốc
+ghi nào. Nó được suy ra ở đây và không bao giờ nhận từ request, vì một mức sẵn sàng mà người gọi khẳng
+định được là một mức sẵn sàng không ai đo. Chạy lại thì bắt đầu lại từ
 bước 1, chỉ dùng lại quan sát có fingerprint không đổi, và tiêu thụ đúng phần delta; một route
 publish lại tới dưới dạng một fingerprint route mới, vì cùng một fingerprint không thể cho một ràng
 buộc khác.
@@ -146,3 +157,4 @@ buộc khác.
 | chủ runtime thiếu hoặc chưa sẵn sàng và cần nêu một yêu cầu phối hợp | `platform.operate` |
 | route đã ràng và một bề mặt frontend phải được quyết bên trong nó | `frontend.direction.decide` |
 | route đã ràng và một head đã publish phải được kiểm trước khi lên | `quality.verify` |
+| route đã ràng và một bề mặt đang phục vụ phải được quan sát | `frontend.surface.audit` |

package/operators/workspace-bind/self-test.mjs

@@ -50,6 +50,7 @@ function responseMd({ binding = routeBinding(), findings = null, runtimeRows = n
     ['ROUTE_HYDRATED_FROM_PORTABLE', binding.hydratedRouteRef, 'the portable declaration resolved to this local route'],
     ['IDENTITY_ROSTER_SEALED', 'the credential roster reference', 'the roster was bound by name and never read'],
     ...(binding.gitPolicy.worktreeBranches === 'forbidden' ? [['WORKTREE_BRANCH_FORBIDDEN', binding.gitPolicy.mutationBranch, 'the routed policy forbids task and worktree branches']] : []),
+    ...(binding.gitPolicy.worktreeBranches === 'session-only' ? [['WORKTREE_BRANCH_SESSION_ONLY', binding.gitPolicy.mutationBranch, 'the routed policy permits a session worktree branch']] : []),
     ...(binding.provenanceHeadRef ? [['PROVENANCE_HEAD_BOUND', binding.provenanceHeadRef, 'a redacted conversation head was attached']] : []),
     ...(binding.runtime ? [['RUNTIME_CONSUMED_NOT_OWNED', binding.runtime.ownerTaskId, 'the caller consumes the owner endpoints and owns no lifecycle']] : []),
   ];
@@ -131,7 +132,7 @@ function writeBranch(files) {
   const session = mkdtempSync(path.join(tmpdir(), 'workspace-session-'));
   const branch = path.join(session, 'step-1', 'parallel-1');
   for (const d of ['request', 'response/data', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['1/1']], steps: { '1/1': 'workspace.bind' }, current: '1/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['1/1']], steps: { '1/1': 'workspace.bind' }, current: '1/1', status: 'running' }));
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));
@@ -196,6 +197,7 @@ await expectError({ ...baseline(), 'response/response.md': responseMd({ findings
 await expectError({ ...baseline(), 'response/response.md': responseMd({ findings: [['ROUTE_HYDRATED_FROM_PORTABLE', HYDRATED, 'resolved'], ['IDENTITY_ROSTER_SEALED', 'roster', 'sealed'], ['WORKTREE_BRANCH_FORBIDDEN', 'mtp', 'forbidden'], ['HINT_REJECTED', 'D:/Repositories/starci-academy', 'a similar directory name']] }) }, 'a hint is INVALID_INPUT at the gate', 'a receipt that weighs a hint');
 await expectError({ ...baseline(), 'response/response.md': responseMd({ findings: [['ROUTE_HYDRATED_FROM_PORTABLE', HYDRATED, 'resolved'], ['WORKTREE_BRANCH_FORBIDDEN', 'mtp', 'forbidden']] }) }, 'the credential roster was sealed and never read', 'no sealed roster finding');
 await expectError({ ...baseline(), 'response/response.md': responseMd({ findings: [['ROUTE_HYDRATED_FROM_PORTABLE', HYDRATED, 'resolved'], ['IDENTITY_ROSTER_SEALED', 'roster', 'sealed']] }) }, 'a forbidden worktree policy must be recorded', 'a forbidden policy that was never recorded');
+await expectError({ ...baseline(), 'response/data/route.json': routeBinding({ gitPolicy: { worktreeBranches: 'session-only', mutationBranch: 'mtp' } }), 'request/request.json': requestJson({ extra: { gitPolicy: { worktreeBranches: 'session-only', mutationBranch: 'mtp' } } }) }, 'a session-only worktree policy must be recorded', 'a session-only policy that was never recorded');
 await expectError({ ...baseline(), 'response/response.md': responseMd({ findings: [['ROUTE_HYDRATED_FROM_PORTABLE', HYDRATED, 'resolved'], ['ROUTE_HYDRATED_FROM_PORTABLE', HYDRATED, 'resolved again'], ['IDENTITY_ROSTER_SEALED', 'roster', 'sealed'], ['WORKTREE_BRANCH_FORBIDDEN', 'mtp', 'forbidden']] }) }, 'repeats subject', 'a repeated finding subject');
 await expectError({ ...baseline(), 'response/response.md': responseMd().replace('## Policy', '## Git policy') }, 'missing section ^## Policy$', 'response section renamed');
 await expectError({ ...baseline(), 'response/response.md': responseMd().replace('| Branch | mtp |', '| Branch | feature/x |') }, 'differs from the route binding', 'the receipt and the binding disagree on the branch');

package/operators/workspace-bind/validate.mjs

@@ -122,6 +122,7 @@ export async function validateWorkspaceStep(branchDir, root = ROOT) {
       // rather than assumed.
       if (!findingKeys.has(`ROUTE_HYDRATED_FROM_PORTABLE|${route.hydratedRouteRef}`)) errors.push('response/response.md: a bound route must record the hydrated route it resolved from');
       if (route.gitPolicy.worktreeBranches === 'forbidden' && !findingKeys.has(`WORKTREE_BRANCH_FORBIDDEN|${route.gitPolicy.mutationBranch}`)) errors.push('response/response.md: a forbidden worktree policy must be recorded on the bound route');
+      if (route.gitPolicy.worktreeBranches === 'session-only' && !findingKeys.has(`WORKTREE_BRANCH_SESSION_ONLY|${route.gitPolicy.mutationBranch}`)) errors.push('response/response.md: a session-only worktree policy must be recorded on the bound route');
       if (route.provenanceHeadRef !== null && !findingKeys.has(`PROVENANCE_HEAD_BOUND|${route.provenanceHeadRef}`)) errors.push('response/response.md: a bound provenance head must be recorded');
       if (route.runtime !== null) {
         if (!findingKeys.has(`RUNTIME_CONSUMED_NOT_OWNED|${route.runtime.ownerTaskId}`)) errors.push('response/response.md: a consumed runtime must record that the caller does not own it');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/skills",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "StarCi Skills: one entry, fourteen operators, a closed routing map and a tool registry, installed as the .claude runtime of a repository for Claude Code and Codex.",
   "license": "MIT",
   "type": "module",

package/readiness/initialization/workspaces/local-route.schema.json

@@ -44,7 +44,7 @@
           "pattern": "^https://github\\.com/[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+(?:\\.git)?$"
         },
         "branch": { "type": "string", "minLength": 1, "maxLength": 255 },
-        "head": { "type": "string", "pattern": "^[0-9a-f]{40}$" },
+        "head": { "type": "string", "pattern": "^[0-9a-f]{40}$", "description": "The head recorded when this route was hydrated. It is never route authority: a binding reports the head it observes on the checkout, and an observed head ahead of this one is the current one, not a stop." },
         "gitPolicy": { "$ref": "#/$defs/gitPolicy" }
       }
     },

package/resources/orchestrator.json

@@ -6,12 +6,18 @@
   "dispatch": "routing.json",
   "agent": {
     "profile": "operator.json → resources.profile",
-    "grants": "operator.json → resources.tools: each @tools/<id> with one mode from resources/tools.json, and nothing the profile would otherwise permit",
+    "grants": "operator.json → resources.tools: each @tools/<id> with one mode from resources/tools.json, and nothing the profile would otherwise permit. A tool whose only use the operator's mode forbids is not granted for that run: backend.source.apply and frontend.source.apply under mode dry receive neither @tools/sourcewrite nor @tools/git",
     "refs": "operator.md → Context table, resolved through alias/alias.json; an unlisted location is unreadable",
-    "requirements": "operator.md → Requirements table; the orchestrator fills defaults into request.json and asks a person only for fields whose Default is — or whose value a stop code names",
+    "requirements": "operator.md → Requirements table; the orchestrator fills defaults into request.json and asks a person only for fields whose Default is — or whose value a stop code names. Fields under agent.fills (project from the mission scope, runId and lease from the session) the orchestrator supplies itself: a workflow neither presets them nor asks a person for them",
     "prompt": "rendered at dispatch from operator.md plus request.json; never stored",
     "isolation": "fresh, no inherited turns",
-    "writes": "only response/ of its own branch (step-N/parallel-M/response/); a nested-exchange agent writes only <exchange>/response/ of that branch; a source-writing operator also writes the session branch of its checkout under an exclusive lease (see sourceWrites)"
+    "writes": "only response/ of its own branch (step-N/parallel-M/response/); a nested-exchange agent writes only <exchange>/response/ of that branch; a source-writing operator also writes the session branch of its checkout under an exclusive lease (see sourceWrites)",
+    "profileRecord": "the orchestrator fills response.json boundProfile (operator.json → resources.profile) and ranProfile at dispatch whenever the two differ; validate-response refuses one without the other or a boundProfile that is not the operator's",
+    "fills": [
+      "project",
+      "runId",
+      "lease"
+    ]
   },
   "concurrency": {
     "rule": "at most maxConcurrentAgents agents at once; branches of one step run concurrently only when their Writes touch no common alias",
@@ -20,14 +26,14 @@
   },
   "handoff": {
     "carrier": "response.json fields: kind → path relative to the branch; the next branch's request.json inputs point at step-N/parallel-M/<path> from the session root, written explicitly by the orchestrator (nearest earlier producer guides the orchestrator, never the agent)",
-    "stop": "response.json status blocked with stop = code; errors/ says whether the code terminates or falls back, and routing.json says where a terminated step hands to",
+    "stop": "response.json status blocked with stop = code; errors/ says whether the code terminates or falls back, and routing.json says where a terminated step hands to. A code the merged registry does not list is read by the orchestrator as UNKNOWN_STOP and routed on domain caller; the branch keeps the code the agent wrote as evidence and the orchestrator records the substitution in state.json.substitutions",
     "waiting": "response.json status waiting with awaiting { exchange, kind }: the orchestrator validates the fields written so far, creates <exchange>/request/request.json in the same branch, runs a fresh agent for it, and resumes the paused agent when <exchange>/response/response.json is done; other branches of the step keep running",
     "resume": "a blocked branch re-enters the same operator as a new agent in step-(N+1)/parallel-1, with request.json.resume naming the blocked step and parallel; the blocked branch stays on disk as evidence"
   },
   "session": {
     "root": "<Source>/.worktrees/sessions/<sessionId>/",
     "id": "<yyyymmdd-HHMMss>-<project>-<first operator>, e.g. 20260903-142200-starci-academy-frontend.direction.decide",
-    "manifest": "state.json: id, project, startedAt, status (running | blocked | done), chain [[\"1/1\"], [\"2/1\", \"2/2\"], ...], steps { \"N/M\": operatorId }, current, leases { \"N/M\": { agent, holds } }, requestHashes { \"N/M\": sha256 of request/request.json }",
+    "manifest": "state.json, validated against templates/step/state.schema.json by validate-request: id, project, workflow, startedAt, status (running | blocked | done | stopped), chain [[\"1/1\"], [\"2/1\", \"2/2\"], ...], steps { \"N/M\": operatorId }, current, leases { \"N/M\": { agent, holds } }, requestHashes { \"N/M\": sha256 of request/request.json }, resumes { \"N/M\": { resumes: \"K/L\", stop } } for every re-entry, stoppedAt { branch, operator, stop | null, domain, route, why } when the session ended, substitutions { \"N/M\": code } for codes read as UNKNOWN_STOP, transitions [] as the audit trail",
     "branch": "step-<N>/parallel-<M>/ — N is the position in the chain, M the parallel branch; parallel-1 always exists",
     "branchLayout": [
       "request/request.json",
@@ -42,9 +48,9 @@
     "lifecycle": [
       "create: the orchestrator writes state.json and takes the leases before the first agent starts",
       "branch: each agent gets a fresh step-N/parallel-M/ with request/request.json already written and hashed into state.json, and writes only response/",
-      "advance: response.json status done and both validators green; the orchestrator writes the next branches' request.json from the Next table and routing.json",
+      "advance: response.json status done and both validators green; the orchestrator writes the next branches' request.json from the Next table and routing.json. A done response that fails a validator does not route: the session ends with stoppedAt { stop: null, why: the validator output } exactly as a terminating stop ends it",
       "wait: status waiting runs the nested exchange, then resumes the same agent; the branch stays running in state.json",
-      "block: status blocked keeps the session on disk; the orchestrator asks the person for the field the stop names, then re-enters the operator in step-(N+1)/parallel-1 with resume set",
+      "block: status blocked keeps the session on disk. When routing.json answers the stop's domain with kind resume, the orchestrator asks the person for the field the stop names and re-enters the operator in step-(N+1)/parallel-1 with resume set and state.json.resumes recorded. When it answers operator, the named operator runs next and the blocked branch is re-entered the same way once that operator is done. When it answers user or external, the branch stays blocked and the chain continues only after the person or the outside party has changed something the stop names; that continuation is also a step-(N+1)/parallel-1 re-entry with resume set, and request.json must carry the changed requirement or input, because a re-entry with no delta is NO_PROGRESS",
       "done: when routing reaches user or external, or git.publish emits done, the orchestrator releases the leases and deletes the session folder; what survives is what the steps published (commits, business heads, UAT pairs, remote runs) and any audit record the owner copies out first"
     ]
   },
@@ -53,7 +59,7 @@
     "track": "changes.md names every path with before/after hashes and the commit; the next requests pin @workspaces/<role> at that sha (contexts[].head) so quality.verify and frontend.surface.audit verify exactly what was written",
     "publish": "git.publish merges the session branch into the target branch: fast-forward when the target has not moved; a merge commit only when there is no conflict and the gates are re-run on the merge result; a conflict is NON_FAST_FORWARD and a person resolves it; never rebase, never force",
     "cleanup": "after a successful publish the worktree and the session branch are removed together with the session folder; a blocked session keeps both",
-    "policy": "the routed checkout must declare gitPolicy.worktreeBranches = session-only (readiness/initialization/workspaces); a route declaring forbidden binds read-only and no source-writing operator may run against it"
+    "policy": "the routed checkout must declare gitPolicy.worktreeBranches = session-only (readiness/initialization/workspaces); a route declaring forbidden binds read-only and no source-writing operator may run against it; mode dry is exempt, because it writes nothing: a dry backend.source.apply or frontend.source.apply may run against a read-only binding, and its plan records a null commit"
   },
   "profileEquivalents": {
     "rule": "an operator binds one profile; when the processor runs on a runtime that lacks that profile, it runs the equivalent profile of its own runtime with exactly the grants the operator requires, and response.json records both (boundProfile, ranProfile) so an audit can tell a stand-in from the binding",

package/routing.json

@@ -259,7 +259,8 @@
         "kind": "resume"
       },
       "runtime": {
-        "kind": "external"
+        "kind": "operator",
+        "target": "platform.operate"
       },
       "identity": {
         "kind": "external"

package/scripts/validate-request.mjs

@@ -12,7 +12,8 @@ import { fileURLToPath } from 'node:url';
 import { validateAgainst } from './json-schema.mjs';
 import { loadOperatorPackages, kindOf, isYes, exchangeOf } from './operator-md.mjs';
 
-const unquote = (s) => String(s ?? '').trim().replace(/^`|`$/g, '');
+// Only a fully quoted cell is unquoted: a sentence that opens with a code span keeps its backticks.
+const unquote = (s) => { const t = String(s ?? '').trim(); return /^`[^`]*`$/.test(t) ? t.slice(1, -1) : t; };
 export const isRequiredField = (row) => row.default.trim().startsWith('—');
 export const isEmpty = (v) => v === undefined || v === null || v === '' || v === '—';
 
@@ -59,6 +60,16 @@ export async function validateRequest(root, dir, packages) {
   if (sessionRoot && existsSync(path.join(sessionRoot, 'state.json'))) {
     try {
       const state = JSON.parse(await readFile(path.join(sessionRoot, 'state.json'), 'utf8'));
+      errors.push(...validateAgainst(JSON.parse(await readFile(path.join(root, 'templates', 'step', 'state.schema.json'), 'utf8')), state, 'state.json'));
+      // A resume re-enters the same operator and names a branch state.json knows; a re-entry state.json does not record is unrecorded evidence.
+      if (request.resume) {
+        const target = `${request.resume.step}/${request.resume.parallel}`;
+        if (state.steps?.[target] === undefined) errors.push(`request.json: resume names ${target}, which state.json does not record`);
+        else if (state.steps[target] !== request.operatorId) errors.push(`request.json: resume names ${target}, a ${state.steps[target]} branch, but this request runs ${request.operatorId}`);
+        const mine = `${request.step}/${request.parallel}`;
+        if (state.resumes && !state.resumes[mine]) errors.push(`request.json: state.json records no resumes[${mine}] for this re-entry`);
+        else if (state.resumes?.[mine] && state.resumes[mine].resumes !== target) errors.push(`request.json: state.json resumes[${mine}] names ${state.resumes[mine].resumes}, the request names ${target}`);
+      }
       const key = `${request.step}/${request.parallel}${request.exchange ? `/${request.exchange}` : ''}`;
       const expected = state.requestHashes?.[key];
       if (expected) {

package/scripts/validate-response.mjs

@@ -17,7 +17,8 @@ import { loadOperatorPackages, kindOf, isYes, exchangeOf } from './operator-md.m
 import { loadErrorsRegistry } from './errors-registry.mjs';
 import { sessionRootOf } from './validate-request.mjs';
 
-const unquote = (s) => String(s ?? '').trim().replace(/^`|`$/g, '');
+// Only a fully quoted cell is unquoted: a sentence that opens with a code span keeps its backticks.
+const unquote = (s) => { const t = String(s ?? '').trim(); return /^`[^`]*`$/.test(t) ? t.slice(1, -1) : t; };
 
 // Rows of the first table under `## <heading>`, cells unquoted.
 export function tableUnder(text, heading) {
@@ -98,7 +99,8 @@ export async function validateResponse(root, dir, { requirements = {}, exchange
   const dispositionOf = (code) => { const e = registry.codes[code]; return e && registry.allowed(code, op.id) ? effectiveDisposition(e, requirements) : null; };
   if (response.status === 'blocked') {
     const d = dispositionOf(response.stop);
-    if (!stopsTable.has(response.stop)) errors.push(`${rel('response/response.json')}: stop ${response.stop} is not in the Stops table of ${op.id}`);
+    // UNKNOWN_STOP is the one code no operator declares: the orchestrator writes it when it meets a code the merged registry does not list.
+    if (response.stop !== 'UNKNOWN_STOP' && !stopsTable.has(response.stop)) errors.push(`${rel('response/response.json')}: stop ${response.stop} is not in the Stops table of ${op.id}`);
     if (d === null) errors.push(`${rel('response/response.json')}: stop ${response.stop} is not a registered code ${op.id} may emit`);
     else if (d !== 'terminate') errors.push(`${rel('response/response.json')}: ${response.stop} has disposition fallback under these requirements; the step should have continued`);
   }
@@ -121,7 +123,16 @@ export async function validateResponse(root, dir, { requirements = {}, exchange
     for (const c of taken) if (!declaredTaken.has(c)) errors.push(`${rel('response/response.md')}: Fallbacks taken lists ${c}, which response.json does not`);
     for (const c of declaredTaken) if (!taken.includes(c)) errors.push(`${rel('response/response.json')}: fallback ${c} is not recorded under ## Fallbacks taken in response.md`);
   }
-  for (const nextId of response.next ?? []) if (nextId !== 'user' && nextId !== 'external' && !packages.some((p) => p.manifest.id === nextId)) errors.push(`${rel('response/response.json')}: next names unknown operator ${nextId}`);
+  // next names only what the operator's own Next table offers (or user / external); a workflow cannot add a hand-off the operator does not declare.
+  const nextTable = new Set((op.tables.next?.rows ?? []).map((r) => unquote(r.operator)));
+  for (const nextId of response.next ?? []) {
+    if (nextId === 'user' || nextId === 'external') continue;
+    if (!packages.some((p) => p.manifest.id === nextId)) errors.push(`${rel('response/response.json')}: next names unknown operator ${nextId}`);
+    else if (!nextTable.has(nextId)) errors.push(`${rel('response/response.json')}: next names ${nextId}, which the Next table of ${op.id} does not offer`);
+  }
+  // A stand-in is recorded as a pair: the profile operator.json binds and the profile that actually ran.
+  if ((response.boundProfile === undefined) !== (response.ranProfile === undefined)) errors.push(`${rel('response/response.json')}: boundProfile and ranProfile are recorded together or not at all`);
+  if (response.boundProfile !== undefined && response.boundProfile !== pkg.manifest.resources?.profile) errors.push(`${rel('response/response.json')}: boundProfile ${response.boundProfile} is not the profile ${op.id} binds (${pkg.manifest.resources?.profile})`);
   if (exchange && (response.next ?? []).length) errors.push(`${rel('response/response.json')}: a nested exchange does not route; next must be empty`);
   return { errors, response, present, pkg };
 }

package/scripts/validate-step.mjs

@@ -12,7 +12,8 @@ import { loadOperatorPackages, exchangeOf } from './operator-md.mjs';
 import { loadKindTemplates } from './validate-templates.mjs';
 import { loadErrorsRegistry } from './errors-registry.mjs';
 
-const unquote = (s) => String(s ?? '').trim().replace(/^`|`$/g, '');
+// Only a fully quoted cell is unquoted: a sentence that opens with a code span keeps its backticks.
+const unquote = (s) => { const t = String(s ?? '').trim(); return /^`[^`]*`$/.test(t) ? t.slice(1, -1) : t; };
 
 export async function validateStep(root, branchDir) {
   const packages = await loadOperatorPackages(root);

package/scripts/validate-workflows.mjs

@@ -11,12 +11,15 @@ import { fileURLToPath } from 'node:url';
 import { loadOperatorPackages, cellAliases, kindOf, isYes } from './operator-md.mjs';
 import { loadAliasRegistry, baseOf } from './alias-registry.mjs';
 
-const unquote = (s) => String(s ?? '').trim().replace(/^`|`$/g, '');
+// Only a fully quoted cell is unquoted: a sentence that opens with a code span keeps its backticks.
+const unquote = (s) => { const t = String(s ?? '').trim(); return /^`[^`]*`$/.test(t) ? t.slice(1, -1) : t; };
 
 export async function validateWorkflows(root) {
   const errors = [];
   const packages = (await loadOperatorPackages(root)).filter((p) => p.shape === 'v9');
   const aliases = (await loadAliasRegistry(root)).aliases;
+  // Fields the orchestrator fills from the session or the mission scope: neither preset nor asked (resources/orchestrator.json#agent.fills).
+  const fills = new Set(JSON.parse(await readFile(path.join(root, 'resources', 'orchestrator.json'), 'utf8')).agent?.fills ?? []);
   const ops = new Map(packages.map((p) => {
     const op = p.en;
     const writes = new Set();
@@ -26,6 +29,8 @@ export async function validateWorkflows(root) {
     for (const r of op.tables.context?.rows ?? []) { const a = cellAliases(r.alias)[0]; const m = a && /^@workspaces\/(fe|be)\b/.exec(a); if (m && isYes(r.required)) roles.add(m[1]); }
     return [p.manifest.id, {
       fields: new Set((op.tables.requirements?.rows ?? []).map((r) => unquote(r.field))),
+      // Fields with no Default: the workflow presets them or declares under asks who supplies them before the branch starts.
+      mustSupply: (op.tables.requirements?.rows ?? []).filter((r) => r.default.trim().startsWith('—')).map((r) => unquote(r.field)),
       required: (op.tables.inputs?.rows ?? []).filter((r) => isYes(r.required)).map((r) => kindOf(r.kind)),
       outputs: new Set((op.tables.outputs?.rows ?? []).map((r) => kindOf(r.kind))),
       next: new Set((op.tables.next?.rows ?? []).map((r) => unquote(r.operator))),
@@ -67,6 +72,8 @@ export async function validateWorkflows(root) {
         if (!op) { errors.push(`${at}: unknown operator ${b.operator}`); return; }
         if (!positions.has(b.operator)) positions.set(b.operator, n);
         for (const key of Object.keys(b.requirements ?? {})) if (!op.fields.has(key)) errors.push(`${at}: requirement ${key} is not a field of ${b.operator}`);
+        for (const key of b.asks ?? []) { if (!op.fields.has(key)) errors.push(`${at}: asks ${key}, which is not a field of ${b.operator}`); else if (key in (b.requirements ?? {})) errors.push(`${at}: asks ${key} and presets it`); else if (fills.has(key)) errors.push(`${at}: asks ${key}, which the orchestrator fills`); }
+        for (const key of op.mustSupply) if (!fills.has(key) && !(key in (b.requirements ?? {})) && !(b.asks ?? []).includes(key)) errors.push(`${at}: ${b.operator} requires ${key} (no Default); preset it or list it under asks`);
         for (const kind of op.required) if (!produced.has(kind)) errors.push(`${at}: ${b.operator} requires input ${kind}, which no earlier step produces`);
         // A required @workspaces/<role> context needs a workspace.bind of that role in an earlier step.
         if (b.operator !== 'workspace.bind') for (const role of op.roles) if (!boundRoles.has(role)) errors.push(`${at}: ${b.operator} requires @workspaces/${role}, which no earlier workspace.bind (role ${role}) bound`);

package/templates/kinds/architecture-decision.contract.json

@@ -8,6 +8,7 @@
     { "heading": "^## Boundaries$", "table": "| Boundary | Responsibility | Owner | Interfaces | Owns data |", "minRows": 1, "cell": { "Owns data": "^(yes|no)$" } },
     { "heading": "^## Data ownership$", "table": "| Store | Owning boundary | Writers | Readers | Migrators | Transaction scope | Backup | Restore |" },
     { "heading": "^## Stack delta$", "table": "| Component | Status | Justification | Evidence | Compatibility |", "minRows": 1, "cell": { "Status": "^(existing|added|replaced|removed|replaced-candidate)$", "Justification": "^(measured-constraint|observed-evidence|requirement-fit|—)$" } },
+    { "heading": "^## Operations$", "table": "| Operation | Transport | Writer | Stores | Transaction | Idempotency | Dimensions |", "minRows": 1, "cell": { "Transport": "^(graphql-mutation|graphql-query|rest|worker|cron|event-consumer)$", "Transaction": "^(single-transaction|per-item|read-only|none)$", "Idempotency": "^(none|natural-key|request-token|event-id)$", "Dimensions": "^[a-z0-9][a-z0-9-]*(?:, [a-z0-9][a-z0-9-]*)*$" } },
     { "heading": "^## Handoff$", "table": "| Item | Kind | Detail |", "minRows": 1, "cell": { "Kind": "^(invariant|risk|contract|migration|rollback|proof|unknown)$" } },
     { "heading": "^## Fallbacks taken$", "table": "| Code | Action |", "cell": { "Code": "^`[A-Z][A-Z0-9_]+`$" } }
   ]

package/templates/kinds/architecture-decision.skeleton.md

@@ -39,6 +39,12 @@
 | --- | --- | --- | --- | --- |
 | `component-id` | existing | measured-constraint | `path@head` | 5/5 verified, or the axes still unknown |
 
+## Operations
+
+| Operation | Transport | Writer | Stores | Transaction | Idempotency | Dimensions |
+| --- | --- | --- | --- | --- | --- | --- |
+| `operation-id` | graphql-mutation | `src/features/api/core/graphql/mutations/handler.ts` | `store-id` | single-transaction | request-token | effective-access |
+
 ## Handoff
 
 | Item | Kind | Detail |

package/templates/kinds/backend-source-application.contract.json

@@ -3,7 +3,7 @@
   "title": "^# backend-source-application — [a-z0-9][a-z0-9-]*$",
   "sections": [
     { "heading": "^## Binding$", "table": "| Field | Value |", "rows": ["Outcome", "Feature", "Contract fingerprint", "Base", "Branch", "Commit"], "cell": { "Value": "\\S" } },
-    { "heading": "^## Operations$", "table": "| Operation | Transport | Writer | Transaction | Idempotency | Decisions |", "minRows": 1, "cell": { "Transport": "^(graphql-mutation|graphql-query|rest|worker|cron|event-consumer)$", "Transaction": "^(single-transaction|per-item|read-only|none)$", "Idempotency": "^(none|natural-key|request-token|event-id)$", "Decisions": "^BA-[0-9]+(?:, BA-[0-9]+)*$" } },
+    { "heading": "^## Operations$", "table": "| Operation | Transport | Writer | Transaction | Idempotency | Decisions |", "minRows": 1, "cell": { "Transport": "^(graphql-mutation|graphql-query|rest|worker|cron|event-consumer)$", "Transaction": "^(single-transaction|per-item|read-only|none)$", "Idempotency": "^(none|natural-key|request-token|event-id)$", "Decisions": "^[a-z0-9][a-z0-9-]*(?:, [a-z0-9][a-z0-9-]*)*$" } },
     { "heading": "^## Changes$", "table": "| Path | Change | Operation | Before | After |", "minRows": 1, "cell": { "Change": "^(added|modified|deleted)$", "Before": "^(sha256:[0-9a-f]{64}|—)$", "After": "^(sha256:[0-9a-f]{64}|—)$" } },
     { "heading": "^## Findings$", "table": "| Code | Operation | File | Statement |", "cell": { "Code": "^`(PATTERN_BOUND|NEW_CONVENTION_REFUSED|SNAPSHOT_REVALIDATED|MIGRATION_INCLUDED|EXCEPTION_IDENTITY_REUSED|BUSINESS_QUESTION_RAISED)`$", "Statement": "\\S" } }
   ]

package/templates/kinds/backend-source-application.skeleton.md

@@ -19,7 +19,7 @@ the conformance and proof records that measure it live beside it in `response/da
 
 | Operation | Transport | Writer | Transaction | Idempotency | Decisions |
 | --- | --- | --- | --- | --- | --- |
-| `operation-id` | graphql-mutation | `src/features/api/core/graphql/mutations/handler.ts` | single-transaction | request-token | BA-1 |
+| `operation-id` | graphql-mutation | `src/features/api/core/graphql/mutations/handler.ts` | single-transaction | request-token | effective-access |
 
 ## Changes
 

package/templates/kinds/frontend-presentation-resolution.contract.json

@@ -4,7 +4,7 @@
   "sections": [
     { "heading": "^## Owner map$", "table": "| Node | Property | Owner | Rule |", "minRows": 1, "cell": { "Node": "^`[^`]+`$", "Owner": "^(app|grammar)$", "Rule": "^`[A-Z][A-Z0-9-]*-[0-9]+`$" } },
     { "heading": "^## Rules chosen$", "table": "| Node | Rule | Class | Condition |", "minRows": 1, "cell": { "Node": "^`[^`]+`$", "Rule": "^`[A-Z][A-Z0-9-]*-[0-9]+`$", "Class": "^`[^`]+`$", "Condition": "\\S" } },
-    { "heading": "^## Removed$", "table": "| Node | Class | Because |", "cell": { "Node": "^`[^`]+`$", "Because": "^(reimplements an owned relationship|overrides Grammar anatomy|off the closed scale)$" } },
+    { "heading": "^## Removed$", "table": "| Node | Class | Because |", "cell": { "Node": "^`[^`]+`$", "Because": "^(reimplements an owned relationship|overrides Grammar anatomy|off the closed scale|refused by [A-Z][A-Z0-9-]*-[0-9]+ Case [0-9]+)$" } },
     { "heading": "^## Gaps$", "table": "| Node | Property | Missing path |", "cell": { "Node": "^`[^`]+`$", "Missing path": "\\S" } },
     { "heading": "^## Fallbacks taken$", "table": "| Code | Action |", "cell": { "Code": "^`[A-Z][A-Z0-9_]+`$" } }
   ]

package/templates/kinds/frontend-presentation-resolution.skeleton.md

@@ -18,6 +18,7 @@
 | Node | Class | Because |
 | --- | --- | --- |
 | `body>main>div[0]>section` | `p-4` | reimplements an owned relationship |
+| `body>main>div[0]>section>span` | `text-accent-soft-foreground` | refused by SURFACE-4 Case 2 |
 
 ## Gaps