@starci/skills 1.1.0

package/operators/backend-source-apply/errors.json

@@ -0,0 +1,66 @@
+{
+  "schemaVersion": 9,
+  "note": "Stop codes only backend.source.apply emits. Same entry shape as operators/errors.json, scope implicit. Shared codes (INVALID_INPUT, SOURCE_DRIFT, NO_PROGRESS) come from operators/errors.json, and OWNER_CONFLICT is not defined here because frontend.presentation.resolve emits it too: a code two operators emit belongs in operators/errors.json with both ids in scope. Every domain below is the one the old package's owningDomain enum published for this operator: backend, business, contract, platform, workspace, caller. `contract` is a routing domain of its own, answered with a person, and it is not spelled caller: the person who reopens a frozen contract is not the person who wrote the request.",
+  "codes": {
+    "CONTRACT_UNFROZEN": {
+      "domain": "contract",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The mutation contract is not frozen, or its fingerprint is stale.",
+        "vi": "Contract mutation chưa đóng băng, hoặc fingerprint của nó đã cũ."
+      },
+      "resume": {
+        "en": "Bring the frozen contract.",
+        "vi": "Mang contract đã đóng băng tới."
+      }
+    },
+    "CONTRACT_WIDENED": {
+      "domain": "contract",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "The outcome cannot be reached without a boundary the contract does not carry.",
+        "vi": "Không đạt được kết quả nếu không có một ranh giới mà contract không mang."
+      },
+      "resume": {
+        "en": "The contract owner reopens and refreezes the contract, then the same outcome is implemented again.",
+        "vi": "Chủ contract mở lại và đóng băng lại contract, rồi cài đặt lại cùng kết quả đó."
+      }
+    },
+    "BUSINESS_AUTHORITY_MISSING": {
+      "domain": "business",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A business question is open and no approved decision settles it.",
+        "vi": "Một câu hỏi nghiệp vụ còn mở và không quyết định đã duyệt nào giải nó."
+      },
+      "resume": {
+        "en": "Publish the decision and rebind the authority fingerprint.",
+        "vi": "Publish quyết định và ràng lại fingerprint thẩm quyền."
+      }
+    },
+    "PATTERN_UNBOUND": {
+      "domain": "backend",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A touched aspect has no sibling family bound for it.",
+        "vi": "Một khía cạnh bị chạm không có họ anh em nào được ràng cho nó."
+      },
+      "resume": {
+        "en": "Bind the missing pattern; guessing the family from memory is refused.",
+        "vi": "Ràng pattern còn thiếu; đoán họ từ trí nhớ bị từ chối."
+      }
+    },
+    "PROOF_UNAVAILABLE": {
+      "domain": "platform",
+      "disposition": "terminate",
+      "meaning": {
+        "en": "A declared proof could not be executed in this environment.",
+        "vi": "Một proof đã khai không chạy được trong môi trường này."
+      },
+      "resume": {
+        "en": "Provide a working proof environment; a proof that could not run never becomes a pass.",
+        "vi": "Cung cấp môi trường chạy proof; một proof không chạy được không bao giờ thành pass."
+      }
+    }
+  }
+}

package/operators/backend-source-apply/operator.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 9,
+  "id": "backend.source.apply",
+  "domain": "backend",
+  "job": "Implement one backend outcome inside a frozen mutation contract, following the observed sibling family, and return the measured conformance and proof receipt that shows the boundary was not widened.",
+  "package": "operator.md",
+  "errors": "errors.json",
+  "validator": "validate.mjs",
+  "selfTest": "self-test.mjs",
+  "resources": {
+    "profile": "luna",
+    "grammarBound": false,
+    "tools": {
+      "@tools/fileread": "context-aliases",
+      "@tools/sourcewrite": "declared-write-set",
+      "@tools/git": "commit-session-branch",
+      "@tools/shell": "declared-commands"
+    }
+  }
+}

package/operators/backend-source-apply/operator.md

