{"schema":1,"harness":"codex","locale":"en","bundleDigest":"ead91feb6c331757bdbf6c24aad8426a1b965e90a240716c0a939678acc61d3d","files":[{"path":".agents/skills/grace-discover-codebase/SKILL.md","kind":"file","content":"---\nname: grace-discover-codebase\ndescription: \"Grace project onboarding: use this as soon as `grace_prepare_task` returns no active talent. Do not write code. Read the project, ask the developer to confirm your architecture hypotheses, then propose a list of talents and install them after explicit approval.\"\n---\n\n# Project discovery — procedure\n\nThe old onboarding asked five blind questions (project type, language, architecture, testing\napproach and domain), concatenated the answers and matched that string against talent keywords.\nNo model read the project, and a talent whose triggers did not match the developer's words was\nnever found.\n\nThis procedure replaces that approach. **You** read the project and derive the answers to each\naxis from files that prove them. The developer confirms or corrects them in a question call, and\n**you** infer the talents. Nothing is activated without an explicit “yes”.\n\n## Output discipline — absolute\n\nThis procedure has exactly four possible visible outputs throughout its execution, and nothing\nelse:\n\n1. the question call(s) in phase 3 — one or more if the drift inventory does not fit in a\n single call, but nothing between calls;\n2. the list of talents in phase 6;\n3. the installation request in phase 7, immediately following the list;\n4. the single phase-6 line when no talent survives phase 4 — it replaces outputs 2 and 3,\n and the procedure stops.\n\nOutput 3 requests permission before a write. It is not a closing comment; the prohibition\nbelow does not apply to it. Omitting it would leave discovery without effect.\n\nEverything else — reconnaissance, hypotheses, evidence, contradictions, near misses and\nverdicts — is internal reasoning. Do not print or summarize it, or introduce or follow any of\nthe outputs with a comment, progress note, count or suggestion. No “I analyzed…”, no\n“here is…”. If you want to say something outside those four outputs, say nothing.\n\n## Phase 1 — Reconnaissance\n\nTarget: the path supplied by the user, otherwise the current working directory.\n\nRead in this order, and stop as soon as your hypotheses are supported:\n\n1. Manifests and configuration: `package.json`, `tsconfig.json`, `go.mod`,\n `pyproject.toml`, `pom.xml`, `Cargo.toml`, lockfiles, `docker-compose*.yml`,\n CI workflows.\n2. Shape: the directory tree two or three levels deep, excluding `node_modules`/`dist`/\n `.git`. Note the **actual vocabulary** (`domain/`, `services/`, `models/`,\n `handlers/`, `usecases/`…); you will use it for phase-4 queries.\n3. Entry points: the manifest's `main`/`scripts` targets and the first files in the\n largest source directory.\n4. Tests: their locations, runner, unit/integration division and naming.\n5. Three to five representative source files in different directories. **Read them\n completely.** This is where the real signal is.\n\nRead only: write nothing and run nothing.\n\n## Phase 2 — Hypotheses\n\nProduce three to six hypotheses. Each has:\n\n- **claim** — one sentence answering an onboarding axis (project type, language/stack,\n architecture, testing approach, domain);\n- **evidence** — two or three `path/file.ts:42` references and what they show. A\n hypothesis without a file is a guess: discard it or label it `low`;\n- **confidence** — `high` | `medium` | `low`;\n- **question** — the single question that would decide it, framed so that “no” is useful.\n\nState each hypothesis in the **project's vocabulary**, never naming a talent. Mapping to\ntalents belongs to phase 4 and nowhere earlier.\n\n### The trap to avoid\n\nDo not infer architecture from the very surface the audit will evaluate. “There is a\n`domain/` directory, therefore the architecture is hexagonal” proves nothing: it would\ngrade the project against a convention it might not actually follow.\n\nThe informative signals are where **the code contradicts itself**:\n\n- a `domain/` directory importing Express, Prisma, `fs` or anything performing I/O;\n- a one-implementation port duplicated by a path that bypasses it;\n- a layer imported by everything that, in turn, imports everything;\n- tests booting the entire app to test a pure function;\n- competing words for the same concept in different directories;\n- a configuration declaring something the project has neither installed nor connected.\n\nAlways include at least one hypothesis of this kind if you find one, phrased neutrally\n(“`user/domain/account.ts:12` imports the Prisma client — should the domain stay\ndependency-free here?”). Such hypotheses are worth confirming and will also be the first\ndrifts reported by the audit.\n\n### Drift inventory\n\nThe other hypotheses answer an axis and stop at three to six. Drifts are different: they\nform a **list**, which must be **exhaustive** — each drift the developer does not see becomes\na violation you decided for them.\n\nDo not stop at one. Scan the project for every place where code contradicts itself, and\nrecord each as a separate item:\n\n- **what** — one sentence naming the symptom in project vocabulary;\n- **where** — exact `path/file.ts:42` lines. A drift without a line reference does not\n count: discard it;\n- **why it is a drift** — the invariant or boundary it violates.\n\nDo not group or judge items at this stage. Do not drop an “obviously intentional” drift:\nthat decision belongs to the developer in phase 3, and collecting that decision is the\npoint of the phase. Ten drifts is normal in a real repository. If you found only one,\nyou have not scanned thoroughly enough.\n\n## Phase 3 — Reverse prompting\n\nKeep the hypotheses to yourself. The first thing the developer sees throughout the\nprocedure is the question call: no table, preamble or dump of evidence.\n\nAsk questions in batches (no more than four per call), most discriminating first. A\ncertain hypothesis that distinguishes nothing is not worth a question. Options must be\nconcrete and mutually exclusive, and one must be your most likely correction, rather\nthan just “yes”/“no”.\n\nPriority: architecture, then drift inventory, testing approach, domain, project type.\nThe language and stack can be read from the manifest; never ask for them.\n\n### Drift questions are a checklist, not a choice\n\nAxis questions are single-choice: the developer selects one answer. Drifts are the\nopposite. Each item from the phase-2 inventory must reach the developer as **its own\ncheckbox** with a fixed meaning:\n\n> **checked = tolerated.** A checked item is deliberate and must **never** be reported\n> as a violation. An unchecked item is a violation to fix.\n\nState this rule in the text of the question itself, each time, in these terms.\nIt is the only framing the developer cannot infer from the options.\n\nConstruction rules:\n\n- always **multi-select**. Never collapse drifts into one “how should we handle all of this”\n question or ask “is this a drift?” separately for every item;\n- **one option for every drift.** An inventory is not a selection. Eleven drifts found\n means eleven options presented;\n- question calls allow at most four options per question and four questions per call:\n a complete inventory may span multiple calls. Group by broken boundary (application\n layer, domain encapsulation, vocabulary and boundaries, typing and tests) and use the\n group title. Beyond sixteen items, make another call instead of truncating;\n- the option title briefly names the symptom. Its description carries the evidence:\n `file.ts:42` lines and what they contain. The developer decides on evidence; a\n description without a line reference is a broken option;\n- never preselect, rank or edit a comment. “Obviously intentional” is not yours to decide.\n\nIf the host has no question-call tool, do not improvise and do not abandon the inventory\nor its semantics. Print the numbered drifts as text, one per line, each with line evidence;\nstate the rule in the same terms (**cited = tolerated**, everything else is a violation\nto fix), and ask the developer to cite the numbers they tolerate. This list then stands\nin for the question call in the output discipline: the format changes, not the question.\n\nRecord the checked set as tolerated. It does not select a talent by itself, but shows\nwhich confirmed drifts remain; any unchecked drift is live evidence for the talent\ncovering it in phase 4.\n\nIf the developer corrects you, do not argue or acknowledge it in prose. Silently record\nthe correction, abandon what it invalidates and proceed directly to phase 4.\n\n## Phase 4 — Map hypotheses to talents\n\nThe entire catalog is appended to this procedure: an ID and summary per talent.\nThere is nothing else to fetch. You translate between project vocabulary and catalog\nvocabulary: a hypothesis phrased in the project's words (`handlers`, `usecases`)\ndoes not automatically match a talent saying `adapters`.\n\nThe appendix contains only IDs and summaries. A non-active talent's manifest remains\nclosed: no `languages`, `status`, `agents` or dependency graph. Choose based on the\nsummary; phase 5 handles everything related to the graph.\n\nWork by hypothesis, never by catalog: answer “what covers this confirmed fact?”, not\n“which of these talents could be useful?”. Make one pass per confirmed hypothesis, plus\none per non-tolerated drift. For each candidate, keep its ID, the hypothesis it serves,\nand the line of evidence behind that hypothesis. Exclude:\n\n- a talent whose summary targets a stack the project does not use;\n- a talent unsupported by any confirmed hypothesis. If you cannot connect it to one,\n it does not belong in the selection, however sensible it sounds;\n- a duplicate: when two talents cover the same hypothesis, keep the one whose summary\n uses the project's own words.\n\nKeep near misses in your reasoning; do not print them.\n\n## Phase 5 — Close the graph\n\nThe catalog is a graph, not a list: hard prerequisites (`requires`), incompatibilities\n(`conflicts`) and complements (`recommends`). These edges are **not** visible here,\nbecause inactive talents' manifests are closed.\n\nDo not guess or invent IDs to fill gaps: close the graph after application, with\n`grace_doctor`, which reports missing prerequisites and conflicts against the actually\nactive selection. Phase 6 therefore outputs the **direct** selection justified by\neach confirmed hypothesis and nothing more.\n\n## Phase 6 — Output\n\nThe phase-4 selection, as a flat list, and nothing else:\n\n```\n- \n- \n```\n\nOne ID per line. No heading, table, evidence column, count, rejected IDs, verdict or\nsentence before the list. Copy IDs exactly as the appendix spells them. Go straight\nto phase 7 with nothing between the two.\n\nIf none survives phase 4, print one line saying no talent matches and stop — there\nis nothing to install.\n\n## Phase 7 — Install\n\nThe list does nothing until it is applied, and you are the one to apply it. Do not\nleave it to the developer to ask: immediately after the list, ask whether they want\nto install these talents. One question, two outcomes, no vague third option.\n\nIf “yes”, call `grace_install_talents({ talents: [\"\", …] })` — a list of bare IDs,\none per chosen talent, no objects or flags — in a single atomic call/revision.\nThen call `grace_doctor`, which reports missing prerequisites and conflicts from\nthe actually active selection, unavailable to you in phase 5. If it reports any,\npresent them the same way and apply the additional selection in a second\n`grace_install_talents` call after approval.\n\nOn “no” or silence, write nothing and do not insist. Discovery ends here.\n\n## Appendix — The catalog\n\nOne talent per line: its ID and summary. This is the only catalog view during\nonboarding and it is enough for phase 4. Never print it: the output discipline\napplies to it too.\n\n_(The catalog index is not in this file: it depends on the project and changes as talents are published. Call `grace_discover_codebase` to get it — the response contains this same procedure, including the index.)_\n\n\n","sha256":"47c00720da6cbd694f2184828679b4a30c50cb4ed3f113c5f1e7f426634deaa7","bytes":11993,"previous":[{"sha256":"fec606973727a3f049589c140617744d7830241b32455e1e21603cc5e0d8b4d8","bytes":13826,"release":"v4.14.0"},{"sha256":"47c00720da6cbd694f2184828679b4a30c50cb4ed3f113c5f1e7f426634deaa7","bytes":11993,"release":"v4.14.0"},{"sha256":"1c847b7b32e4e2f1c8d9b4a05ec9061a1eb51200fad8dace0efe6774c77d8992","bytes":11994,"release":"v4.13.0"}]},{"path":".agents/skills/grace-effort/SKILL.md","kind":"file","content":"---\nname: grace-effort\ndescription: \"Show or change my Grace review level: auto, low, medium or high. The level guides the harness’s choice of model and reasoning.\"\nargument-hint: \"[auto|low|medium|high]\"\n---\n\nUse only an invocation method offered by the client: a command such as /grace-effort, a reference such as $grace-effort, or the skill picker. Available methods depend on the client; never invent a command it does not offer. This skill is distinct from the existing grace-effort MCP prompt: keep that prompt.\n\n1. Read the invocation argument. Without an argument, call grace_get_effort({}), display the personal preference, its revision and returned minimums, then stop without writing. Display returned values; never infer Auto from a missing response.\n2. With exactly auto, low, medium or high, first call grace_get_effort({}). Keep preference.revision, then call grace_set_effort({ effort: \"\", revision: , semantics: \"review_level_v2\" }). Never use a project/organization revision or a stale revision from context. If reading fails or supplies no revision, do not write.\n3. Any other argument is invalid: show the four accepted values without changing the preference. In Plan or read-only mode, display the setting and requested change without calling grace_set_effort.\n4. On a revision conflict, reread grace_get_effort({}), explain the newly observed setting and unapplied request, then stop. Never retry automatically or overwrite the concurrent change. An authorization or isolation denial stays a denial; do not switch organizations or identities to bypass it.\n5. After success, display the returned preference and new revision. Auto is always adaptive: the coordinator selects model and reasoning while honoring applicable review minimums, then passes them when launching each reviewer. This requested setting does not confirm a reviewer’s actual configuration or execution. Do not change project/organization minimums or the client’s native settings.\n\n","sha256":"ed049e4ba0449f7c2052330b52cbe391ccf00361a577b2c9d3589c44bb3107f4","bytes":2013,"previous":[]},{"path":".agents/skills/grace-review/scripts/review-client.py","kind":"file","content":"#!/usr/bin/env python3\n\"\"\"Offline exhaustive Grace review client; Python 3.10+, standard library only.\n\nRequests: OPERATION --input JSON_FILE. Exact v1 request keys are in REQUESTS.\nArtifact paths are explicit, local, absolute paths without links. Coordinator-owned\ndirectories must not be writable by untrusted users. Reviewer identity is supplied\nby the calling harness, never extracted from the untrusted response.\n\"\"\"\n\nimport argparse\nimport difflib\nfrom contextlib import contextmanager\nimport hashlib\nimport json\nimport os\nfrom pathlib import Path\nimport re\nimport stat\nimport subprocess\nimport sys\nimport uuid\n\n\nVERSION = \"grace-audit-packet-v2\"\n# inline-v1 plans keep identities and digests only: no rule body or Custom instruction on disk.\nINLINE_VERSION = \"grace-review-inline-v1\"\nCLIENT_VERSION = \"1.2\"\nPACKET_LIMIT = 65536\nPACKET_TARGET = 32768\nARTIFACT_LIMIT = 64 * 1024 * 1024\nOUTPUT_LIMIT = 8192\nHASH = re.compile(r\"[0-9a-f]{64}\\Z\")\nCOMMIT = re.compile(r\"[0-9a-f]{40}(?:[0-9a-f]{24})?\\Z\")\nPACKET_KEYS = \"reviewId packetId resolutionId packetHash maxPacketBytes files entries talentIds rulesDigests obligationIds dependencies\"\nREQUESTS = {\n \"capture\": \"schemaVersion repository changeSource outputDirectory\",\n \"manifest\": \"schemaVersion capture outputDirectory\",\n \"pack\": \"schemaVersion manifest plan assignments outputDirectory\",\n \"verify\": \"schemaVersion packet expected dependencies state range\",\n \"accept\": \"schemaVersion state expectedStateHash response reviewer submissionId arbitration repair\",\n \"invalidate\": \"schemaVersion state expectedStateHash current currentStateHash upstreamChanges attempts\",\n}\n\n\nclass Refusal(Exception):\n def __init__(self, code, message):\n super().__init__(message)\n self.code = code\n\n\ndef require(condition, code, message):\n if not condition:\n raise Refusal(code, message)\n\n\ndef closed(value, keys):\n require(type(value) is dict and set(value) == set(keys.split()),\n \"schema\", \"Expected the documented closed object; check missing or unknown keys.\")\n\n\ndef v1(value):\n require(type(value) is int and value == 1, \"version\", \"Only schemaVersion 1 is supported.\")\n\n\ndef string(value):\n require(type(value) is str and value.strip() and \"\\0\" not in value,\n \"string\", \"Expected a nonblank string without NUL.\")\n try:\n value.encode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"utf8\", \"Invalid Unicode scalar; provide strict UTF-8.\") from None\n return value\n\n\ndef digest(value):\n require(type(value) is str and HASH.fullmatch(value), \"digest\", \"Expected bare lowercase SHA-256.\")\n return value\n\n\ndef identifier(value):\n string(value)\n try:\n parsed = uuid.UUID(value)\n except ValueError:\n raise Refusal(\"uuid\", \"Expected a UUID identifier.\") from None\n require(str(parsed) == value and parsed.version in range(1, 9), \"uuid\", \"Expected a canonical UUID.\")\n return value\n\n\ndef array(value):\n require(type(value) is list, \"schema\", \"Expected an array.\")\n return value\n\n\ndef ordered(values):\n array(values)\n for value in values:\n string(value)\n require(values == sorted(set(values)), \"order\", \"Expected unique strings in Unicode scalar order.\")\n return values\n\n\ndef sha(data):\n return hashlib.sha256(data).hexdigest()\n\n\ndef encoded(value):\n try:\n return json.dumps(value, ensure_ascii=False, separators=(\",\", \":\"), allow_nan=False).encode(\"utf-8\")\n except (UnicodeError, ValueError, TypeError, RecursionError):\n raise Refusal(\"json\", \"Object cannot be serialized as strict UTF-8 JSON.\") from None\n\n\ndef unique_pairs(items):\n result = {}\n for key, value in items:\n require(key not in result, \"duplicate_key\", \"Duplicate JSON keys are forbidden.\")\n result[key] = value\n return result\n\n\ndef parse(data, limit=ARTIFACT_LIMIT):\n require(len(data) <= limit, \"size\", \"Input exceeds its trusted byte limit; split the review explicitly.\")\n try:\n value = json.loads(data.decode(\"utf-8\", \"strict\"), object_pairs_hook=unique_pairs,\n parse_constant=lambda _: (_ for _ in ()).throw(ValueError()))\n encoded(value) # Reject escaped unpaired surrogates too.\n return value\n except (UnicodeError, ValueError, RecursionError):\n raise Refusal(\"json\", \"Expected unambiguous strict UTF-8 JSON, without nonfinite numbers.\") from None\n\n\ndef local_path(value, exists=True):\n string(value)\n path = Path(value)\n require(path.is_absolute() and \"..\" not in path.parts, \"path\", \"Use an absolute local path without traversal.\")\n for item in reversed([path, *path.parents]):\n try:\n info = item.lstat()\n except FileNotFoundError:\n require(not exists and item == path, \"path\", \"Parent directory or input is missing.\")\n continue\n require(not stat.S_ISLNK(info.st_mode) and not getattr(info, \"st_file_attributes\", 0) & 0x400,\n \"path\", \"Links and reparse points require manual review.\")\n require(stat.S_ISDIR(info.st_mode) or (item == path and stat.S_ISREG(info.st_mode) and info.st_nlink == 1),\n \"path\", \"Only ordinary files and directories are supported; no hardlinks.\")\n return path\n\n\ndef windows_handle(path, directory=False, create=False, write=False):\n # Denying FILE_SHARE_DELETE pins each opened component against rename/removal.\n # OPEN_REPARSE_POINT opens the link itself, which is rejected before use.\n import ctypes\n from ctypes import wintypes\n kernel = ctypes.WinDLL(\"kernel32\", use_last_error=True)\n kernel.CreateFileW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, ctypes.c_void_p,\n wintypes.DWORD, wintypes.DWORD, wintypes.HANDLE]\n kernel.CreateFileW.restype = wintypes.HANDLE\n kernel.CloseHandle.argtypes = [wintypes.HANDLE]\n kernel.CloseHandle.restype = wintypes.BOOL\n kernel.GetFileInformationByHandleEx.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD]\n kernel.GetFileInformationByHandleEx.restype = wintypes.BOOL\n class Attributes(ctypes.Structure):\n _fields_ = [(\"attributes\", wintypes.DWORD), (\"tag\", wintypes.DWORD)]\n access = 0x80 if directory else (0x40000000 if write else 0x80000000)\n handle = kernel.CreateFileW(str(path), access, 3, None, 1 if create else 3, 0x00200000 | 0x02000000, None)\n if handle == wintypes.HANDLE(-1).value:\n raise ctypes.WinError(ctypes.get_last_error())\n try:\n info = Attributes()\n if not kernel.GetFileInformationByHandleEx(handle, 9, ctypes.byref(info), ctypes.sizeof(info)):\n raise ctypes.WinError(ctypes.get_last_error())\n require(not info.attributes & 0x400 and bool(info.attributes & 0x10) == directory,\n \"path\", \"Reparse points or unexpected file types require manual review.\")\n except BaseException:\n kernel.CloseHandle(handle)\n raise\n return handle, kernel\n\n\n@contextmanager\ndef anchored_parent(value):\n path = Path(value)\n string(str(value))\n require(path.is_absolute() and \"..\" not in path.parts, \"path\", \"Use an absolute local path without traversal.\")\n if os.name == \"nt\":\n require(len(path.drive) == 2 and path.drive[1] == \":\", \"path\", \"Only local drive paths are supported, never network/device paths.\")\n reserved = {\"CON\", \"PRN\", \"AUX\", \"NUL\", *(\"COM\" + str(n) for n in range(1, 10)), *(\"LPT\" + str(n) for n in range(1, 10))}\n require(all(\":\" not in part and not part.endswith((\" \", \".\")) and part.split(\".\")[0].upper() not in reserved\n for part in path.parts[1:]), \"path\", \"Windows device names, streams and ambiguous components are forbidden.\")\n handles = []\n try:\n for parent in reversed(path.parents):\n handles.append(windows_handle(parent, directory=True))\n yield path, {}\n finally:\n for handle, kernel in reversed(handles):\n kernel.CloseHandle(handle)\n else:\n require(os.open in os.supports_dir_fd and hasattr(os, \"O_NOFOLLOW\") and hasattr(os, \"O_DIRECTORY\"),\n \"capability\", \"Anchored filesystem operations unavailable; manual review required.\")\n fd = os.open(path.anchor, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)\n try:\n for part in path.parts[1:-1]:\n next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd)\n os.close(fd); fd = next_fd\n yield path.name, {\"dir_fd\": fd}\n finally:\n os.close(fd)\n\n\ndef open_anchored(name, parent, write=False, create=False):\n if os.name == \"nt\":\n import msvcrt\n handle, kernel = windows_handle(name, create=create, write=write)\n try:\n return msvcrt.open_osfhandle(handle, os.O_BINARY | os.O_NOINHERIT)\n except BaseException:\n kernel.CloseHandle(handle)\n raise\n flags = (os.O_WRONLY if write else os.O_RDONLY) | os.O_NOFOLLOW | os.O_NONBLOCK\n if create:\n flags |= os.O_CREAT | os.O_EXCL\n return os.open(name, flags, 0o600, **parent)\n\n\ndef read_anchored(name, parent, limit):\n fd = open_anchored(name, parent)\n with os.fdopen(fd, \"rb\") as stream:\n info = os.fstat(stream.fileno())\n require(stat.S_ISREG(info.st_mode) and info.st_nlink == 1, \"path\", \"Input must be an ordinary unlinked file.\")\n require(info.st_size <= limit, \"size\", \"Input exceeds its trusted byte limit before parsing.\")\n data = stream.read(limit + 1)\n require(len(data) <= limit, \"size\", \"Input grew beyond its trusted byte limit.\")\n return data\n\n\ndef read_bytes(value, limit=ARTIFACT_LIMIT):\n with anchored_parent(value) as (name, parent):\n return read_anchored(name, parent, limit)\n\n\ndef read_json(path, limit=ARTIFACT_LIMIT):\n return parse(read_bytes(path, limit), limit)\n\n\ndef new_directory(value):\n path = local_path(value, exists=False)\n with anchored_parent(path) as (name, parent):\n os.mkdir(name, mode=0o700, **parent) # Existing output is never replaced.\n return path\n\n\ndef write_new(path, data, readonly=False):\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"Artifact exceeds local byte limit.\")\n with anchored_parent(path) as (name, parent):\n fd = open_anchored(name, parent, write=True, create=True)\n with os.fdopen(fd, \"wb\") as stream:\n stream.write(data)\n stream.flush()\n os.fsync(stream.fileno())\n if readonly:\n if os.name == \"nt\":\n # The open non-delete-shared handle pins the final name too.\n os.chmod(name, 0o400)\n else:\n os.fchmod(stream.fileno(), 0o400)\n return {\"path\": str(path), \"bytes\": len(data), \"sha256\": sha(data)}\n\n\ndef frame(value):\n data = str(value).encode(\"utf-8\", \"strict\")\n return str(len(data)).encode(\"ascii\") + b\"\\0\" + data\n\n\ndef group(name, values):\n return frame(name) + frame(len(values)) + b\"\".join(frame(v) for v in values)\n\n\ndef entry_id(entry):\n return \"m-\" + sha(b\"\".join(frame(entry[k]) for k in (\"file\", \"kind\", \"content\")))\n\n\ndef packet_id(obligations):\n return \"p-\" + sha(group(\"obligationIds\", sorted(obligations)))\n\n\ndef packet_hash(packet):\n data = b\"\".join(frame(v) for v in (VERSION, packet[\"resolutionId\"], packet[\"packetId\"], PACKET_LIMIT))\n data += group(\"files\", packet[\"files\"])\n data += frame(\"entries\") + frame(len(packet[\"entries\"]))\n data += b\"\".join(frame(e[k]) for e in packet[\"entries\"] for k in (\"entryId\", \"file\", \"kind\", \"content\"))\n data += group(\"talentIds\", packet[\"talentIds\"])\n data += frame(\"rulesDigests\") + frame(len(packet[\"rulesDigests\"]))\n data += b\"\".join(frame(d[k]) for d in packet[\"rulesDigests\"] for k in (\"talentId\", \"rulesDigest\"))\n data += group(\"obligationIds\", packet[\"obligationIds\"])\n data += frame(\"dependencies\") + frame(len(packet[\"dependencies\"]))\n data += b\"\".join(frame(d[\"packetId\"]) + group(\"entryIds\", d[\"entryIds\"]) + group(\"obligationIds\", d[\"obligationIds\"])\n for d in packet[\"dependencies\"])\n return sha(data)\n\n\ndef git_path(value):\n string(value)\n require(not value.startswith((\"/\", \"\\\\\")) and \"\\\\\" not in value and \":\" not in value\n and all(p not in (\"\", \".\", \"..\", \".git\") for p in value.split(\"/\")),\n \"git_path\", \"Ambiguous or unsafe Git path; use manual review.\")\n return value\n\n\ndef decode_git_name(value):\n if not value.startswith('\"'):\n return value\n require(value.endswith('\"'), \"git_path\", \"Unterminated Git quoted path.\")\n raw = bytearray()\n body = value[1:-1]\n i = 0\n escapes = {\"a\": 7, \"b\": 8, \"t\": 9, \"n\": 10, \"v\": 11, \"f\": 12, \"r\": 13, '\"': 34, \"\\\\\": 92}\n while i < len(body):\n c = body[i]\n if c != \"\\\\\":\n raw.extend(c.encode(\"utf-8\")); i += 1\n else:\n i += 1\n require(i < len(body), \"git_path\", \"Incomplete Git escape.\")\n if body[i] in escapes:\n raw.append(escapes[body[i]]); i += 1\n else:\n octal = body[i:i + 3]\n require(len(octal) == 3 and all(c in \"01234567\" for c in octal) and int(octal, 8) <= 255,\n \"git_path\", \"Unsupported Git path escape.\")\n raw.append(int(octal, 8)); i += 3\n try:\n return raw.decode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"git_path\", \"Git path is not strict UTF-8.\") from None\n\n\ndef header_paths(line):\n body = line.removeprefix(\"diff --git \").rstrip(\"\\n\")\n # Git does not quote spaces, so accept exactly one unambiguous a/ -> b/ split.\n candidates = []\n for match in re.finditer(r' (?=b/|\"b/)', body):\n try:\n a, b = decode_git_name(body[:match.start()]), decode_git_name(body[match.end():])\n if a.startswith(\"a/\") and b.startswith(\"b/\"):\n candidates.append((git_path(a[2:]), git_path(b[2:])))\n except Refusal:\n pass\n require(len(candidates) == 1, \"git_path\", \"Ambiguous diff header path; manual review required.\")\n return candidates[0]\n\n\ndef manifest_entries(data):\n try:\n text = data.decode(\"utf-8\", \"strict\")\n except UnicodeError:\n raise Refusal(\"utf8\", \"Diff is not strict UTF-8; manual review required.\") from None\n require(\"\\0\" not in text, \"binary\", \"Binary diff is unsupported; manual review required.\")\n # splitlines also treats Unicode separators as lines: only LF is a Git boundary.\n lines = text.split(\"\\n\")\n lines = [line + \"\\n\" for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])\n blocks = []\n for line in lines:\n if line.startswith(\"diff --git \"):\n blocks.append([line])\n else:\n require(bool(blocks), \"diff\", \"Diff has data outside a Git file section.\")\n blocks[-1].append(line)\n entries = []\n for block in blocks:\n source, destination = header_paths(block[0])\n chunks = [[]]\n for line in block:\n if line.startswith(\"@@ \"):\n require(re.fullmatch(r\"@@ -\\d+(?:,\\d+)? \\+\\d+(?:,\\d+)? @@[^\\n]*\\n?\", line) is not None,\n \"diff\", \"Malformed unified hunk header.\")\n chunks.append([])\n elif line.startswith((\"@@@\", \"GIT binary patch\", \"Binary files \")):\n raise Refusal(\"binary\", \"Binary or combined diff requires manual review.\")\n chunks[-1].append(line)\n header = chunks[0]\n require(all(line.startswith((\"diff --git \", \"index \", \"old mode \", \"new mode \", \"new file mode \",\n \"deleted file mode \", \"similarity index \", \"dissimilarity index \",\n \"rename from \", \"rename to \", \"copy from \", \"copy to \", \"--- \", \"+++ \"))\n for line in header), \"diff\", \"Unsupported data in diff header; manual review required.\")\n for line in header:\n require(not re.search(r\"(?:^| )(120000|160000)(?:\\s|$)\", line),\n \"special_file\", \"Symlink/submodule changes require manual review.\")\n deleted = any(line.startswith(\"deleted file mode \") for line in header)\n file = source if deleted else destination\n for prefix, expected in ((\"--- \", \"/dev/null\" if any(l.startswith(\"new file mode \") for l in header) else \"a/\" + source),\n (\"+++ \", \"/dev/null\" if deleted else \"b/\" + destination)):\n names = [decode_git_name(line[len(prefix):].removesuffix(\"\\n\").removesuffix(\"\\t\")) for line in header if line.startswith(prefix)]\n require(len(names) <= 1 and (not names or names == [expected]), \"git_path\", \"Header paths disagree.\")\n for index, chunk in enumerate(chunks):\n if index:\n match = re.match(r\"@@ -\\d+(?:,(\\d+))? \\+\\d+(?:,(\\d+))? @@\", chunk[0])\n counts = [int(value) if value is not None else 1 for value in match.groups()]\n observed = [0, 0]\n previous_line = False\n for line in chunk[1:]:\n if line == \"\\\\ No newline at end of file\\n\":\n require(previous_line, \"diff\", \"Misplaced no-newline marker.\")\n previous_line = False\n continue\n require(line[:1] in (\"+\", \"-\", \" \"), \"diff\", \"Malformed hunk body.\")\n observed[0] += line[0] in (\"-\", \" \")\n observed[1] += line[0] in (\"+\", \" \")\n previous_line = True\n require(observed == counts, \"diff\", \"Hunk line counts disagree with its header.\")\n content = \"\".join(chunk)\n entry = {\"entryId\": \"\", \"file\": file, \"kind\": \"header\" if index == 0 else \"hunk\", \"content\": content}\n entry[\"entryId\"] = entry_id(entry)\n entries.append(entry)\n require(len({e[\"entryId\"] for e in entries}) == len(entries), \"duplicate_entry\", \"Identical manifest entries require manual review.\")\n require(b\"\".join(e[\"content\"].encode(\"utf-8\") for e in entries) == data, \"coverage\", \"Manifest does not cover exact diff bytes.\")\n return entries\n\n\ndef git(repo, *args, accepted=(0,)):\n env = {key: value for key, value in os.environ.items() if not key.startswith(\"GIT_\")}\n env.update(GIT_OPTIONAL_LOCKS=\"0\", GIT_TERMINAL_PROMPT=\"0\", GIT_CONFIG_NOSYSTEM=\"1\", GIT_NO_LAZY_FETCH=\"1\",\n GIT_ALLOW_PROTOCOL=\"\")\n # No shell, external diff, textconv, pager or network operations.\n with subprocess.Popen([\"git\", \"--no-replace-objects\", \"--no-pager\", \"-c\", \"core.quotePath=true\", \"-c\", \"core.fsmonitor=false\",\n \"-c\", \"core.autocrlf=false\", \"-c\", \"core.filemode=true\",\n \"-C\", str(repo), *args], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env) as process:\n data = process.stdout.read(ARTIFACT_LIMIT + 1)\n if len(data) > ARTIFACT_LIMIT:\n process.kill()\n status = process.wait()\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"Git output exceeds local artifact limit.\")\n require(status in accepted, \"git\", \"Git refused the capture; check repository, refs and index conflicts.\")\n return data\n\n\ndef resolve_commit(repo, ref):\n string(ref)\n require(not ref.startswith(\"-\"), \"ref\", \"A Git ref cannot be an option.\")\n value = git(repo, \"rev-parse\", \"--verify\", \"--end-of-options\", ref + \"^{commit}\").decode().strip()\n require(COMMIT.fullmatch(value), \"ref\", \"Expected a complete commit identity.\")\n return value\n\n\ndef git_index(repo):\n flags = git(repo, \"ls-files\", \"-v\", \"-z\").split(b\"\\0\")\n require(all(not item or (item[:1].isupper() and item[:1] != b\"S\") for item in flags),\n \"index_flags\", \"assume-unchanged or skip-worktree can hide changes; clear these flags or use manual review.\")\n # ls-files exposes intent-to-add as a normal empty blob. Compare two explicit\n # index-only views; neither consults the live worktree or runs its filters.\n options = (\"--cached\", \"--raw\", \"-z\", \"--no-abbrev\", \"--no-renames\", \"--no-ext-diff\", \"--no-textconv\",\n \"--ignore-submodules=none\")\n visible = git(repo, \"diff\", *options, \"--ita-visible-in-index\", \"HEAD\", \"--\")\n invisible = git(repo, \"diff\", *options, \"--ita-invisible-in-index\", \"HEAD\", \"--\")\n require(visible == invisible, \"intent_to_add\",\n \"Intent-to-add entries require staging actual content, clearing intent-to-add, or manual review.\")\n index = git(repo, \"ls-files\", \"--stage\", \"-z\")\n files = {}\n for item in index.split(b\"\\0\"):\n if not item:\n continue\n meta, name = item.split(b\"\\t\", 1)\n mode, oid, stage = meta.split()\n require(stage == b\"0\", \"conflict\", \"Unmerged index requires manual review.\")\n path = git_path(name.decode(\"utf-8\", \"strict\"))\n require(mode != b\"120000\", \"special_file\", \"Tracked symlinks require manual review.\")\n require(mode in (b\"100644\", b\"100755\", b\"160000\") and COMMIT.fullmatch(oid.decode(\"ascii\")),\n \"index\", \"Unsupported index entry; manual review required.\")\n files[path] = (mode, oid.decode(\"ascii\"))\n return index, files\n\n\ndef blob_hash(data, oid):\n algorithm = \"sha1\" if len(oid) == 40 else \"sha256\"\n return hashlib.new(algorithm, b\"blob \" + str(len(data)).encode() + b\"\\0\" + data).hexdigest()\n\n\ndef snapshot(repo, clean=False):\n index, entries = git_index(repo)\n files = {name: mode for name, (mode, _) in entries.items()}\n untracked = git(repo, \"ls-files\", \"--others\", \"--exclude-standard\", \"-z\").split(b\"\\0\")\n names = sorted(git_path(n.decode(\"utf-8\", \"strict\")) for n in untracked if n)\n for name in names:\n files[name] = b\"100644\"\n paths = sorted(files)\n for offset in range(0, len(paths), 256):\n attrs = git(repo, \"check-attr\", \"-z\", \"filter\", \"text\", \"eol\", \"working-tree-encoding\", \"ident\",\n \"--\", *paths[offset:offset + 256]).split(b\"\\0\")\n require(all(value in (b\"unspecified\", b\"unset\") for value in attrs[2::3]),\n \"filter\", \"Git filters or text conversions can alter bytes/execute code; use manual review.\")\n records = []\n for name, mode in sorted(files.items()):\n path = repo / name\n if not path.exists() and not path.is_symlink():\n require(mode != b\"160000\", \"submodule\", \"Missing submodule prevents complete capture; use manual review.\")\n require(not clean, \"submodule\", \"Dirty submodule has a missing tracked file; manual review required.\")\n records.append([name, \"missing\"])\n continue\n local_path(str(path))\n if mode == b\"160000\":\n snapshot(path, clean=True) # Raw blobs only; never status/diff against a live submodule worktree.\n subhead = resolve_commit(path, \"HEAD\")\n expected = entries[name][1]\n require(subhead == expected, \"submodule\", \"Submodule HEAD differs from index; manual review required.\")\n records.append([name, subhead])\n else:\n info = path.stat()\n data = read_bytes(str(path))\n if clean:\n require(name in entries and blob_hash(data, entries[name][1]) == entries[name][1]\n and (b\"100755\" if info.st_mode & stat.S_IXUSR else b\"100644\") == mode,\n \"submodule\", \"Dirty submodule content or mode requires manual review.\")\n records.append([name, info.st_mode, sha(data)])\n if clean:\n require(not names and not git(repo, \"diff\", *DIFF_OPTIONS, \"--cached\", \"HEAD\", \"--\"),\n \"submodule\", \"Dirty submodule index/untracked files require manual review.\")\n return {\"head\": resolve_commit(repo, \"HEAD\"), \"index\": sha(index), \"worktree\": sha(encoded(records)), \"untracked\": names}\n\n\nDIFF_OPTIONS = (\"--no-ext-diff\", \"--no-textconv\", \"--no-color\", \"--ignore-submodules=none\", \"--binary\", \"--full-index\", \"--src-prefix=a/\", \"--dst-prefix=b/\", \"--unified=3\")\n\n\ndef raw_worktree_diff(repo):\n # The live index stat cache and attributes never decide whether bytes changed.\n _, entries = git_index(repo)\n result = bytearray()\n for name, (mode, oid) in sorted(entries.items()):\n if mode == b\"160000\":\n continue # snapshot recursively proves these clean, or refuses capture.\n path = repo / name\n try:\n new = read_bytes(str(path))\n new_mode = b\"100755\" if path.stat().st_mode & stat.S_IXUSR else b\"100644\"\n except FileNotFoundError:\n new, new_mode = b\"\", None\n new_oid = \"0\" * len(oid) if new_mode is None else blob_hash(new, oid)\n if new_mode == mode and new_oid == oid:\n continue\n old = git(repo, \"cat-file\", \"blob\", oid)\n require(blob_hash(old, oid) == oid, \"object\", \"Index blob bytes disagree with their object identity.\")\n require(b\"\\0\" not in old and b\"\\0\" not in new, \"binary\", \"Changed binary requires manual review.\")\n old_text, new_text = old.decode(\"utf-8\", \"strict\"), new.decode(\"utf-8\", \"strict\")\n a, b = json.dumps(\"a/\" + name, ensure_ascii=False), json.dumps(\"b/\" + name, ensure_ascii=False)\n header = f\"diff --git {a} {b}\\n\"\n if new_mode is None:\n header += \"deleted file mode \" + mode.decode() + \"\\n\"\n elif mode != new_mode:\n header += \"old mode \" + mode.decode() + \"\\nnew mode \" + new_mode.decode() + \"\\n\"\n header += \"index \" + oid + \"..\" + new_oid + (\" \" + mode.decode() if mode == new_mode else \"\") + \"\\n\"\n if old != new:\n header += \"--- \" + a + \"\\n+++ \" + (\"/dev/null\" if new_mode is None else b) + \"\\n\"\n result.extend(header.encode())\n require(len(result) <= ARTIFACT_LIMIT, \"size\", \"Captured diff exceeds local artifact limit.\")\n def lines(text):\n pieces = text.split(\"\\n\")\n return [line + \"\\n\" for line in pieces[:-1]] + ([pieces[-1]] if pieces[-1] else [])\n # unified_diff's two pathname lines are already represented above.\n patch = iter(difflib.unified_diff(lines(old_text), lines(new_text), n=3, lineterm=\"\\n\"))\n next(patch, None); next(patch, None)\n for line in patch:\n result.extend(line.encode())\n if not line.endswith(\"\\n\"):\n result.extend(b\"\\n\\\\ No newline at end of file\\n\")\n require(len(result) <= ARTIFACT_LIMIT, \"size\", \"Captured diff exceeds local artifact limit.\")\n return bytes(result)\n\n\ndef capture(request):\n repo = local_path(request[\"repository\"])\n require(repo.is_dir() and Path(git(repo, \"rev-parse\", \"--show-toplevel\").decode().strip()) == repo,\n \"repository\", \"Capture must target the repository root.\")\n output = local_path(request[\"outputDirectory\"], exists=False)\n require(not output.is_relative_to(repo), \"output\", \"Keep review artifacts outside the captured repository.\")\n source = request[\"changeSource\"]\n require(type(source) is dict and source.get(\"kind\") in (\"local\", \"pr\"), \"source\", \"Specify local or pr provenance.\")\n parts = []\n if source[\"kind\"] == \"local\":\n closed(source, \"kind baseCommit\")\n base = resolve_commit(repo, source[\"baseCommit\"])\n require(base == source[\"baseCommit\"], \"source\", \"Local baseCommit must be the full immutable commit.\")\n before = snapshot(repo)\n parts = [(\"committed\", git(repo, \"diff\", *DIFF_OPTIONS, base, before[\"head\"], \"--\")),\n (\"index\", git(repo, \"diff\", *DIFF_OPTIONS, \"--cached\", before[\"head\"], \"--\")),\n (\"worktree\", raw_worktree_diff(repo))]\n for name in before[\"untracked\"]:\n content = read_bytes(str(repo / name))\n content.decode(\"utf-8\", \"strict\")\n require(b\"\\0\" not in content, \"binary\", \"Untracked binary requires manual review.\")\n a, b = json.dumps(\"a/\" + name, ensure_ascii=False), json.dumps(\"b/\" + name, ensure_ascii=False)\n mode = \"100755\" if (repo / name).stat().st_mode & stat.S_IXUSR else \"100644\"\n header = f\"diff --git {a} {b}\\nnew file mode {mode}\\n--- /dev/null\\n+++ {b}\\n\"\n if content:\n lines = content.split(b\"\\n\")\n count = len(lines) - (1 if not lines[-1] else 0)\n body = b\"\".join(b\"+\" + line + b\"\\n\" for line in lines[:-1])\n if lines[-1]:\n body += b\"+\" + lines[-1] + b\"\\n\\\\ No newline at end of file\\n\"\n header += f\"@@ -0,0 +1,{count} @@\\n\"\n parts.append((\"untracked\", header.encode() + body))\n else:\n parts.append((\"untracked\", header.encode()))\n after = snapshot(repo)\n require(before == after, \"concurrent_change\", \"Repository changed during capture; capture again after writers stop.\")\n provenance = {\"kind\": \"local\", \"repository\": str(repo), \"baseCommit\": base, \"headCommit\": before[\"head\"],\n \"before\": before, \"after\": after}\n else:\n closed(source, \"kind baseRef headRef baseCommit headCommit mergeBaseCommit\")\n base, head = resolve_commit(repo, source[\"baseRef\"]), resolve_commit(repo, source[\"headRef\"])\n merge = git(repo, \"merge-base\", \"--all\", base, head).decode().splitlines()\n require(len(merge) == 1 and [base, head, merge[0]] == [source[k] for k in (\"baseCommit\", \"headCommit\", \"mergeBaseCommit\")],\n \"source\", \"PR refs or merge base disagree with explicit provenance.\")\n parts = [(\"pr\", git(repo, \"diff\", *DIFF_OPTIONS, merge[0], head, \"--\"))]\n require(base == resolve_commit(repo, source[\"baseRef\"]) and head == resolve_commit(repo, source[\"headRef\"]),\n \"concurrent_change\", \"PR refs changed during capture.\")\n provenance = {**source, \"repository\": str(repo)}\n data = b\"\".join(part for _, part in parts)\n manifest_entries(data)\n segments = []\n offset = 0\n for kind, part in parts:\n segments.append({\"kind\": kind, \"offset\": offset, \"bytes\": len(part), \"sha256\": sha(part)})\n offset += len(part)\n directory = new_directory(str(output))\n diff = write_new(directory / \"full.diff\", data, readonly=True)\n captured = {\"schemaVersion\": 1, \"changeSource\": provenance, \"fullDiff\": diff, \"segments\": segments}\n artifact = write_new(directory / \"capture.json\", encoded(captured))\n return [artifact], {\"fullDiffHash\": diff[\"sha256\"], \"bytes\": len(data), \"segments\": len(segments)}\n\n\ndef check_descriptor(descriptor):\n closed(descriptor, \"path bytes sha256\")\n digest(descriptor[\"sha256\"])\n require(type(descriptor[\"bytes\"]) is int and 0 <= descriptor[\"bytes\"] <= ARTIFACT_LIMIT, \"size\", \"Invalid artifact size.\")\n data = read_bytes(descriptor[\"path\"])\n require(len(data) == descriptor[\"bytes\"] and sha(data) == descriptor[\"sha256\"], \"integrity\", \"Artifact bytes or hash changed.\")\n return data\n\n\ndef load_capture(path):\n captured = read_json(path)\n closed(captured, \"schemaVersion changeSource fullDiff segments\")\n v1(captured[\"schemaVersion\"])\n data = check_descriptor(captured[\"fullDiff\"])\n offset = 0\n for segment in array(captured[\"segments\"]):\n closed(segment, \"kind offset bytes sha256\")\n require(segment[\"kind\"] in (\"committed\", \"index\", \"worktree\", \"untracked\", \"pr\")\n and type(segment[\"offset\"]) is int and segment[\"offset\"] == offset\n and type(segment[\"bytes\"]) is int and segment[\"bytes\"] >= 0,\n \"source\", \"Invalid provenance segment.\")\n end = offset + segment[\"bytes\"]\n require(end <= len(data) and sha(data[offset:end]) == digest(segment[\"sha256\"]), \"source\", \"Provenance range changed.\")\n offset = end\n require(offset == len(data), \"coverage\", \"Provenance does not cover full diff.\")\n source = captured[\"changeSource\"]\n require(type(source) is dict and source.get(\"kind\") in (\"local\", \"pr\"), \"source\", \"Missing change source.\")\n if source[\"kind\"] == \"local\":\n closed(source, \"kind repository baseCommit headCommit before after\")\n for snapshot_value in (source[\"before\"], source[\"after\"]):\n closed(snapshot_value, \"head index worktree untracked\")\n require(snapshot_value[\"head\"] == source[\"headCommit\"], \"source\", \"Snapshot HEAD mismatch.\")\n digest(snapshot_value[\"index\"]); digest(snapshot_value[\"worktree\"])\n for name in ordered(snapshot_value[\"untracked\"]):\n git_path(name)\n require(source[\"before\"] == source[\"after\"], \"source\", \"Capture records concurrent changes.\")\n else:\n closed(source, \"kind repository baseRef headRef baseCommit headCommit mergeBaseCommit\")\n string(source[\"baseRef\"]); string(source[\"headRef\"])\n require(type(source[\"mergeBaseCommit\"]) is str and COMMIT.fullmatch(source[\"mergeBaseCommit\"]), \"source\", \"Invalid merge base.\")\n string(source[\"repository\"])\n for key in (\"baseCommit\", \"headCommit\"):\n require(type(source[key]) is str and COMMIT.fullmatch(source[key]), \"source\", \"Invalid source commit.\")\n return captured, data\n\n\ndef manifest(request):\n captured, data = load_capture(request[\"capture\"])\n entries = manifest_entries(data)\n result = {\"schemaVersion\": 1, \"capture\": request[\"capture\"], \"captureHash\": sha(encoded(captured)), \"entries\": entries}\n directory = new_directory(request[\"outputDirectory\"])\n artifact = write_new(directory / \"manifest.json\", encoded(result))\n return [artifact], {\"entries\": len(entries), \"fullDiffHash\": captured[\"fullDiff\"][\"sha256\"]}\n\n\ndef load_manifest(path):\n value = read_json(path)\n closed(value, \"schemaVersion capture captureHash entries\")\n v1(value[\"schemaVersion\"])\n captured, data = load_capture(value[\"capture\"])\n require(sha(encoded(captured)) == digest(value[\"captureHash\"]), \"integrity\", \"Capture metadata changed.\")\n require(value[\"entries\"] == manifest_entries(data), \"coverage\", \"Manifest differs from exact captured diff.\")\n return value, captured\n\n\ndef validate_plan(plan):\n closed(plan, \"schemaVersion resolutionId protocol sourceHash obligations\")\n v1(plan[\"schemaVersion\"])\n identifier(plan[\"resolutionId\"])\n digest(plan[\"sourceHash\"])\n protocol = plan[\"protocol\"]\n inline = type(protocol) is dict and protocol.get(\"version\") == INLINE_VERSION\n if inline:\n closed(protocol, \"version digest\")\n digest(protocol[\"digest\"])\n else:\n closed(protocol, \"version content digest\")\n require(protocol[\"version\"] == VERSION and sha(string(protocol[\"content\"]).encode()) == digest(protocol[\"digest\"]),\n \"protocol\", \"Materialized protocol version/content digest mismatch.\")\n obligations = {}\n talents = {}\n custom_identities = set()\n applied = {}\n for obligation in array(plan[\"obligations\"]):\n require(type(obligation) is dict and obligation.get(\"kind\") in (\"grace\", \"custom\"), \"plan\", \"Unknown obligation kind.\")\n common = \"kind obligationId appliedExpertiseId severity\"\n if obligation[\"kind\"] == \"grace\":\n closed(obligation, common + \" talentId ruleId rulesDigest\")\n tid, rid = string(obligation[\"talentId\"]), string(obligation[\"ruleId\"])\n require(obligation[\"obligationId\"] == tid + \":\" + rid and \":\" not in tid and \":\" not in rid,\n \"plan\", \"Grace obligation identity mismatch.\")\n value = digest(obligation[\"rulesDigest\"])\n require(tid not in talents or talents[tid] == value, \"plan\", \"Conflicting rules digests.\")\n talents[tid] = value\n require(tid not in applied or applied[tid] == obligation[\"appliedExpertiseId\"], \"plan\", \"Talent has inconsistent applied identity.\")\n applied[tid] = obligation[\"appliedExpertiseId\"]\n else:\n closed(obligation, common + \" expertiseId expertiseVersionId \" + (\"instructionDigest\" if inline else \"contentDigest instruction\"))\n identifier(obligation[\"expertiseId\"]); identifier(obligation[\"expertiseVersionId\"])\n identity = (obligation[\"expertiseId\"], obligation[\"expertiseVersionId\"])\n require(identity not in custom_identities, \"plan\", \"Duplicate Custom identity/version.\")\n custom_identities.add(identity)\n require(obligation[\"obligationId\"] == obligation[\"appliedExpertiseId\"] and obligation[\"severity\"] == \"blocking\",\n \"plan\", \"Custom identity or blocking severity mismatch.\")\n if inline:\n digest(obligation[\"instructionDigest\"])\n else:\n require(sha(string(obligation[\"instruction\"]).encode()) == digest(obligation[\"contentDigest\"]),\n \"plan\", \"Custom instruction digest mismatch.\")\n identifier(obligation[\"appliedExpertiseId\"])\n require(obligation[\"severity\"] in (\"blocking\", \"warning\", \"info\"), \"plan\", \"Unknown severity.\")\n oid = string(obligation[\"obligationId\"])\n require(oid not in obligations, \"plan\", \"Duplicate expected obligation.\")\n obligations[oid] = obligation\n require(bool(obligations), \"plan\", \"No expected obligations; do not manufacture an empty review.\")\n return obligations\n\n\ndef validate_packet(packet):\n require(len(encoded(packet)) <= PACKET_LIMIT, \"size\", \"Packet exceeds 65536 bytes; repartition explicitly.\")\n closed(packet, PACKET_KEYS)\n string(packet[\"reviewId\"]); string(packet[\"resolutionId\"])\n require(type(packet[\"maxPacketBytes\"]) is int and packet[\"maxPacketBytes\"] == PACKET_LIMIT,\n \"size\", \"Packet cannot override the trusted 65536-byte limit.\")\n for key in (\"files\", \"talentIds\", \"obligationIds\"):\n ordered(packet[key])\n require(packet[\"obligationIds\"] and packet[\"entries\"], \"empty_packet\", \"Each packet needs entries and obligations.\")\n ids = []\n for entry in array(packet[\"entries\"]):\n closed(entry, \"entryId file kind content\")\n git_path(entry[\"file\"]); string(entry[\"content\"])\n require(entry[\"kind\"] in (\"header\", \"hunk\") and entry_id(entry) == entry[\"entryId\"], \"entry\", \"Entry identity mismatch.\")\n require(entry[\"content\"].startswith(\"diff --git \" if entry[\"kind\"] == \"header\" else \"@@ \"), \"entry\", \"Entry kind mismatch.\")\n ids.append(entry[\"entryId\"])\n require(len(set(ids)) == len(ids) and packet[\"files\"] == sorted({e[\"file\"] for e in packet[\"entries\"]}),\n \"entry\", \"Duplicate entry or inconsistent files.\")\n tids = []\n for value in array(packet[\"rulesDigests\"]):\n closed(value, \"talentId rulesDigest\")\n tids.append(string(value[\"talentId\"])); digest(value[\"rulesDigest\"])\n require(tids == packet[\"talentIds\"], \"rules\", \"Exactly one ordered digest per talent is required.\")\n dependencies = []\n for dependency in array(packet[\"dependencies\"]):\n closed(dependency, \"packetId entryIds obligationIds\")\n ordered(dependency[\"entryIds\"]); ordered(dependency[\"obligationIds\"])\n require(dependency[\"entryIds\"] or dependency[\"obligationIds\"], \"dependency\", \"Empty dependency.\")\n dependencies.append(string(dependency[\"packetId\"]))\n ordered(dependencies)\n require(packet[\"packetId\"] not in dependencies, \"dependency\", \"Self dependency.\")\n require(packet_id(packet[\"obligationIds\"]) == packet[\"packetId\"] and packet_hash(packet) == packet[\"packetHash\"],\n \"hash\", \"Packet identity/hash mismatch.\")\n\n\ndef validate_graph(packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n require(len(by_id) == len(packets), \"packet\", \"Duplicate packet identity.\")\n for packet in packets:\n validate_packet(packet)\n for dependency in packet[\"dependencies\"]:\n upstream = by_id.get(dependency[\"packetId\"])\n require(upstream is not None, \"dependency\", \"Missing upstream packet.\")\n require(set(dependency[\"entryIds\"]) <= {e[\"entryId\"] for e in upstream[\"entries\"]}\n and set(dependency[\"obligationIds\"]) <= set(upstream[\"obligationIds\"]),\n \"dependency\", \"Dependency identifiers do not belong to upstream packet.\")\n remaining = {key: {d[\"packetId\"] for d in p[\"dependencies\"]} for key, p in by_id.items()}\n while remaining:\n ready = {key for key, deps in remaining.items() if not deps}\n require(ready, \"cycle\", \"Packet dependency graph contains a cycle.\")\n remaining = {key: deps - ready for key, deps in remaining.items() if key not in ready}\n return by_id\n\n\ndef check_bindings(packet, plan):\n obligations = validate_plan(plan)\n require(packet[\"resolutionId\"] == plan[\"resolutionId\"] and set(packet[\"obligationIds\"]) <= set(obligations),\n \"binding\", \"Packet differs from expected resolution/obligations.\")\n mapping = {obligations[oid][\"talentId\"]: obligations[oid][\"rulesDigest\"] for oid in packet[\"obligationIds\"]\n if obligations[oid][\"kind\"] == \"grace\"}\n require(packet[\"rulesDigests\"] == [{\"talentId\": tid, \"rulesDigest\": value} for tid, value in sorted(mapping.items())],\n \"binding\", \"Packet rules differ from the materialized plan.\")\n\n\ndef pack(request):\n manifest_value, captured = load_manifest(request[\"manifest\"])\n plan = read_json(request[\"plan\"])\n obligations = validate_plan(plan)\n require(plan[\"sourceHash\"] == sha(encoded(captured[\"changeSource\"])), \"source\", \"Plan binds a different change source.\")\n entries = {e[\"entryId\"]: e for e in manifest_value[\"entries\"]}\n packets, attempts = [], []\n assigned, covered = [], set()\n for assignment in array(request[\"assignments\"]):\n closed(assignment, \"entryIds obligationIds dependencies reviewId attemptId reviewer\")\n ordered(assignment[\"entryIds\"]); ordered(assignment[\"obligationIds\"])\n require(set(assignment[\"entryIds\"]) <= set(entries) and set(assignment[\"obligationIds\"]) <= set(obligations),\n \"assignment\", \"Unknown entry or obligation in assignment.\")\n selected = [e for e in manifest_value[\"entries\"] if e[\"entryId\"] in assignment[\"entryIds\"]]\n mapping = {obligations[oid][\"talentId\"]: obligations[oid][\"rulesDigest\"] for oid in assignment[\"obligationIds\"]\n if obligations[oid][\"kind\"] == \"grace\"}\n packet = {\"reviewId\": string(assignment[\"reviewId\"]), \"packetId\": packet_id(assignment[\"obligationIds\"]),\n \"resolutionId\": plan[\"resolutionId\"], \"packetHash\": \"\", \"maxPacketBytes\": PACKET_LIMIT,\n \"files\": sorted({e[\"file\"] for e in selected}), \"entries\": selected, \"talentIds\": sorted(mapping),\n \"rulesDigests\": [{\"talentId\": tid, \"rulesDigest\": value} for tid, value in sorted(mapping.items())],\n \"obligationIds\": assignment[\"obligationIds\"], \"dependencies\": assignment[\"dependencies\"]}\n packet[\"packetHash\"] = packet_hash(packet)\n validate_packet(packet)\n packets.append(packet)\n attempts.append({\"reviewId\": packet[\"reviewId\"], \"attemptId\": identifier(assignment[\"attemptId\"]),\n \"packetId\": packet[\"packetId\"], \"packetHash\": packet[\"packetHash\"],\n \"reviewer\": string(assignment[\"reviewer\"]), \"role\": \"primary\", \"status\": \"pending\", \"response\": None})\n assigned.extend(assignment[\"obligationIds\"]); covered.update(assignment[\"entryIds\"])\n require(sorted(assigned) == sorted(obligations) and covered == set(entries), \"coverage\", \"Obligation assignment or entry coverage is incomplete/duplicated.\")\n require(len({a[\"reviewId\"] for a in attempts}) == len(attempts) and len({a[\"attemptId\"] for a in attempts}) == len(attempts),\n \"attempt\", \"Attempt/review identities must be unique.\")\n validate_graph(packets)\n directory = new_directory(request[\"outputDirectory\"])\n for packet in packets:\n write_new(directory / (packet[\"packetId\"] + \".json\"), encoded(packet))\n state = {\"schemaVersion\": 1, \"revision\": 0, \"generation\": 0, \"plan\": plan, \"planHash\": sha(encoded(plan)),\n \"manifest\": request[\"manifest\"], \"manifestHash\": sha(encoded(manifest_value)),\n \"fullDiffHash\": captured[\"fullDiff\"][\"sha256\"], \"packets\": [encoded(p).decode() for p in packets],\n \"attempts\": attempts, \"finals\": {}, \"previousFinals\": {}, \"reports\": []}\n artifact = write_new(directory / \"state.json\", encoded(state))\n return [artifact], {\"packets\": len(packets), \"aboveTarget\": sum(len(encoded(p)) > PACKET_TARGET for p in packets),\n \"packetDirectory\": str(directory)}\n\n\ndef load_state(path, raw=None):\n raw = read_bytes(path) if raw is None else raw\n state = parse(raw)\n closed(state, \"schemaVersion revision generation plan planHash manifest manifestHash fullDiffHash packets attempts finals previousFinals reports\")\n v1(state[\"schemaVersion\"])\n require(type(state[\"revision\"]) is int and state[\"revision\"] >= 0, \"state\", \"Invalid state revision.\")\n require(type(state[\"generation\"]) is int and state[\"generation\"] >= 0, \"state\", \"Invalid review generation.\")\n validate_plan(state[\"plan\"])\n require(sha(encoded(state[\"plan\"])) == digest(state[\"planHash\"]), \"state\", \"Plan digest mismatch.\")\n packets = [parse(string(p).encode(), PACKET_LIMIT) for p in array(state[\"packets\"])]\n validate_graph(packets)\n for packet in packets:\n check_bindings(packet, state[\"plan\"])\n validate_lifecycle(state, packets)\n return state, packets, sha(raw)\n\n\ndef validate_verdict(verdict, identity_keys, custom=False):\n closed(verdict, identity_keys + \" verdict justification evidence missingEvidence\")\n require(verdict[\"verdict\"] in (\"respected\", \"violated\", \"not_applicable\", \"inconclusive\"), \"verdict\", \"Unknown verdict.\")\n require(not custom or verdict[\"verdict\"] != \"not_applicable\", \"custom\", \"Custom obligations cannot be not_applicable.\")\n string(verdict[\"justification\"])\n for evidence in array(verdict[\"evidence\"]):\n closed(evidence, \"location explanation\")\n match = re.fullmatch(r\"(.+?):([1-9][0-9]*)(?::([1-9][0-9]*))?\", string(evidence[\"location\"]))\n require(match is not None, \"evidence\", \"Evidence needs a relative file:line[:column] location.\")\n git_path(match.group(1)); string(evidence[\"explanation\"])\n ordered(verdict[\"missingEvidence\"])\n if verdict[\"verdict\"] == \"inconclusive\":\n require(verdict[\"missingEvidence\"], \"evidence\", \"Inconclusive verdict needs missingEvidence.\")\n else:\n require(verdict[\"evidence\"] and not verdict[\"missingEvidence\"], \"evidence\", \"Conclusive verdict needs evidence and no missingEvidence.\")\n\n\ndef validate_preserved_payload(payload):\n closed(payload, \"submissionId resolutionId talentResults expertiseResults\")\n identifier(payload[\"submissionId\"]); identifier(payload[\"resolutionId\"])\n talents, custom = [], []\n for talent in array(payload[\"talentResults\"]):\n closed(talent, \"talentId rulesDigest ruleResults\")\n talents.append(string(talent[\"talentId\"])); digest(talent[\"rulesDigest\"])\n rules = []\n for verdict in array(talent[\"ruleResults\"]):\n validate_verdict(verdict, \"ruleId\")\n rules.append(string(verdict[\"ruleId\"]))\n ordered(rules)\n ordered(talents)\n for verdict in array(payload[\"expertiseResults\"]):\n validate_verdict(verdict, \"expertiseId expertiseVersionId\", True)\n custom.append((identifier(verdict[\"expertiseId\"]), identifier(verdict[\"expertiseVersionId\"])))\n require(custom == sorted(set(custom)), \"report\", \"Duplicate or unsorted Custom result identities.\")\n\n\ndef validate_response(response, packet, plan):\n closed(response, \"reviewId packetId packetHash rulesDigests verdicts\")\n string(response[\"reviewId\"])\n require(response[\"packetId\"] == packet[\"packetId\"] and response[\"packetHash\"] == packet[\"packetHash\"]\n and response[\"rulesDigests\"] == packet[\"rulesDigests\"], \"response_binding\", \"Response packet/hash/rules mapping differs from current assignment.\")\n obligations = validate_plan(plan)\n ids = []\n for verdict in array(response[\"verdicts\"]):\n closed(verdict, \"obligationId verdict justification evidence missingEvidence\")\n oid = string(verdict[\"obligationId\"])\n require(oid in obligations, \"verdict\", \"Unknown obligation in response.\")\n ids.append(oid)\n validate_verdict(verdict, \"obligationId\", obligations[oid][\"kind\"] == \"custom\")\n require(ids == packet[\"obligationIds\"], \"coverage\", \"Response verdicts must exactly cover assigned obligations, sorted and unique.\")\n\n\ndef validate_lifecycle(state, packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n reviews, executions, primaries = set(), set(), set()\n attempts = {}\n for attempt in array(state[\"attempts\"]):\n closed(attempt, \"reviewId attemptId packetId packetHash reviewer role status response\")\n rid = string(attempt[\"reviewId\"])\n aid = identifier(attempt[\"attemptId\"])\n require(rid not in reviews and aid not in executions, \"attempt\", \"Reused attempt identity in state.\")\n reviews.add(rid); executions.add(aid); attempts[rid] = attempt\n string(attempt[\"reviewer\"]); string(attempt[\"packetId\"]); digest(attempt[\"packetHash\"])\n require(attempt[\"role\"] in (\"primary\", \"second\") and attempt[\"status\"] in (\"pending\", \"consumed\", \"revoked\"),\n \"attempt\", \"Invalid attempt role or lifecycle state.\")\n if attempt[\"status\"] == \"pending\":\n require(attempt[\"response\"] is None, \"attempt\", \"Pending attempt already has a response.\")\n packet = by_id.get(attempt[\"packetId\"])\n require(packet is not None and packet[\"packetHash\"] == attempt[\"packetHash\"], \"attempt\", \"Pending attempt targets a stale packet.\")\n if attempt[\"role\"] == \"primary\":\n require(attempt[\"packetId\"] not in primaries, \"attempt\", \"Multiple pending primary attempts.\")\n primaries.add(attempt[\"packetId\"])\n if attempt[\"status\"] == \"consumed\":\n require(type(attempt[\"response\"]) is dict, \"attempt\", \"Consumed attempt lacks its response.\")\n if attempt[\"response\"] is not None:\n closed(attempt[\"response\"], \"reviewId packetId packetHash rulesDigests verdicts\")\n response = attempt[\"response\"]\n ids = []\n for verdict in array(response[\"verdicts\"]):\n validate_verdict(verdict, \"obligationId\")\n ids.append(string(verdict[\"obligationId\"]))\n ordered(ids)\n talents = []\n for mapping in array(response[\"rulesDigests\"]):\n closed(mapping, \"talentId rulesDigest\")\n talents.append(string(mapping[\"talentId\"])); digest(mapping[\"rulesDigest\"])\n ordered(talents)\n require(all(attempt[\"response\"][key] == attempt[key] for key in (\"reviewId\", \"packetId\", \"packetHash\")),\n \"attempt\", \"Stored response differs from attempt binding.\")\n require(type(state[\"finals\"]) is dict and type(state[\"previousFinals\"]) is dict, \"state\", \"Final selections must be objects.\")\n for packet_id_value, selection in state[\"finals\"].items():\n closed(selection, \"reviewId reason\")\n string(selection[\"reason\"])\n attempt = attempts.get(selection[\"reviewId\"])\n require(attempt is not None and attempt[\"status\"] == \"consumed\" and attempt[\"packetId\"] == packet_id_value\n and packet_id_value in by_id, \"final\", \"Final selection is not a consumed current attempt.\")\n require(not any(a[\"packetId\"] == packet_id_value and a[\"status\"] == \"pending\" for a in attempts.values()),\n \"final\", \"A pending second view prevents finalization.\")\n validate_response(attempt[\"response\"], by_id[packet_id_value], state[\"plan\"])\n for packet_id_value, review_id in state[\"previousFinals\"].items():\n attempt = attempts.get(review_id)\n require(attempt is not None and attempt[\"response\"] is not None and attempt[\"packetId\"] == packet_id_value,\n \"state\", \"Previous final response is missing.\")\n submissions = set()\n for report in array(state[\"reports\"]):\n closed(report, \"submissionId payload payloadHash revision generation\")\n require(identifier(report[\"submissionId\"]) not in submissions, \"report\", \"Duplicate report submission identity.\")\n submissions.add(report[\"submissionId\"])\n validate_preserved_payload(report[\"payload\"])\n require(report[\"payload\"][\"submissionId\"] == report[\"submissionId\"] and sha(encoded(report[\"payload\"])) == digest(report[\"payloadHash\"]),\n \"report\", \"Preserved report payload changed.\")\n require(type(report[\"revision\"]) is int and 0 <= report[\"revision\"] <= state[\"revision\"], \"report\", \"Invalid report revision.\")\n require(type(report[\"generation\"]) is int and 0 <= report[\"generation\"] <= state[\"generation\"], \"report\", \"Invalid report generation.\")\n\n\ndef global_bindings(state, packets):\n value, captured = load_manifest(state[\"manifest\"])\n require(sha(encoded(value)) == state[\"manifestHash\"] and captured[\"fullDiff\"][\"sha256\"] == state[\"fullDiffHash\"]\n and sha(encoded(captured[\"changeSource\"])) == state[\"plan\"][\"sourceHash\"], \"state\", \"State source/manifest binding mismatch.\")\n covered, assigned = set(), []\n for packet in packets:\n ids = {e[\"entryId\"] for e in packet[\"entries\"]}\n require(packet[\"entries\"] == [e for e in value[\"entries\"] if e[\"entryId\"] in ids],\n \"coverage\", \"Packet is not an ordered subset of the manifest.\")\n covered.update(ids); assigned.extend(packet[\"obligationIds\"])\n require(covered == {e[\"entryId\"] for e in value[\"entries\"]} and sorted(assigned) == sorted(validate_plan(state[\"plan\"])),\n \"coverage\", \"Global coverage differs from manifest/plan.\")\n return value\n\n\n@contextmanager\ndef locked_state(request):\n path = local_path(request[\"state\"])\n with anchored_parent(path) as (name, parent):\n lock = str(name) + \".lock\"\n try:\n fd = open_anchored(lock, parent, write=True, create=True)\n except FileExistsError:\n raise Refusal(\"locked\", \"State is locked; verify the writer has stopped before explicit lock recovery.\") from None\n os.close(fd)\n temporary = None\n try:\n state, packets, old_hash = load_state(str(path), read_anchored(name, parent, ARTIFACT_LIMIT))\n require(old_hash == digest(request[\"expectedStateHash\"]), \"state_conflict\", \"State changed; reread before making a new decision.\")\n global_bindings(state, packets)\n yield state, packets\n state[\"revision\"] += 1\n validate_lifecycle(state, [parse(p.encode(), PACKET_LIMIT) for p in state[\"packets\"]])\n data = encoded(state)\n require(len(data) <= ARTIFACT_LIMIT, \"size\", \"State exceeds local artifact limit.\")\n temporary = (path.parent if os.name == \"nt\" else Path()) / (\".review-state-\" + uuid.uuid4().hex)\n fd = open_anchored(temporary, parent, write=True, create=True)\n with os.fdopen(fd, \"wb\") as stream:\n stream.write(data); stream.flush(); os.fsync(stream.fileno())\n require(sha(read_anchored(name, parent, ARTIFACT_LIMIT)) == old_hash,\n \"state_conflict\", \"State changed despite the lock; stop all writers.\")\n replace_args = {} if os.name == \"nt\" else {\"src_dir_fd\": parent[\"dir_fd\"], \"dst_dir_fd\": parent[\"dir_fd\"]}\n os.replace(temporary, name, **replace_args)\n temporary = None\n finally:\n if temporary is not None:\n os.unlink(temporary, **parent)\n os.unlink(lock, **parent)\n\n\ndef response_for(state, review_id):\n return next(a[\"response\"] for a in state[\"attempts\"] if a[\"reviewId\"] == review_id)\n\n\ndef reverse_closure(packets, seeds):\n invalid = set(seeds)\n while True:\n added = {p[\"packetId\"] for p in packets if any(d[\"packetId\"] in invalid for d in p[\"dependencies\"])} - invalid\n if not added:\n return invalid\n invalid.update(added)\n\n\ndef revoke(state, packet_ids):\n for attempt in state[\"attempts\"]:\n if attempt[\"packetId\"] in packet_ids:\n attempt[\"status\"] = \"revoked\"\n for pid in packet_ids:\n if pid in state[\"finals\"]:\n state[\"previousFinals\"][pid] = state[\"finals\"].pop(pid)[\"reviewId\"]\n\n\ndef project_report(state, packets, submission_id):\n require(set(state[\"finals\"]) == {p[\"packetId\"] for p in packets}, \"coverage\", \"Final verdicts are incomplete.\")\n obligations = validate_plan(state[\"plan\"])\n verdicts = {}\n for selection in state[\"finals\"].values():\n for item in response_for(state, selection[\"reviewId\"])[\"verdicts\"]:\n require(item[\"obligationId\"] not in verdicts, \"coverage\", \"Multiple final verdicts for one obligation.\")\n verdicts[item[\"obligationId\"]] = item\n require(set(verdicts) == set(obligations), \"coverage\", \"Final verdict coverage mismatch.\")\n talents, custom = {}, []\n for oid, obligation in sorted(obligations.items()):\n verdict = verdicts[oid]\n result = {key: verdict[key] for key in (\"verdict\", \"justification\", \"evidence\", \"missingEvidence\")}\n if obligation[\"kind\"] == \"grace\":\n group_value = talents.setdefault(obligation[\"talentId\"], {\"talentId\": obligation[\"talentId\"],\n \"rulesDigest\": obligation[\"rulesDigest\"], \"ruleResults\": []})\n group_value[\"ruleResults\"].append({\"ruleId\": obligation[\"ruleId\"], **result})\n else:\n custom.append({\"expertiseId\": obligation[\"expertiseId\"], \"expertiseVersionId\": obligation[\"expertiseVersionId\"], **result})\n return {\"submissionId\": identifier(submission_id), \"resolutionId\": state[\"plan\"][\"resolutionId\"],\n \"talentResults\": [talents[key] for key in sorted(talents)],\n \"expertiseResults\": sorted(custom, key=lambda x: (x[\"expertiseId\"], x[\"expertiseVersionId\"]))}\n\n\ndef materialize_exact(path, data):\n if path.exists():\n require(read_bytes(str(path)) == data, \"artifact_conflict\", \"Existing immutable artifact has different bytes.\")\n return {\"path\": str(path), \"bytes\": len(data), \"sha256\": sha(data)}\n return write_new(path, data)\n\n\ndef accept(request):\n identifier(request[\"submissionId\"])\n artifacts = []\n with locked_state(request) as (state, packets):\n by_id = {p[\"packetId\"]: p for p in packets}\n previous = {pid: response_for(state, selection[\"reviewId\"])[\"verdicts\"] for pid, selection in state[\"finals\"].items()}\n previous.update({pid: response_for(state, rid)[\"verdicts\"] for pid, rid in state[\"previousFinals\"].items() if pid not in previous})\n if request[\"response\"] is not None:\n raw = read_bytes(request[\"response\"], PACKET_LIMIT)\n if request[\"repair\"] is not None:\n repair = request[\"repair\"]\n closed(repair, \"original originalSha256 semanticSha256\")\n original = read_bytes(repair[\"original\"], PACKET_LIMIT)\n require(sha(original) == digest(repair[\"originalSha256\"]), \"repair\", \"Original envelope changed.\")\n # Only this explicit, unambiguous markdown envelope is repairable.\n require(original.startswith(b\"```json\\n\") and original.endswith(b\"\\n```\"), \"repair\", \"Unsupported envelope; request a new response.\")\n old = parse(original[8:-4], PACKET_LIMIT)\n response = parse(raw, PACKET_LIMIT)\n require(old == response and sha(encoded(old)) == digest(repair[\"semanticSha256\"]), \"repair\", \"Envelope repair changed semantic content.\")\n else:\n response = parse(raw, PACKET_LIMIT)\n closed(response, \"reviewId packetId packetHash rulesDigests verdicts\")\n attempt = next((a for a in state[\"attempts\"] if a[\"reviewId\"] == response[\"reviewId\"]), None)\n require(attempt is not None and attempt[\"status\"] == \"pending\", \"attempt\", \"Unknown, revoked or consumed attempt; do not replay a response.\")\n require(string(request[\"reviewer\"]) == attempt[\"reviewer\"], \"reviewer\", \"Harness-supplied reviewer differs from assignment.\")\n packet = by_id[attempt[\"packetId\"]]\n validate_response(response, packet, state[\"plan\"])\n attempt.update(status=\"consumed\", response=response)\n active = [a for a in state[\"attempts\"] if a[\"packetId\"] == packet[\"packetId\"] and a[\"status\"] != \"revoked\"]\n if len(active) == 1 and attempt[\"role\"] == \"primary\":\n state[\"finals\"][packet[\"packetId\"]] = {\"reviewId\": attempt[\"reviewId\"], \"reason\": \"Unique primary response\"}\n else:\n require(request[\"reviewer\"] is None and request[\"repair\"] is None, \"schema\", \"Arbitration/export without response has no reviewer or repair.\")\n arbitrated = set()\n for decision in array(request[\"arbitration\"]):\n closed(decision, \"packetId reviewId reason\")\n pid = decision[\"packetId\"]\n require(pid in by_id and pid not in arbitrated, \"arbitration\", \"Unknown or repeated packet arbitration.\")\n arbitrated.add(pid); string(decision[\"reason\"])\n active = [a for a in state[\"attempts\"] if a[\"packetId\"] == pid and a[\"status\"] != \"revoked\"]\n require(active and all(a[\"status\"] == \"consumed\" for a in active), \"arbitration\", \"Wait for every active view or explicitly revoke/reissue.\")\n require(any(a[\"reviewId\"] == decision[\"reviewId\"] for a in active), \"arbitration\", \"Chosen view is not an active consumed response.\")\n state[\"finals\"][pid] = {\"reviewId\": decision[\"reviewId\"], \"reason\": decision[\"reason\"]}\n changed = {pid for pid, selection in state[\"finals\"].items() if pid in previous\n and response_for(state, selection[\"reviewId\"])[\"verdicts\"] != previous[pid]}\n # A changed final can itself depend on another changed final in this call.\n dependents = {p[\"packetId\"] for p in packets if any(d[\"packetId\"] in changed for d in p[\"dependencies\"])}\n invalidated = reverse_closure(packets, dependents)\n revoke(state, invalidated)\n for pid in set(state[\"finals\"]) - invalidated:\n state[\"previousFinals\"].pop(pid, None)\n complete = set(state[\"finals\"]) == set(by_id)\n payload = None\n if complete:\n payload = project_report(state, packets, request[\"submissionId\"])\n payload_hash = sha(encoded(payload))\n existing = next((r for r in state[\"reports\"] if r[\"submissionId\"] == request[\"submissionId\"]), None)\n if existing:\n require(existing[\"payloadHash\"] == payload_hash and existing[\"generation\"] == state[\"generation\"],\n \"submission_conflict\", \"A new review generation requires a new submissionId; retries must preserve exact payload.\")\n else:\n require(not any(r[\"generation\"] == state[\"generation\"] for r in state[\"reports\"]),\n \"submission_conflict\", \"This generation already has a submissionId; retry that exact report.\")\n state[\"reports\"].append({\"submissionId\": request[\"submissionId\"], \"payload\": payload,\n \"payloadHash\": payload_hash, \"revision\": state[\"revision\"] + 1, \"generation\": state[\"generation\"]})\n validate_lifecycle({**state, \"revision\": state[\"revision\"] + 1}, packets)\n if payload is not None:\n report_path = Path(request[\"state\"]).parent / (\"report-\" + request[\"submissionId\"] + \".json\")\n artifacts.append(materialize_exact(report_path, encoded(payload)))\n summary = {\"complete\": complete, \"finalPackets\": len(state[\"finals\"]), \"invalidatedCount\": len(invalidated),\n \"recorded\": False, \"nextAction\": \"Submit the exact preserved report; retain the server acknowledgment separately.\" if complete else \"Complete or arbitrate remaining views.\"}\n raw = read_bytes(request[\"state\"])\n artifacts.insert(0, {\"path\": request[\"state\"], \"bytes\": len(raw), \"sha256\": sha(raw)})\n return artifacts, summary\n\n\ndef invalidate(request):\n artifacts = []\n outgoing = []\n with locked_state(request) as (state, previous_packets):\n current, current_packets, current_hash = load_state(request[\"current\"])\n require(current_hash == digest(request[\"currentStateHash\"]), \"state_conflict\", \"Current candidate state changed.\")\n global_bindings(current, current_packets)\n before = {p[\"packetId\"]: p for p in previous_packets}\n after = {p[\"packetId\"]: p for p in current_packets}\n old_obligations, new_obligations = validate_plan(state[\"plan\"]), validate_plan(current[\"plan\"])\n changed = set(before) ^ set(after)\n for pid in set(before) & set(after):\n if before[pid][\"packetHash\"] != after[pid][\"packetHash\"] or any(old_obligations.get(oid) != new_obligations.get(oid) for oid in after[pid][\"obligationIds\"]):\n changed.add(pid)\n if any(state[\"plan\"][key] != current[\"plan\"][key] for key in (\"resolutionId\", \"protocol\")):\n changed.update(before); changed.update(after)\n if changed and any(a[\"response\"] is not None for a in state[\"attempts\"]):\n require(set(state[\"finals\"]) == set(before) and state[\"reports\"], \"report_required\", \"Preserve the exhaustive report before correction/invalidation.\")\n latest = project_report(state, previous_packets, state[\"reports\"][-1][\"submissionId\"])\n require(sha(encoded(latest)) == state[\"reports\"][-1][\"payloadHash\"], \"report_required\", \"Current exhaustive report has not been preserved.\")\n for pid in ordered(request[\"upstreamChanges\"]):\n require(pid in state[\"finals\"] and pid in current[\"finals\"], \"upstream\", \"An upstream change requires both observed final responses.\")\n old_response = response_for(state, state[\"finals\"][pid][\"reviewId\"])\n new_response = response_for(current, current[\"finals\"][pid][\"reviewId\"])\n require(old_response[\"verdicts\"] != new_response[\"verdicts\"], \"upstream\", \"Upstream final verdict did not change.\")\n changed.add(pid)\n attempts = array(request[\"attempts\"])\n reissued = set()\n for item in attempts:\n closed(item, \"reviewId attemptId packetId reviewer role reason\")\n require(item[\"packetId\"] in after and item[\"role\"] in (\"primary\", \"second\"), \"attempt\", \"Unknown packet/attempt role.\")\n string(item[\"reason\"])\n if item[\"role\"] == \"primary\":\n require(item[\"packetId\"] not in reissued, \"attempt\", \"Only one new primary per packet.\")\n reissued.add(item[\"packetId\"])\n invalidated = reverse_closure(previous_packets + [p for p in current_packets if p not in previous_packets], changed | reissued)\n revoke(state, invalidated)\n if invalidated or attempts:\n state[\"generation\"] += 1\n state.update({key: current[key] for key in (\"plan\", \"planHash\", \"manifest\", \"manifestHash\", \"fullDiffHash\", \"packets\")})\n for item in attempts:\n require(not any(a[\"reviewId\"] == item[\"reviewId\"] or a[\"attemptId\"] == item[\"attemptId\"] for a in state[\"attempts\"]),\n \"attempt\", \"Never reuse a reviewId or execution attemptId, including revoked attempts.\")\n pid = item[\"packetId\"]\n if item[\"role\"] == \"second\":\n require(any(a[\"packetId\"] == pid and a[\"role\"] == \"primary\" and a[\"status\"] != \"revoked\" for a in state[\"attempts\"]),\n \"attempt\", \"A second view needs an active primary.\")\n if pid in state[\"finals\"]:\n state[\"previousFinals\"][pid] = state[\"finals\"].pop(pid)[\"reviewId\"]\n packet = {**after[pid], \"reviewId\": string(item[\"reviewId\"])}\n validate_packet(packet)\n state[\"attempts\"].append({\"reviewId\": item[\"reviewId\"], \"attemptId\": identifier(item[\"attemptId\"]), \"packetId\": pid,\n \"packetHash\": packet[\"packetHash\"], \"reviewer\": string(item[\"reviewer\"]), \"role\": item[\"role\"],\n \"status\": \"pending\", \"response\": None})\n path = Path(request[\"state\"]).parent / (\"attempt-\" + sha(frame(item[\"reviewId\"])) + \".json\")\n outgoing.append((path, encoded(packet)))\n validate_lifecycle(state, current_packets)\n transition = {\"revision\": state[\"revision\"] + 1, \"invalidated\": sorted(invalidated),\n \"preserved\": sorted(set(after) - invalidated), \"attempts\": []}\n for path, data in outgoing:\n transition[\"attempts\"].append(materialize_exact(path, data))\n transition_path = Path(request[\"state\"]).parent / (\"transition-\" + str(state[\"revision\"] + 1) + \".json\")\n artifacts.append(materialize_exact(transition_path, encoded(transition)))\n summary = {\"invalidatedCount\": len(invalidated), \"preservedCount\": len(set(after) - invalidated), \"newAttempts\": len(attempts)}\n raw = read_bytes(request[\"state\"])\n artifacts.insert(0, {\"path\": request[\"state\"], \"bytes\": len(raw), \"sha256\": sha(raw)})\n return artifacts, summary\n\n\ndef verify_pages(request):\n \"\"\"Check retained server pages and an already materialized file; never write or fetch.\"\"\"\n require(request[\"packet\"] is None and request[\"state\"] is None\n and request[\"dependencies\"] == [] and request[\"range\"] is None,\n \"verify\", \"Page verification cannot be combined with packet/state verification.\")\n expected = request[\"expected\"]\n closed(expected, \"format pages materialized resolutionId locale view target section indexDigest contentDigest rulesDigest protocolVersion\")\n require(expected[\"format\"] == \"paged-v1\" and expected[\"locale\"] in (\"fr\", \"en\")\n and expected[\"view\"] in (\"index\", \"rules\", \"custom\", \"protocol\", \"deepen\"),\n \"page_binding\", \"Unknown page format, locale or view.\")\n if expected[\"resolutionId\"] is not None:\n identifier(expected[\"resolutionId\"])\n deepen = expected[\"view\"] == \"deepen\"\n require(deepen or expected[\"resolutionId\"] is not None, \"page_binding\", \"Review pages require a resolution.\")\n if deepen or expected[\"view\"] in (\"rules\", \"custom\"):\n string(expected[\"target\"])\n else:\n require(expected[\"target\"] is None, \"page_binding\", \"This view has no target.\")\n require(deepen or expected[\"section\"] is None, \"page_binding\", \"Only deepen has sections.\")\n if expected[\"section\"] is not None:\n string(expected[\"section\"])\n for key in (\"indexDigest\", \"contentDigest\"):\n digest(expected[key])\n if expected[\"rulesDigest\"] is not None:\n digest(expected[\"rulesDigest\"])\n require((expected[\"view\"] == \"rules\" or expected[\"rulesDigest\"] is None)\n and expected[\"protocolVersion\"] == (None if deepen else VERSION),\n \"page_binding\", \"Unexpected rules digest or protocol version.\")\n if expected[\"view\"] == \"index\":\n require(expected[\"indexDigest\"] == expected[\"contentDigest\"], \"page_binding\", \"Index hashes differ.\")\n paths = array(expected[\"pages\"])\n require(0 < len(paths) <= 4096 and len(set(map(string, paths))) == len(paths),\n \"page_count\", \"Use 1..4096 distinct advancing page files.\")\n offset, total, finished = 0, None, False\n materialized = bytearray()\n for path in paths:\n page = read_json(path, 16384)\n if deepen:\n closed(page, \"format resolutionId locale results\")\n results = array(page[\"results\"])\n require(0 < len(results) <= 20, \"page_count\", \"Invalid deepen batch.\")\n for item in results:\n closed(item, \"uri section status contentDigest indexDigest offset totalBytes fragment nextCursor complete\")\n matches = [item for item in results if item[\"uri\"] == expected[\"target\"] and item[\"section\"] == expected[\"section\"]]\n require(len(matches) == 1, \"page_binding\", \"Expected exactly one URI/section in each retained page.\")\n fragment = matches[0]\n require(fragment[\"status\"] == \"ok\", \"page_unavailable\", \"Missing or inaccessible content cannot become an empty success.\")\n else:\n closed(page, \"format resolutionId locale view target indexDigest contentDigest rulesDigest protocolVersion offset totalBytes fragment nextCursor complete\")\n require(all(page[key] == expected[key] for key in (\"view\", \"target\", \"rulesDigest\", \"protocolVersion\")),\n \"page_binding\", \"View, target, rules or protocol changed.\")\n fragment = page\n require(all(page[key] == expected[key] for key in (\"format\", \"resolutionId\", \"locale\"))\n and all(fragment[key] == expected[key] for key in (\"indexDigest\", \"contentDigest\")),\n \"page_binding\", \"Scope or content changed; revalidate remotely before reusing cache.\")\n require(type(fragment[\"offset\"]) is int and fragment[\"offset\"] == offset and not finished\n and type(fragment[\"totalBytes\"]) is int and 0 <= fragment[\"totalBytes\"] <= ARTIFACT_LIMIT,\n \"page_order\", \"Missing, repeated, reordered or oversized page.\")\n if total is None:\n total = fragment[\"totalBytes\"]\n require(fragment[\"totalBytes\"] == total and type(fragment[\"fragment\"]) is str,\n \"page_binding\", \"Page length or fragment type changed.\")\n raw = fragment[\"fragment\"].encode(\"utf-8\", \"strict\")\n require(raw or total == 0, \"page_deferred\", \"Deferred pages do not advance; retain only advancing pages for this URI.\")\n offset += len(raw)\n require(offset <= total and type(fragment[\"complete\"]) is bool\n and fragment[\"complete\"] == (offset == total), \"page_completion\", \"Invalid completion or byte count.\")\n finished = fragment[\"complete\"]\n if finished:\n require(fragment[\"nextCursor\"] is None, \"page_completion\", \"Completed page has a cursor.\")\n else:\n string(fragment[\"nextCursor\"])\n materialized.extend(raw)\n require(finished and sha(materialized) == expected[\"contentDigest\"],\n \"page_digest\", \"Incomplete content or invalid exact UTF-8 digest.\")\n require(read_bytes(expected[\"materialized\"]) == materialized,\n \"page_materialization\", \"Materialized bytes differ from the verified fragments.\")\n return [], {\"format\": \"paged-v1\", \"pages\": len(paths), \"bytes\": offset,\n \"contentDigest\": expected[\"contentDigest\"], \"complete\": True,\n \"remoteAuthorizationVerified\": False}\n\n\ndef verify(request):\n if type(request[\"expected\"]) is dict and request[\"expected\"].get(\"format\") == \"paged-v1\":\n return verify_pages(request)\n require((request[\"state\"] is None) != (request[\"packet\"] is None), \"verify\", \"Choose packet verification or global state verification.\")\n if request[\"state\"] is not None:\n require(request[\"expected\"] is None and request[\"dependencies\"] == [], \"verify\", \"Global verification reads its bound plan.\")\n state, packets, state_hash = load_state(request[\"state\"])\n value = global_bindings(state, packets)\n summary = {\"packets\": len(packets), \"entries\": len(value[\"entries\"]), \"stateHash\": state_hash}\n else:\n packet = read_json(request[\"packet\"], PACKET_LIMIT)\n closed(packet, PACKET_KEYS)\n expected = request[\"expected\"]\n closed(expected, \"plan packetId packetHash reviewId\")\n plan = read_json(expected[\"plan\"])\n require(all(packet.get(key) == expected[key] for key in (\"packetId\", \"packetHash\", \"reviewId\")),\n \"binding\", \"Packet differs from the coordinator's expected attempt/hash.\")\n packets = [packet]\n for dependency in array(request[\"dependencies\"]):\n closed(dependency, \"path packetId packetHash\")\n item = read_json(dependency[\"path\"], PACKET_LIMIT)\n closed(item, PACKET_KEYS)\n require(all(item.get(key) == dependency[key] for key in (\"packetId\", \"packetHash\")),\n \"binding\", \"Upstream packet differs from expected binding.\")\n packets.append(item)\n validate_graph(packets)\n for item in packets:\n check_bindings(item, plan)\n summary = {\"packetId\": packet[\"packetId\"], \"packetHash\": packet[\"packetHash\"], \"entries\": len(packet[\"entries\"])}\n if request[\"range\"] is not None:\n value = request[\"range\"]\n closed(value, \"offset count\")\n require(type(value[\"offset\"]) is int and value[\"offset\"] >= 0 and type(value[\"count\"]) is int and 1 <= value[\"count\"] <= 20,\n \"range\", \"Use a nonnegative offset and count from 1 to 20.\")\n all_entries = [e for p in packets for e in p[\"entries\"]]\n end = min(value[\"offset\"] + value[\"count\"], len(all_entries))\n summary[\"range\"] = [{\"entryId\": e[\"entryId\"], \"bytes\": len(e[\"content\"].encode())} for e in all_entries[value[\"offset\"]:end]]\n summary[\"nextOffset\"] = end if end < len(all_entries) else None\n return [], summary\n\n\ndef main():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\"operation\", choices=REQUESTS)\n parser.add_argument(\"--input\", required=True)\n args = parser.parse_args()\n response = {\"schemaVersion\": 1, \"operation\": args.operation, \"ok\": False, \"artifacts\": [], \"summary\": {}, \"errors\": []}\n try:\n require(sys.version_info >= (3, 10), \"python_version\", \"Python 3.10 or later is required.\")\n request = read_json(args.input)\n closed(request, REQUESTS[args.operation])\n require(type(request[\"schemaVersion\"]) is int and request[\"schemaVersion\"] == 1, \"version\", \"Only request schemaVersion 1 is supported.\")\n response[\"artifacts\"], response[\"summary\"] = globals()[args.operation](request)\n response[\"ok\"] = True\n except Refusal as error:\n response[\"errors\"] = [{\"code\": error.code, \"message\": str(error)}]\n except (OSError, UnicodeError, ValueError, TypeError, KeyError, RecursionError):\n response[\"errors\"] = [{\"code\": \"input_or_io\", \"message\": \"Invalid or unavailable local input; check paths, permissions and schema. No automatic retry.\"}]\n output = encoded(response)\n if len(output) > OUTPUT_LIMIT:\n response.update(ok=False, artifacts=[], summary={}, errors=[{\"code\": \"output_size\", \"message\": \"Summary exceeds output limit; use shorter paths or a smaller range.\"}])\n output = encoded(response)\n sys.stdout.buffer.write(output + b\"\\n\")\n return 0 if response[\"ok\"] else 1\n\n\nif __name__ == \"__main__\":\n sys.exit(main())\n","sha256":"6d9851fcc8781772596e6d014ce0f32f90c7235b5f186ed8755bc70be1f1d01a","bytes":78989,"previous":[]},{"path":".agents/skills/grace-review/SKILL.md","kind":"file","content":"---\nname: grace-review\ndescription: \"Use before declaring any task that creates or changes code complete.\"\n---\n\nRead the diff **as if somebody else wrote it**: look for defects. For each rule, give a verdict and `file.ts:line` evidence; when unsure, flag it, never say “compliant”.\n\nAfter selection, before every launch/retry, announce “Grace — Review”: requested level,\nexact model, exact native effort passed, talents and planned checks. Auto: chosen level and short reason.\nEffort not passed: “reasoning inherited” and “level not applied”.\nNever infer effort from Low/Medium/High. Group identical configurations; identify each different scope.\nUnknown: “unavailable” and limitation. Distinguish planned selection, observed configuration,\nconfirmed execution; correct any mismatch returned by the harness.\nPlan ≠ validation; distinguish consulted rules, performed checks, corrections.\nUnfinished review, impossible check, failed call: “Grace — Blocker”, problem, consequence,\nnext known action. User's language, plain text, no duplicate within an attempt.\n\n## Local review workflow (inline-v1)\n\nThis workflow changes neither the review-level policy nor harness permissions or tools; every reviewer launch passes the selected model and effort explicitly. Open an additional session only when the review requires it.\n1. Call grace_review({ resolutionId, format: \"inline-v1\" }) for this review generation, then, when parts > 1, each part 2..parts with the first part's layoutDigest. Together the parts contain protocol grace-review-inline-v1, policy, obligations, complete rules, Custom instructions and digests. Do not call grace_review per talent or reviewer. review_dossier_too_large: no verdict, no retry and no fallback to paged-v1 or the historical plan; \"Grace — Blocker\" with the stated sizes. Grace alone chooses the accepted size.\n2. Keep the dossier in the orchestrator's context. Never write the dossier, rules or Custom instructions to any file, cache, archive, command argument or local state.\n3. Check Python >=3.10 without installing it. The kit places scripts/review-client.py beside this skill: require exact bytes/SHA-256 from the validated manifest and CLIENT_VERSION=\"1.2\" before execution. Missing/tampered/incompatible script or missing Python: explicit diagnosis, then the received protocol's exhaustive manual workflow; never simulated success.\n4. Run python3 -I -S -B