@@ -0,0 +1,189 @@
+# backend.source.apply
+
+## Job
+
+Implement one backend outcome inside a frozen mutation contract, following the observed sibling
+family, and return the measured conformance and proof receipt that shows the boundary was not widened.
+
+## The contract is frozen before the first write
+
+The contract arrives as the Input `architecture-decision`, fingerprinted and closed. The operations,
+writers, stores, transaction boundaries, idempotency kinds, and migrations it lists are the complete
+set the implementation may touch, and this operator answers only one question per operation: does the
+code that now exists do exactly what the contract says, and what measurement shows it. The operations
+are not a Requirement, because a person retyping a contract into a request is how the contract and
+the implementation quietly diverge; step 3 reads them from the frozen input and restates them in
+`response/data/mutations.json`. Three prohibitions carry that, and each is enforced rather than
+advised. An operation, writer, store, transaction, migration, or event outside the contract is
+`CONTRACT_WIDENED`, returned to the contract owner before any product write. A file outside the
+mutable ceiling is `OWNER_CONFLICT`, even when the change there would be one line. A convention no
+bound sibling pattern publishes is refused and recorded as `NEW_CONVENTION_REFUSED`, while an aspect
+with no pattern at all is `PATTERN_UNBOUND`. Discovering mid-implementation that the outcome needs a
+wider boundary is the expected way this operator ends, not a failure of nerve: the contract is
+reopened by its owner and the same outcome is implemented again against the new fingerprint. Reaching
+outside the list is not a smaller change than reopening the contract; it is the same change made
+without a record.
+
+## The person's branch is never written
+
+This operator never writes on the branch a person has checked out. The orchestrator prepares a
+dedicated git worktree of the routed checkout on the session branch `session/<sessionId>`, cut from
+the frozen head, and step 3 writes there and nowhere else, under an exclusive lease on
+`@workspaces/be`. The final step commits the whole declared write set once, records that sha in
+`response.json.commits`, and names the same sha in `response/data/mutations.json` as `commit` beside
+the `base` it started from and the `branch` it lives on; `response/changes.md` states the same move in
+its Binding row, `@workspaces/be` at `<base>` → `<sha>` on `session/<sessionId>`. One commit, because
+a step whose work arrives as several commits cannot be pinned by the next step's request, and an
+uncommitted write cannot be pinned at all. Nothing is pushed and nothing is merged here: `git.publish`
+merges the session branch into the target branch, and it is the only operator that talks to a remote.
+
+## Dry mode writes the plan, not the tree
+
+`mode` decides whether this run touches the checkout at all. Under `apply` the operator fills the
+contract, commits once, and everything below holds as written. Under `dry` it does the same reading,
+the same binding and the same projection, then stops after the plan: `response/data/mutations.json`
+carries the operations it would fill and the files it would touch with `commit` null and no after
+hash, `response.json` records no commit, and not one byte reaches `@workspaces/be`. The branch still
+ends `done`, because a plan honestly produced is a finished answer to a question about a plan; its
+`changes.md` lists every planned path as `unchanged`, which is what the working tree actually shows,
+and names the change it would have made in `Why`. A dry run measures nothing, so it carries no
+conformance record and no proof record: a facet cannot be measured on code that was never written,
+and a plan that shipped verdicts would be indistinguishable from an implementation. That is also why
+a dry run can never be the run that satisfies the contract — it is a way to read the write set before
+paying for it, not a cheaper way to apply it.
+
+## The backend never invents business behaviour
+
+Every operation cites the approved decisions it implements. When the code reaches a point where the
+answer depends on a business rule nobody approved, the branch stops with `BUSINESS_AUTHORITY_MISSING`
+and names the open question. It does not pick the lenient reading, mirror what a neighbouring feature
+happens to do, or choose whichever branch makes the test go green. This is the most load-bearing rule
+in the operator, because a guessed business rule that passes its own test is indistinguishable from an
+approved one once it ships. An implemented receipt therefore cannot carry a `BUSINESS_QUESTION_RAISED`
+finding: raising the question and implementing anyway is the exact contradiction the check exists to
+catch.
+
+## Sibling patterns are the only source of convention
+
+The bound patterns name one family per aspect, and the implementation mirrors the family the codebase
+already publishes rather than the one it remembers: command handlers in the family the mutation layer
+already uses, exceptions derived from the published exception identity, entity access through the
+injected primary entity manager, migrations under the primary datasource. Two families bound for one
+aspect means no family is bound, and guessing the family from memory is how a second house style
+enters a codebase unnoticed.
+
+## Conformance is measured, not asserted
+
+A conformance record without evidence is a sentence about the code, and a sentence cannot contradict
+the code. Each declared facet of each operation gets its own file,
+`response/data/conformance/<operationId>.<facet>.json`, so a facet nobody measured is a missing file
+rather than a missing line inside a file that still looks complete. The evidence is what a later
+reader uses to disagree with this receipt, so it is required for every facet including the ones that
+passed. The same reasoning makes a proof carry its command, its exit code and its output in
+`response/data/proofs/<operationId>.<kind>.json`: the command says what was run and the result says
+what came back, and either one alone can be written by someone who ran nothing. A proof that could not
+run never becomes an assertion that the behaviour is fine, and a failed proof blocks the receipt
+rather than being reclassified. Each touched file carries one change record with its kind and its
+before and after hashes, because a modified file whose two hashes agree records a mutation that did
+not happen.
+
+## Boundary
+
+The operator writes product source only inside the mutable file ceiling, only inside the session
+branch worktree of `@workspaces/be`, and writes everything else into `response/` of its own branch:
+`response.md`, `response/changes.md`, `response/data/mutations.json`, one conformance record per
+declared facet, one proof record per declared proof, and `response.json`. It never adds an operation,
+writer, store, transaction, migration, or event the frozen contract does not carry, decides a business
+rule the approved authority does not state, introduces a convention no bound sibling pattern
+publishes, weakens, skips, suppresses, or substitutes a declared proof to make a run go green, edits
+the contract, the business authority, or a file outside the mutable ceiling, commits more than once,
+writes on the person's checked-out branch, pushes, merges, or tags anything, claims conformance
+without naming the evidence that measured it, or records a quality, visual, or UAT verdict; those are
+other jobs with their own gates.
+
+## Context
+
+| Alias | Bind | Required |
+| --- | --- | --- |
+| `@worktrees/businesses/<featureId>` | the published business head, the only source of business behaviour | yes |
+| `@knowledge/patterns/be` | the sibling families this change mirrors, one per aspect; the only source of valid conventions | yes |
+| `@workspaces/be` | the routed backend checkout at the frozen head, written only on its session branch worktree | yes |
+
+## Inputs
+
+| Kind | From | Required |
+| --- | --- | --- |
+| `architecture-decision` | `architecture.decide`; the frozen mutation contract the implementation fills and may not widen | yes |
+| `backend-source-application` | a prior run of `backend.source.apply` for the same outcome; regression history, absent on the first run | no |
+
+## Requirements
+
+| Field | Type | Default | Ask |
+| --- | --- | --- | --- |
+| `featureId` | id | — | The feature whose published business head decides this behaviour |
+| `outcome` | prompt | — | The one thing being implemented, in the person's words |
+| `mutableFileRefs` | list | — | The only files product source may be written into |
+| `mode` | choice | apply | `apply` fills the contract and commits, `dry` emits the plan and writes nothing |
+| `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 | `resume`, `mode` | `request/request.json`, input `backend-source-application` when present, @workspaces/be at the frozen head | — | `INVALID_INPUT`, `SOURCE_DRIFT`, `NO_PROGRESS` |
+| 2 | Bind authority, contract and patterns | `featureId` | @worktrees/businesses/<featureId> at its published head, input `architecture-decision` as the frozen contract, @knowledge/patterns/be one pattern per aspect | — | `CONTRACT_UNFROZEN`, `BUSINESS_AUTHORITY_MISSING`, `PATTERN_UNBOUND` |
+| 3 | Fill one contract operation at a time, on the session branch | `mutableFileRefs` | @knowledge/patterns/be for each aspect, @workspaces/be inside the mutable ceiling | @workspaces/be/branch/session inside the mutable ceiling, under an exclusive lease, @tools/sourcewrite | `CONTRACT_WIDENED`, `OWNER_CONFLICT` |
+| 4 | Check every mutation against the frozen contract and record it with its before and after hash | `mode` | @workspaces/be, the touched files and the frozen contract | `response/data/mutations.json` | — |
+| 5 | Revalidate persisted snapshots on read | — | @workspaces/be, the persisted snapshot, @knowledge/patterns/be for the rules that drift after it | — | — |
+| 6 | Prove each declared facet | — | @workspaces/be, the measurement behind each facet | `response/data/conformance/<operationId>.<facet>.json` | — |
+| 7 | Run each declared proof | — | @workspaces/be, the pinned command of each declared proof kind | `response/data/proofs/<operationId>.<proofKind>.json`, @tools/shell | `PROOF_UNAVAILABLE` |
+| 8 | Commit the write set once, write the receipt and emit | `outcome` | everything above | @workspaces/be/branch/session as one commit, `response/changes.md`, `response/response.md`, `response/response.json`, @tools/git | — |
+
+Under `mode = dry` step 3 projects the fill onto the declared paths without writing one of them, step
+4 records that projection as the plan with a null commit and no after hash, steps 5 to 7 have nothing
+to measure and produce nothing, and step 8 emits the receipt and the change record without a commit.
+Under `apply` every step runs as written. The routed head is reverified immediately before the first
+product write, so drift found there stops the branch before anything is written. Filling an operation writes the transport, the validation, the
+authorization check, the data access, and the failure paths into the declared writer and the files the
+change genuinely requires; it refuses loudly and early rather than dropping a case silently, raising
+the exception the exception-identity pattern publishes before any row or external checkout is created.
+When the outcome persists a workflow, session, cart, draft, or other snapshot, usability is enforced
+again where it is read, reconciled server side, in stable order, with indexes remapped atomically and
+an explicit terminal state when nothing actionable remains, and recorded as `SNAPSHOT_REVALIDATED`. A
+resume begins again at step 1, reuses only unchanged fingerprinted observations, and consumes the exact
+delta; an approved business decision arrives as a new authority fingerprint, because the same
+fingerprint cannot yield a different answer.
+
+## Outputs
+
+| Kind | File | Type | Required |
+| --- | --- | --- | --- |
+| `backend-source-application` | `response/response.md` | md | yes |
+| `changes` | `response/changes.md` | md | yes |
+| `mutations` | `response/data/mutations.json` | data | yes |
+| `conformance` | `response/data/conformance/<operationId>.<facet>.json` | data | no |
+| `proof` | `response/data/proofs/<operationId>.<proofKind>.json` | data | no |
+
+## Stops
+
+| Code | Disposition |
+| --- | --- |
+| `INVALID_INPUT` | terminate |
+| `SOURCE_DRIFT` | terminate |
+| `NO_PROGRESS` | terminate |
+| `CONTRACT_UNFROZEN` | terminate |
+| `CONTRACT_WIDENED` | terminate |
+| `BUSINESS_AUTHORITY_MISSING` | terminate |
+| `OWNER_CONFLICT` | terminate |
+| `PATTERN_UNBOUND` | terminate |
+| `PROOF_UNAVAILABLE` | terminate |
+
+## Next
+
+| When | Operator |
+| --- | --- |
+| the contract is filled and the gates the change record names must run | `quality.verify` |
+| the promise must be reconciled against the source that was delivered | `business.decide` |
+| the contract is filled and a frontend surface must consume it | `frontend.direction.decide` |
+| a file needing mutation lies outside the routed write ceiling | `workspace.bind` |
+| a declared proof cannot be executed in this environment | `platform.operate` |

package/operators/backend-source-apply/operator.vi.md

@@ -0,0 +1,185 @@
+# backend.source.apply
+
+## Việc
+
+Cài đặt một kết quả backend bên trong một contract mutation đã đóng băng, theo đúng họ anh em quan
+sát được, và trả về biên nhận conformance cùng proof đo được cho thấy ranh giới không bị nới ra.
+
+## Contract đóng băng trước lần ghi đầu tiên
+
+Contract tới dưới dạng Đầu vào `architecture-decision`, có fingerprint và đã đóng. Các operation,
+writer, store, ranh giới giao dịch, kiểu idempotency và migration mà nó liệt kê là tập đầy đủ mà phần
+cài đặt được chạm, và operator này chỉ trả lời một câu hỏi cho mỗi operation: đoạn code đang tồn tại
+có làm đúng điều contract nói không, và phép đo nào cho thấy điều đó. Các operation không phải một
+Yêu cầu, vì việc một người gõ lại contract vào request chính là cách contract và phần cài đặt lặng lẽ
+tách nhau; bước 3 đọc chúng từ đầu vào đã đóng băng và ghi lại vào `response/data/mutations.json`. Ba
+điều cấm gánh phần đó, và mỗi điều được cưỡng chế chứ không phải khuyên. Một operation, writer, store,
+giao dịch, migration hay event nằm ngoài contract là `CONTRACT_WIDENED`, trả về cho chủ contract trước
+mọi lần ghi vào sản phẩm. Một file ngoài trần file được sửa là `OWNER_CONFLICT`, kể cả khi thay đổi ở
+đó chỉ một dòng. Một quy ước mà không pattern anh em nào đã ràng công bố thì bị từ chối và ghi lại là
+`NEW_CONVENTION_REFUSED`, còn một khía cạnh không có pattern nào cả là `PATTERN_UNBOUND`. Phát hiện
+giữa chừng rằng kết quả cần một ranh giới rộng hơn là cách kết thúc dự kiến của operator này, không
+phải sự nhụt chí: chủ contract mở lại và đóng băng lại, rồi cùng kết quả ấy được cài đặt lại theo
+fingerprint mới. Với tay ra ngoài danh sách không phải là thay đổi nhỏ hơn việc mở lại contract; nó là
+cùng một thay đổi nhưng không có dấu vết.
+
+## Không bao giờ ghi lên nhánh của người
+
+Operator này không bao giờ ghi lên nhánh mà một người đang checkout. Orchestrator chuẩn bị một git
+worktree riêng của checkout được route trên nhánh phiên `session/<sessionId>`, cắt từ head đã đóng
+băng, và bước 3 ghi ở đó chứ không ở đâu khác, dưới một lease độc quyền trên `@workspaces/be`. Bước
+cuối commit toàn bộ tập ghi đã khai đúng một lần, ghi sha ấy vào `response.json.commits`, và nêu cùng
+sha ấy trong `response/data/mutations.json` ở trường `commit`, cạnh `base` nó xuất phát và `branch` nó
+sống trên đó; `response/changes.md` nói đúng bước chuyển ấy ở hàng Binding, `@workspaces/be` tại
+`<base>` → `<sha>` trên `session/<sessionId>`. Một commit, vì một bước mà công việc tới dưới dạng nhiều
+commit thì bước sau không pin được trong request của nó, còn một lần ghi chưa commit thì không pin
+được chút nào. Ở đây không push và không merge gì cả: `git.publish` merge nhánh phiên vào nhánh đích,
+và nó là operator duy nhất nói chuyện với remote.
+
+## Chế độ dry ghi bản kế hoạch, không ghi cây
+
+`mode` quyết lượt chạy này có chạm vào checkout hay không. Dưới `apply`, operator điền contract,
+commit một lần, và mọi điều bên dưới đúng y như đã viết. Dưới `dry`, nó vẫn đọc, vẫn ràng, vẫn chiếu
+đúng như vậy, rồi dừng ngay sau bản kế hoạch: `response/data/mutations.json` mang những operation nó
+sẽ điền và những file nó sẽ chạm, với `commit` rỗng và không hash sau, `response.json` không ghi
+commit nào, và không một byte nào tới `@workspaces/be`. Nhánh vẫn kết thúc `done`, vì một bản kế
+hoạch làm thật thà là một câu trả lời trọn vẹn cho một câu hỏi về kế hoạch; `changes.md` của nó liệt
+mọi path đã định là `unchanged`, đúng như cây làm việc đang cho thấy, và nêu thay đổi nó sẽ làm ở cột
+`Why`. Một lượt dry không đo gì cả, nên nó không mang bản ghi conformance và không mang bản ghi
+proof: không thể đo một facet trên đoạn code chưa từng được viết, và một bản kế hoạch mà ship kèm
+phán quyết thì không phân biệt nổi với một lần cài đặt thật. Đó cũng là lý do một lượt dry không bao
+giờ là lượt thoả contract — nó là cách đọc trước tập ghi trước khi trả giá cho nó, không phải một
+cách áp dụng rẻ hơn.
+
+## Backend không bao giờ bịa hành vi nghiệp vụ
+
+Mỗi operation dẫn các quyết định đã duyệt mà nó cài đặt. Khi đoạn code tới chỗ câu trả lời phụ thuộc
+vào một luật nghiệp vụ chưa ai duyệt, nhánh dừng với `BUSINESS_AUTHORITY_MISSING` và nêu tên câu hỏi
+còn mở. Nó không chọn cách đọc dễ dãi, không bắt chước feature bên cạnh tình cờ làm gì, và không chọn
+nhánh nào làm test xanh. Đây là luật gánh nặng nhất của operator, vì một luật nghiệp vụ đoán ra mà qua
+được test của chính nó thì không phân biệt nổi với một luật đã duyệt một khi đã ship. Vì vậy một biên
+nhận đã cài đặt không thể mang finding `BUSINESS_QUESTION_RAISED`: nêu câu hỏi rồi vẫn cài đặt chính
+là mâu thuẫn mà phép kiểm này sinh ra để bắt.
+
+## Pattern anh em là nguồn quy ước duy nhất
+
+Các pattern đã ràng nêu một họ cho mỗi khía cạnh, và phần cài đặt bắt chước họ mà codebase đang công
+bố chứ không phải họ mà nó nhớ: command handler theo họ mà tầng mutation đang dùng, exception dẫn xuất
+từ định danh exception đã công bố, truy cập entity qua entity manager chính được tiêm, migration dưới
+datasource chính. Hai họ cùng ràng cho một khía cạnh nghĩa là không họ nào được ràng, và đoán họ từ
+trí nhớ chính là cách một kiểu nhà thứ hai lọt vào codebase mà không ai để ý.
+
+## Conformance là đo được, không phải khẳng định
+
+Một bản ghi conformance không có bằng chứng chỉ là một câu nói về đoạn code, và một câu nói không mâu
+thuẫn nổi với code. Mỗi facet đã khai của mỗi operation có file riêng,
+`response/data/conformance/<operationId>.<facet>.json`, nên một facet không ai đo là một file thiếu
+chứ không phải một dòng thiếu bên trong một file trông vẫn đầy đủ. Bằng chứng là thứ người đọc sau
+dùng để phản đối biên nhận này, nên nó bắt buộc cho mọi facet, kể cả những facet đã qua. Cùng lý lẽ ấy
+khiến một proof phải mang câu lệnh, mã thoát và output trong
+`response/data/proofs/<operationId>.<kind>.json`: câu lệnh nói đã chạy gì và kết quả nói cái gì trả
+về, còn mỗi thứ đứng một mình đều có thể do người chưa chạy gì viết ra. Một proof không chạy được
+không bao giờ trở thành khẳng định rằng hành vi vẫn ổn, và một proof hỏng chặn biên nhận chứ không
+được phân loại lại. Mỗi file bị chạm mang một bản ghi thay đổi kèm loại và hash trước/sau, vì một file
+sửa mà hai hash bằng nhau ghi lại một mutation không hề xảy ra.
+
+## Ranh giới
+
+Operator chỉ ghi source sản phẩm bên trong trần file được sửa, chỉ bên trong worktree nhánh phiên của
+`@workspaces/be`, và ghi mọi thứ khác vào `response/` của nhánh mình: `response.md`,
+`response/changes.md`, `response/data/mutations.json`, một bản ghi conformance cho mỗi facet đã khai,
+một bản ghi proof cho mỗi proof đã khai, và `response.json`. Nó không bao giờ thêm một operation,
+writer, store, giao dịch, migration hay event mà contract đóng băng không mang, không quyết một luật
+nghiệp vụ mà thẩm quyền đã duyệt không nói, không đưa vào một quy ước mà không pattern anh em nào công
+bố, không làm yếu, bỏ qua, chặn hay thay thế một proof đã khai để một lượt chạy thành xanh, không sửa
+contract, thẩm quyền nghiệp vụ hay một file ngoài trần được sửa, không commit quá một lần, không ghi
+lên nhánh mà người đang checkout, không push, merge hay tag gì, không tuyên bố conformance mà không
+nêu bằng chứng đã đo nó, và không ghi phán quyết chất lượng, thị giác hay UAT; đó là những việc khác
+với cổng riêng của chúng.
+
+## Context
+
+| Alias | Bind | Bắt buộc |
+| --- | --- | --- |
+| `@worktrees/businesses/<featureId>` | head nghiệp vụ đã publish, nguồn duy nhất của hành vi nghiệp vụ | có |
+| `@knowledge/patterns/be` | các họ anh em mà thay đổi này bắt chước, mỗi khía cạnh một họ; nguồn quy ước hợp lệ duy nhất | có |
+| `@workspaces/be` | checkout backend được route ở head đóng băng, chỉ ghi trên worktree nhánh phiên của nó | có |
+
+## Đầu vào
+
+| Kind | Từ đâu | Bắt buộc |
+| --- | --- | --- |
+| `architecture-decision` | `architecture.decide`; contract mutation đã đóng băng mà phần cài đặt điền vào và không được nới | có |
+| `backend-source-application` | một lượt chạy trước của `backend.source.apply` cho cùng kết quả; lịch sử hồi quy, vắng mặt ở lần đầu | không |
+
+## Yêu cầu
+
+| Field | Kiểu | Mặc định | Hỏi |
+| --- | --- | --- | --- |
+| `featureId` | id | — | Feature mà head nghiệp vụ đã publish của nó quyết hành vi này |
+| `outcome` | prompt | — | Một thứ duy nhất đang được cài đặt, bằng lời của người dùng |
+| `mutableFileRefs` | list | — | Những file duy nhất mà source sản phẩm được ghi vào |
+| `mode` | choice | apply | `apply` điền contract rồi commit, `dry` chỉ phát bản kế hoạch và không ghi gì |
+| `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 và chạy lại | `resume`, `mode` | `request/request.json`, đầu vào `backend-source-application` nếu có, @workspaces/be ở head đóng băng | — | `INVALID_INPUT`, `SOURCE_DRIFT`, `NO_PROGRESS` |
+| 2 | Ràng thẩm quyền, contract và pattern | `featureId` | @worktrees/businesses/<featureId> ở head đã publish, đầu vào `architecture-decision` làm contract đóng băng, @knowledge/patterns/be mỗi khía cạnh một pattern | — | `CONTRACT_UNFROZEN`, `BUSINESS_AUTHORITY_MISSING`, `PATTERN_UNBOUND` |
+| 3 | Điền từng operation của contract, trên nhánh phiên | `mutableFileRefs` | @knowledge/patterns/be cho từng khía cạnh, @workspaces/be trong trần được sửa | @workspaces/be/branch/session trong trần được sửa, dưới một lease độc quyền, @tools/sourcewrite | `CONTRACT_WIDENED`, `OWNER_CONFLICT` |
+| 4 | Đối chiếu mọi mutation với contract đóng băng và ghi nó kèm hash trước và sau | `mode` | @workspaces/be, các file bị chạm và contract đóng băng | `response/data/mutations.json` | — |
+| 5 | Kiểm lại snapshot đã lưu khi đọc | — | @workspaces/be, snapshot đã lưu, @knowledge/patterns/be cho các luật trôi sau nó | — | — |
+| 6 | Chứng minh từng facet đã khai | — | @workspaces/be, phép đo đứng sau mỗi facet | `response/data/conformance/<operationId>.<facet>.json` | — |
+| 7 | Chạy từng proof đã khai | — | @workspaces/be, câu lệnh đã pin của mỗi kiểu proof đã khai | `response/data/proofs/<operationId>.<proofKind>.json`, @tools/shell | `PROOF_UNAVAILABLE` |
+| 8 | Commit tập ghi đúng một lần, viết biên nhận và phát | `outcome` | mọi thứ ở trên | @workspaces/be/branch/session thành một commit, `response/changes.md`, `response/response.md`, `response/response.json`, @tools/git | — |
+
+Dưới `mode = dry`, bước 3 chiếu phần điền lên các path đã khai mà không ghi lấy một path nào, bước 4
+ghi bản chiếu ấy thành kế hoạch với commit rỗng và không hash sau, bước 5 tới 7 không có gì để đo nên
+không phát ra gì, và bước 8 phát biên nhận cùng bản ghi thay đổi mà không có commit. Dưới `apply`,
+mọi bước chạy đúng như đã viết. Head được route được kiểm lại ngay trước lần ghi sản phẩm đầu tiên, nên trôi head phát hiện ở đó dừng
+nhánh trước khi có gì được ghi. Điền một operation là viết transport, phần kiểm tra hợp lệ, phần kiểm
+quyền, phần truy cập dữ liệu và các đường lỗi vào writer đã khai cùng những file mà thay đổi thực sự
+đòi; nó từ chối to và sớm chứ không im lặng bỏ rơi một trường hợp, ném ra exception mà pattern định
+danh exception công bố trước khi có dòng nào hay checkout ngoài nào được tạo. Khi kết quả lưu một
+workflow, phiên, giỏ, bản nháp hay snapshot khác, tính dùng được lại được cưỡng chế ở nơi nó được
+đọc, đối chiếu phía server, theo thứ tự ổn định, với chỉ mục ánh xạ lại nguyên tử và một trạng thái
+kết thúc tường minh khi không còn gì để làm, và được ghi là `SNAPSHOT_REVALIDATED`. 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
+quyết định nghiệp vụ đã duyệt tới dưới dạng một fingerprint thẩm quyền mới, vì cùng một fingerprint
+không thể cho một câu trả lời khác.
+
+## Đầu ra
+
+| Kind | File | Kiểu | Bắt buộc |
+| --- | --- | --- | --- |
+| `backend-source-application` | `response/response.md` | md | có |
+| `changes` | `response/changes.md` | md | có |
+| `mutations` | `response/data/mutations.json` | data | có |
+| `conformance` | `response/data/conformance/<operationId>.<facet>.json` | data | không |
+| `proof` | `response/data/proofs/<operationId>.<proofKind>.json` | data | không |
+
+## Dừng
+
+| Code | Xử lý |
+| --- | --- |
+| `INVALID_INPUT` | terminate |
+| `SOURCE_DRIFT` | terminate |
+| `NO_PROGRESS` | terminate |
+| `CONTRACT_UNFROZEN` | terminate |
+| `CONTRACT_WIDENED` | terminate |
+| `BUSINESS_AUTHORITY_MISSING` | terminate |
+| `OWNER_CONFLICT` | terminate |
+| `PATTERN_UNBOUND` | terminate |
+| `PROOF_UNAVAILABLE` | terminate |
+
+## Kế tiếp
+
+| Khi | Operator |
+| --- | --- |
+| contract đã điền xong và các cổng mà bản ghi thay đổi nêu tên phải chạy | `quality.verify` |
+| lời hứa phải được đối chiếu với source đã giao | `business.decide` |
+| contract đã điền xong và một bề mặt frontend phải tiêu thụ nó | `frontend.direction.decide` |
+| một file cần sửa nằm ngoài trần ghi được route | `workspace.bind` |
+| một proof đã khai không chạy được trong môi trường này | `platform.operate` |