@yunhozz/arc 0.1.3 → 0.1.5

package/MANIFEST.sha256

@@ -1,22 +1,23 @@
 cbd254348f60c8610d0e5c4b8216c9772c0bd5dbfef324796da516b87054b06e  README.md
 484d9b2002ce542c87589bb719d644d3762706aad28a6ee010024875f8cc00e2  bin/arc.mjs
-947c0d09355ba3e3dede51192430fe3166ba3b6bb4589c271f6fdbc2bda9b109  claude/agents/arc-coder.md
+d853d31ba0d1a04661adf8cae1df11058455cb5d366c52312888c9dd2e9a1fb8  claude/agents/arc-coder.md
 91a2c62f4ea3ff00145407411fbbe62aa02fb7608af8f33bbd3d1719fc9d2f13  claude/agents/arc-planner.md
-715b594438b6c216a6e4c918503b72fa518b432e646c969a0ff0021d82d41740  claude/agents/arc-qa.md
+d864e57a1b2b6d69435a17a5c56a0e2c68d26592dd5e510be8d0fa341762cad1  claude/agents/arc-qa.md
 bd51442a5e76d4b61cbeb7f42d43cbcc7bab890db0d39ef16002ae13f5317c34  claude/agents/arc-reviewer.md
 c20162438bb8ac6905164268f867a8f1cfdbbfd51ddfd7e795cc211cc7f8c858  claude/agents/arc-scouter.md
-da8b352426e668e6432a9c370a673f1302f811da08fa7bd6eb07e18ad1585526  claude/skill/SKILL.md
+525c92fb52cc45c2f779176629e11c3a21f4e4434648cd5d6e4f6d7657f536f6  claude/skill/SKILL.md
 0bf77247b82371b3fe12a8dbe8fd2415c98d06e676d2c234b086b1f1e661b9db  claude/skill/hooks/git-policy.json
 b188c24d1339367acfe16b81be5743298e498856915e5e91b45e1a7220dad602  claude/skill/hooks/role-git-guard.mjs
 5126d44470486cb2581790b7c8d1605c4d0ee2448b725cf536ba1141eb40fa81  claude/skill/hooks/runtime-gate.mjs
-fa822237c0dbf83ba211679af2c8da98d7fe2a535940ef08abb468682944229f  claude/skill/references/commit.md
-66489f92a60a9261ce8d10ec38bd2595cd5bc4739972a1466f4d5da1895c4df9  claude/skill/references/git-recovery.md
-746013ce50fc2976af77f29a4403f0dd460451a344a88de31d654f8f1947738c  claude/skill/references/handoff-prep.md
-aa8425e303865ea6a6b4af10c4e60b3caaf5c934b58ebdc496d9050012f8d87f  claude/skill/references/handoff.md
-10eaf353b5c35ce0d51c10c37ca6cb181121cd20517c793d82c7f5dc5563dff6  claude/skill/references/limits.md
-acbaaecb6675c4d22e8b49453fa881010bda3493685c1e77bebe0860f27a86f0  claude/skill/references/planning.md
-0ca18832b03732594be1c6ee700a0d0f8707d1d6c01149c2dea8f3af6bfa0f83  claude/skill/references/verification.md
-0950dd5973db2578547dddfbed1dbe6000c821fda77e2c54da513ff328b5716d  claude/skill/references/visual-companion.md
+3926dbf9c7c244ebbb0baee17b1163387979793cb81c28e90977473d1e0a85e9  claude/skill/references/commit.md
+33ccd670b9d365abcc03edbfa26761ad00970df8e46633799beee4e72e6148fe  claude/skill/references/coordination.md
+90198f8bc6d9e99cbdb32604413c708753ff8503954b6b120aa7c7f00719de96  claude/skill/references/git-recovery.md
+d4b3100626831b23f0b1cf0106ef9f3bc7e6f3d14864e9dd93ae0f8063b5bdda  claude/skill/references/handoff-prep.md
+42a13f77f2b28d660236237dff88cab166f052a178295cef253a774fd6fc8e40  claude/skill/references/handoff.md
+4172c1c8ba397ceb561e437cc6ef02d4c2d7e7ed3df1400a4efbf4b46ddca4fa  claude/skill/references/limits.md
+93a7001c6ad4215170fa331261c2d58835fcdad823724f024d5c81a450133340  claude/skill/references/planning.md
+78704f725dd82bf49f7916ef5522e8c52040ccb05e109b568796d8a9f6e52e6e  claude/skill/references/verification.md
+cae43b5105a1300e87526bcc286516519863b2f8c5f70cd6fe1e0950b196a762  claude/skill/references/visual-companion.md
 30d8cdcb9d7ab6396cab09cd9f5cf6b8003f5490fb5c0ffe9f5acffbb0534978  claude/skill/runtime/adapters/claude.mjs
 d30d118d3b42b805195ed05a3dea0ed3cf939eac811cf0228ca0b0cafeda7969  claude/skill/runtime/adapters/codex.mjs
 c5a56ac147f13e9f946f673ac57a5dadbb4560d1f9deaa7c3b60e703f39b2d83  claude/skill/runtime/capabilities.mjs
@@ -31,22 +32,23 @@ c93f08cf6cafb5d96007df33d00dadda676c54b074fb998c2e523ecfc5e23d30  claude/skill/r
 aa1361419c0137f74793847805a3abc076a8d782c6f590e2d28b8eee5c35065d  claude/skill/runtime/store.mjs
 e4445f3582c55861907e11dfe97ea9e87c69bcc3ff773d3d583914c198f1d024  claude/skill/scripts/apply-models.py
 e4fe5d5718db1cf6ecc5ab289995aafc73de99bd0ed1fa9cf3ebc0815015109d  claude/skill/scripts/model_config.py
-7fe34f48ff1fb3b18257639cfe763b86c61b7e4f33e419f4d829529d2169d1d8  codex/agents/arc-coder.toml
-c9df6eaffd228a99ed4fd6604b032741c85f755bf8e4b2bd22af860f33bb7262  codex/agents/arc-planner.toml
-d79781ade7670a942f4b6b1a7c30406c6328195e395cc47ae0c5a4f3e9a5e449  codex/agents/arc-qa.toml
-c4911b92fc75c316e23164e0efbac5b5a25d7c9666fce0e1f5686e0f96867588  codex/agents/arc-reviewer.toml
-13bf5608336871683f096fc0f305725fb87b5b9703195fbae42f33ef991a00f9  codex/agents/arc-scouter.toml
-956da5ce64a1111ab2972457617f31a19a02c9f8c1647a4a75a8097d8bbc4fae  codex/skill/SKILL.md
+e88c798941158bf28b67a1f4687c8896d66417d9113b97a7324438c929cf2df5  codex/agents/arc-coder.toml
+d9c718e4a1cce5fef343afbc623ebb82fd29b85f40270b84a0f1770f57a61a50  codex/agents/arc-planner.toml
+793d132db240208729c2d54068634e872ead72b573c0cd4648a6e2f50e5cc56c  codex/agents/arc-qa.toml
+022f1abd7fd325ab543f6c7c5263a1d0c973be417a39ee8f3bb3295b44749fa3  codex/agents/arc-reviewer.toml
+0dc1905c3bb16e3b7117d9b38cab0c1e6e93f496afdb82f782ef830f1f3a6417  codex/agents/arc-scouter.toml
+79a113eebcaff301656fdc52f3713f0dad909ce7b55d6a0357504ca20eb48549  codex/skill/SKILL.md
 019f190ee7a2ccfea059a289ca971265574b043353f89bc96e219436c9827e9e  codex/skill/hooks/runtime-gate.mjs
-0bcf6bd4c032ee365135514a4a793680f216d4077451d1beefe87be48bd811ba  codex/skill/references/commit.md
-c164e4c47e21edb10bb06ba010c684a9cdb0bea40d4cde32f60fb08315dfbb97  codex/skill/references/git-recovery.md
-61fc845e06871cb061292027101f83f6091b5190134a35cf61ce9adf95cecdb3  codex/skill/references/handoff-prep.md
-46c20384b87730f73d2bb1cba260571618eed1946f8006c466d08ca3b4546105  codex/skill/references/handoff-worktree.md
-b13ce4acc91790f70f47cae165a88b029b32ddd66fadc10117e4d0a3a80ee5f8  codex/skill/references/handoff.md
-658314d60ed1ff78a1d931b5216a3b85f5f928821db915260ccf06d66e6e91ae  codex/skill/references/limits.md
-f2e368783e7f8afd5b8a25d2d5c837df3b1feef6f3d7677bbabd41645ddd280f  codex/skill/references/planning.md
-83a6bc324065bc155a21e1c15cf89a485ef967b00a6119b74b8e9bdbd73ae06f  codex/skill/references/verification.md
-892017d193534039fb82cac1dd41f53a28037ea4b8bf255e4716d348adc7d6be  codex/skill/references/visual-companion.md
+ce8ab4dd1a69176fc4d76b2e9e3c81b9165586c3a29833fe855f2a085f22195e  codex/skill/references/commit.md
+263b4d59d67bc365bcf9e658ebfba1d3896662c5fcdb0f45a87a30fd6b0fd43a  codex/skill/references/coordination.md
+be0a2e4050a0cad20d272775698be82dcc244081c4c1092de56e8a118de718b1  codex/skill/references/git-recovery.md
+39ce5bb81d1fa303394c8c2c6b0d306d9fc341a866654fdabb02a33e6f5c2dee  codex/skill/references/handoff-prep.md
+272b60b91ac05139985611d1555c417eab3ca1783655a9196511a0eda02caaba  codex/skill/references/handoff-worktree.md
+3338d9080415c3cdd4c7a5337f5c1f1d74e9f6cfb084181fe9cce78d906a1162  codex/skill/references/handoff.md
+89ae51633112f8c7bd71ab15940085e01e57d6582fb0d977c9efdf9d77ce9fc3  codex/skill/references/limits.md
+ed40f33754e4b6df683fe567b91974a381cf99ebd5ec772b493a71f17f01d5a7  codex/skill/references/planning.md
+3b89adb5bfbf91ac4937b41cdd3a5ebb2ffb652826fff9d834489bd377245e2c  codex/skill/references/verification.md
+23d928dc115b922e5418db9c89057dab2f19acb7c946420a55923d3bb5148417  codex/skill/references/visual-companion.md
 30d8cdcb9d7ab6396cab09cd9f5cf6b8003f5490fb5c0ffe9f5acffbb0534978  codex/skill/runtime/adapters/claude.mjs
 d30d118d3b42b805195ed05a3dea0ed3cf939eac811cf0228ca0b0cafeda7969  codex/skill/runtime/adapters/codex.mjs
 c5a56ac147f13e9f946f673ac57a5dadbb4560d1f9deaa7c3b60e703f39b2d83  codex/skill/runtime/capabilities.mjs
@@ -70,7 +72,7 @@ a575a94adc9461a7c5c051983b47d1a40a88fb8ee90fa469041cd99165cbb80f  lib/cli/progre
 ad8ad2f47da6e1d3160d786628d768e8d95108f1a1c113a6a5305e7c85c438db  lib/cli/root.mjs
 85f25429f208a4b45a36e66f89933d2bbfb470d6f52f032f70971817063e45f0  lib/cli/uninstall.mjs
 7719a16f6327ea3ba35206ee41c829ab967f865df9ebbd161129ca28babceb3d  lib/installer/acquisition.mjs
-4738c709721b233d8c5a58f7c8087bdefdf51d40154c7bfb2815765cb203de94  lib/installer/global-config.mjs
+66bc9a18523f70ddbb1d9a0844173d311aabd2d00d9ed5c06ca6679179ba8b06  lib/installer/global-config.mjs
 061ff82e0c655f47b872610b6ad7bde5d1941eaf7c563491a44291c86b16a349  lib/installer/install.mjs
 f9a0958fc424742f49ce6e2e0a49c7cf2bbe288e0cf3551d69a8a912c8f2709f  lib/installer/language.mjs
 64713575291e51971abc542df716baa99e9a530a489e92b2f8345b782e0ce4cd  lib/installer/limits.mjs
@@ -90,7 +92,8 @@ f0606cd2cd4871d11e544b5ad8221e4d9050761d1d80ab94c9219eb7e494b375  lib/installer/
 a7afd79d4620abcf85f4954aab4599870d8e47b897490d1c5c774f256c5e8800  lib/models/index.mjs
 cc205194c9aa90887bb74c11cb0f5adb63f9da8afe660755a73c62d090309385  lib/models/profiles.mjs
 7c36313221f36a9d08964017c79e8c7b3c848655f6a338f71a24ce508ac6e3ed  lib/policy/claude-hook.mjs
-b3084e6620ee31c6ee9a29009a69c27dda0fdda740adba000fe4b0fa92940516  lib/policy/render.mjs
+f32fcb03201c6a73d658a6b3107376f13d03f21503c568a7b4e71ff9b71dd426  lib/policy/placement.mjs
+09b5851cdbcb88b9d4d027e2d96aadb275660354ea64eef0aaa7583ec8090c3e  lib/policy/render.mjs
 5fd21f28b7983a89de8d52033ea61003462586ae679dbf87843b8291a2a29237  lib/policy/role-policy.json
 30d8cdcb9d7ab6396cab09cd9f5cf6b8003f5490fb5c0ffe9f5acffbb0534978  lib/runtime/adapters/claude.mjs
 d30d118d3b42b805195ed05a3dea0ed3cf939eac811cf0228ca0b0cafeda7969  lib/runtime/adapters/codex.mjs
@@ -107,7 +110,7 @@ aa1361419c0137f74793847805a3abc076a8d782c6f590e2d28b8eee5c35065d  lib/runtime/st
 4174dfcfcd4d69a5486b91108ec03279cfd50644109c7457aa87f9ac877fb1ac  lib/safe-fs/native.mjs
 ff9c33c8b3c2bd466d54ffbe4c7139ccd87c79c7de34a6c4cde92e9f6e9b42d2  native/binding.c
 205bedc1dee1a9ffa58124c6e21256a1f0cbe24f06f7c8d7cb0b99524cfab9d0  native/binding.gyp
-1565cf13103ae8aeb25a54597d375b62f93b80a65895d37d9134752ca5c9aa52  package.json
+b4aa1c8a1b3226485c90ca31841b57559150ab2a83db5764bf11ad84083236dd  package.json
 208c65cfde244d39ce45c3cf1b0acb128f04d21199b6b3fb5466e62db5b64af9  prebuilds/darwin-arm64/arc_safe_fs.node
 572887ac794d10a8b921d8168ea2328e31f05b45987611ff02c83114dba901af  prebuilds/darwin-x64/arc_safe_fs.node
 2bb9443021f9d873712b26321de733eddd6794c45f0bc79e2d5dc98669196635  prebuilds/index.json

package/claude/agents/arc-coder.md

@@ -45,7 +45,7 @@ assigned skill instructions, and explicitly cited references.
 
 Preserve unrelated staged, unstaged, and untracked changes and edit ownership. MUST NOT automatically stash, reset, clean,
 unstage, discard, amend, delete branches/worktrees, change permissions to bypass a blocker, delete locks,
-or bypass sandbox restrictions. On an actual conflict, missing assigned path, command failure, unexpected Git state,
+or bypass sandbox restrictions. On an actual conflict, missing assigned path, tool failure, unexpected Git state,
 or partial completion, stop dependent work and report observed workspace, branch/HEAD, index, files, completed steps,
 and needed resolution to Orchestrator. Do not retry or fall back automatically. Expected TDD RED is evidence,
 not an operational failure. After Orchestrator resolves a blocker, revalidate affected gates before resuming.

package/claude/agents/arc-qa.md

@@ -17,7 +17,7 @@ hooks:
           onFailure: block
 ---
 
-# Qa
+# QA
 
 {{ARC_OUTPUT_LANGUAGE_POLICY}}
 
@@ -46,7 +46,7 @@ assigned skill instructions, and explicitly cited references.
 
 Preserve unrelated staged, unstaged, and untracked changes and edit ownership. MUST NOT automatically stash, reset, clean,
 unstage, discard, amend, delete branches/worktrees, change permissions to bypass a blocker, delete locks,
-or bypass sandbox restrictions. On an actual conflict, missing assigned path, command failure, unexpected Git state,
+or bypass sandbox restrictions. On an actual conflict, missing assigned path, tool failure, unexpected Git state,
 or partial completion, stop dependent work and report observed workspace, branch/HEAD, index, files, completed steps,
 and needed resolution to Orchestrator. Do not retry or fall back automatically. Expected TDD RED is evidence,
 not an operational failure. After Orchestrator resolves a blocker, revalidate affected gates before resuming.

package/claude/skill/SKILL.md

@@ -12,7 +12,7 @@ Orchestrator MUST NEVER author them and MUST NEVER invoke `brainstorming` or `wr
 If either auto-triggers in Orchestrator context, Orchestrator stops and routes to Planner, citing that skill's SKILL.md
 path in the brief. A user request to skip questions never waives design or approval gates; Planner returns questions to
 Orchestrator. Each top-level task (a plan task, or the whole request without a plan) gets a FRESH Coder,
-and each task that needs QA (risk-scaled, unchanged) gets a FRESH QA, never one reused from another task;
+and each task that needs QA under Risk-scaled execution gets a FRESH QA, never one reused from another task;
 same-task rechecks may reuse.
 
 Follow user instructions and project guidance. Orchestrator uses the current chat model and answers a simple,
@@ -20,93 +20,16 @@ self-contained question (answerable from context or one quick read, no edits) di
 For substantive multistep work, Orchestrator coordinates implementation, configuration, tests, and mixed work.
 Assign material research/analysis and bounded read-only exploration of static code, documents, data, and logs/reports to Scouter.
 Orchestrator handles research directly when the needed material is already in its context or the check is a quick read
-of a few known
-files; all other material research/analysis and bounded exploration goes to Scouter with its configured settings (a
+of a few known files; all other material research/analysis and bounded exploration goes to Scouter with its configured settings (a
 bounded lookup gets a narrow brief: known paths, specific facts, no synthesis). Route by object and deliverable,
 not verbs alone. Standalone document writing has no specialist auto-route. Design, spec, plan, and brainstorming drafts
 are not standalone document writing (see Role gate).
 For mixed research/document requests, Orchestrator may explicitly assign only research to Scouter.
 Live execution-state investigation or cleanup are outside Scouter scope and this boundary makes no owner assignment.
 
-## Ownership
-
-- Orchestrator: sole owner of development, configuration, tests, implementation-dependent documentation, and mixed tasks
-  requiring implementation, assigning their edits to Coder. Coordinates scope, planning, approvals, integration,
-  acceptance, verification, and completion.
-- Scouter: read-only material research/analysis and assigned static code/document/data/log exploration. Reports
-  evidence, assumptions, unresolved questions, impact, next actions, and workspace/path issues to Orchestrator.
-  Does not edit files or author standalone document files, or decide design/plans, verification, review, or completion.
-- Planner: returns design/spec/plan drafts.
-- Coder edits assigned, approved implementation/configuration/test-code files and assigned dependent docs.
-  Orchestrator does not edit
-  them directly except under the Orchestrator direct path for small tasks.
-- QA: verifies without edits.
-- Reviewer: independently reviews the final full change.
-- All five roles report directly to Orchestrator at depth 2: Scouter, Planner, Coder, QA, and Reviewer.
-  Orchestrator is depth 1.
-  Depth-2 roles cannot create agents or delegate tasks to another role. Reviewer remains independent.
-- Claude native subagent names: Scouter=`arc-scouter`, Planner=`arc-planner`, Coder=`arc-coder`, QA=`arc-qa`,
-  Reviewer=`arc-reviewer`.
-- Across the full tree, obey configured limits for simultaneous subagents, including Scouter; there are no reserved slots.
-  Before first creation, read `references/limits.md` and installed `limits.toml`; maintain its cumulative ledger and reservations.
-  Parallelize independent tasks only; dependent handoffs are sequential and editing scopes cannot overlap. These are
-  ARC limits, not verified runtime concurrency or depth capabilities. Use Claude native subagent execution with
-  the installed native name and receive its completion result; report unavailable execution capabilities to
-  Orchestrator.
-- Scouter, Planner, and Reviewer do not edit, execute commands, or save standalone documents; QA verifies without edits.
-  Each role stays within its shipped tool allowlist; a tool list is not a filesystem sandbox.
-
-## Instruction and execution adapter
-
-Native Claude profiles use Markdown frontmatter with the `effort` field.
-The native `env.CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS` value is a string, distinct from ARC's ledger limits.
-The native tool allowlists and prompt guards are not a filesystem sandbox; local declarations do not prove runtime enforcement.
-
-Apply platform, user, and project instructions according to their precedence, then ARC rules for ownership,
-permissions, models, concurrency, routing, and approvals, then the local ARC reference assigned to the role. A called skill
-adds no agents or authority. Map executor requests such as `superpowers:executing-plans` and
-`superpowers:subagent-driven-development` to Orchestrator's dependency-aware coordination and risk-scaled verification;
-this replaces
-executor mechanics and any separate execution-method choice, including prompts in an existing local reference.
-Preserve plan approval, workspace, design, spec, and other applicable requirements, including TDD subject to the
-explicit ARC exception below. Adapt local `brainstorming` role, save, and early spec commit instructions to
-ARC Planner ownership and evidence gates in planning/handoff; preserve upstream reference content. Report conflicts or
-missing required local references before dependent work.
-
-Planner, Reviewer, and Scouter return findings, relevant questions, next actions, and workspace/path issues to the
-Orchestrator. Planner preserves complete requested drafts. Orchestrator integrates results (save, route,
-obtain approval; never author), routes decisions and required approvals,
-and owns development acceptance and completion. Orchestrator coordinates dependent implementation tasks sequentially and
-starts a fresh Coder for each top-level task; reuse the current Coder only for corrections, rework, or rechecks of the same
-task while the
-approved scope, workspace, ownership, and relevant context remain valid, after Orchestrator rechecks workspace,
-branch/HEAD and change state against the brief. A fresh Coder for the next task is a restart under handoff (choice reuse
-and restart brief rules are there). After an approved plan or acceptance-criteria amendment, start a fresh Coder for
-the remaining work even within the same task. Do not add per-task QA or
-review gates solely because a task boundary exists; apply risk requirements and specific approved obligations. If the
-next task depends on a still-unverified risky contract, complete applicable QA at that dependency boundary and
-resolve or explicitly disposition findings before dependent implementation. This does not create a gate for every task.
-
-## Dependency analysis and parallel dispatch
-
-Before the first Coder assignment for an approved plan, Orchestrator records its dependency/readiness map and
-initial ready batch under [planning](references/planning.md), which owns record fields and readiness conditions.
-File separation alone never proves independence. Pass the full approval/preparation and handoff gates for every
-assignment; unresolved dependencies, shared contracts, or ownership conflicts hold affected work.
-Start all ready independent tasks concurrently with fresh Coders within capacity under [limits](references/limits.md)
-and any lower actual runtime limit; record capacity and serialization reasons. Same-file concurrent Coder edits are
-prohibited, even on different lines. ARC's cap is not a claim of runtime capability.
-
-Reassess readiness after completion reports, new check evidence, acceptance, commit, slot return, or a new conflict.
-Coder completion alone does not release dependents: require predecessor checks, Orchestrator acceptance and verified
-focused commit, or accepted no-change evidence under [commit](references/commit.md). Start newly ready tasks without
-waiting for unrelated batch members; failures hold affected dependents while unaffected ready work may continue.
-Preserve risk-scaled QA/Reviewer timing and execution-target restrictions. Shared-checkout Git coordination belongs to
-commit.md; refresh assignment evidence under [handoff](references/handoff.md).
-
 ## Shared terms
 
-The handoff, git-recovery, and commit references and the Coder profile use these terms; context-specific commands,
+The handoff, handoff-prep, verification, and commit references use these terms; context-specific commands,
 paths, and state checks still apply.
 
 - **Preservation rule**: preserve unrelated staged, unstaged, and untracked changes and edit ownership; never
@@ -119,12 +42,13 @@ paths, and state checks still apply.
   automatically; revalidate affected gates after resolution.
 - **Evidence verdict**: each criterion is proven, unmet, or unverified; passing runs, reports, or disposition never
   turn unverified into proven; reports keep unverified scope visible.
+- **Common handoff gate**: the full verification Orchestrator passes before every Coder first start/restart and
+  Orchestrator direct edit; see [handoff](references/handoff.md#common-handoff-gate).
 
 ## Mandatory task references
 
 Orchestrator and each assigned role must read the applicable references before dependent decisions or actions,
-and Orchestrator must
-include in the role brief the accessible path and section name of each reference section the role must read.
+and Orchestrator must include in the role brief the accessible path and section name of each reference section the role must read.
 Resolve paths relative to this installed skill directory.
 These contracts are conditional on the trigger, mandatory when triggered. Missing, inaccessible, or conflicting
 references must be reported to Orchestrator; stop dependent work until resolved.
@@ -132,235 +56,34 @@ Do not load all references on every task.
 
 | Reference | Required before |
 |---|---|
-| [planning](references/planning.md) | Design/plan-depth judgments, spec/plan drafting or approval, first spec/plan save |
+| [coordination](references/coordination.md) | Before the first specialist creation or assignment and related coordination decisions; role contracts, briefing, adapters, models and token discipline |
+| [limits](references/limits.md) and installed `limits.toml` | Before the first specialist creation; capacity, reservations and cumulative ledger |
+| [planning](references/planning.md) | Design/plan-depth judgments, spec/plan drafting or approval, first spec/plan save; dependency and readiness decisions before assignment |
 | [handoff](references/handoff.md) | Every Coder first start/restart preparation by Orchestrator, and before each Orchestrator direct edit's first edit; Coder trusts the Orchestrator-verified brief under its profile and reads only brief-cited sections |
 | [handoff-prep](references/handoff-prep.md) | Execution-target choice request, each preparation Git mutation (branch creation/switch, staging, commit) |
 | [commit](references/commit.md) | Plan-task acceptance and its focused commit, resuming a task with an unclear commit result |
-| [verification](references/verification.md) | Orchestrator's verification design, QA/Reviewer assignment, correction rechecks, UI acceptance checks; QA and Reviewer use their profiles and only brief-cited sections |
-| [git-recovery](references/git-recovery.md) | Branch collision, Git preparation failure, partial completion, metadata write denial recovery |
+| [verification](references/verification.md) | Orchestrator's verification design, QA/Reviewer assignment, correction rechecks, UI acceptance checks, risk classification, acceptance and completion; QA and Reviewer use their profiles and only brief-cited sections |
+| [git-recovery](references/git-recovery.md) | Branch collision, Git preparation failure, partial completion, metadata write denial, handoff record write denial recovery |
 | [visual-companion](references/visual-companion.md) | Visual companion offer or operation |
 
-Design and plan depth are independent of verification risk. Planner alone uses local brainstorming/writing-plans
-(Role gate);
-Orchestrator integrates complete drafts and obtains applicable approvals. Architectural specs and Bounded written specs
-required by Orchestrator's recorded plan-depth judgment use planning save gates; a required plan alone does not require
-a spec. Obtain explicit execution-target choice and verify actual target preparation before formal drafting
-and saving. Complete all current-scope individual document approvals before the batch docs commit. A missing required skill blocks its stage.
+Before classifying a small-task, plan-omission, or TDD exception, read the full conditions in [handoff](references/handoff.md), including Coder TDD and constraints and Orchestrator direct path for small tasks; read [planning](references/planning.md) for design/plan-depth judgments and [verification](references/verification.md) for the full risk criteria before deciding eligibility. An exception name or this index alone never establishes eligibility.
 
-## Common handoff gate
-
-Before every Coder first start/restart, Orchestrator passes the full gate in
-[handoff](references/handoff.md): applicable approvals/artifacts or valid omissions, explicit execution-target choice
-or verified reuse, intended accessible repository/workspace, actual Git identity/state, preservation/ownership,
-verified document commits or valid absence, and no unresolved failure/partial completion.
-Missing evidence, mismatches, unclear ownership or unresolved preparation block handoff and require Orchestrator
-resolution and full revalidation. Handoff owns the evidence fields, canonical handoff record, restart brief, choice lifetime
-and reuse. Coder trusts the Orchestrator-verified brief and reports actual conflicts under its self-contained profile;
-never replace its local guards with a requirement to load Orchestrator procedures.
-Depth-2 roles use the supplied workspace and report path/state conflicts; they cannot create/switch workspaces or
-branches. The same conditions apply before a Orchestrator direct edit.
-Claude v1 supports the current checkout only; obtain the explicit current-branch or task-branch choice and complete
-approved document preparation under [handoff-prep](references/handoff-prep.md).
-ARC-managed worktree execution is unsupported; report an isolated worktree request before dependent work.
-
-## Coder TDD and constraints
+## Ownership
 
-Before feature, bug-fix, or behavior edits, Coder follows local `test-driven-development` unless the explicit
-ARC exception applies; the Coder profile holds Coder's full TDD rules. TDD is waived only when every small,
-low-risk criterion (Risk-scaled execution) and every plan-skip criterion (Orchestrator direct path) holds.
-Before Coder starts,
-Orchestrator records the scope, why every criterion is met, acceptance criteria, and focused verification in the brief.
-An explicit user or task-specific TDD request overrides
-this waiver. For qualifying tasks only, this exception takes precedence over the generic trigger in the local reference;
-do not change that skill. Ordinary multi-step or significant/high-risk work is not eligible. The waiver skips only
-RED-GREEN steps; focused checks and risk-appropriate QA/Reviewer remain, and do not claim TDD was followed.
-If a constraint blocks a required TDD step, Orchestrator records the
-decision in the brief/plan and obtains any required human approval; internal approval is not a substitute.
-Non-behavior documentation/configuration uses only a specifically authorized exception recorded in the brief; do not
-generalize it to behavior work.
+Read [coordination](references/coordination.md#ownership) before assigning roles. Only Orchestrator accepts work; specialists report directly at depth 2 and cannot delegate.
 
 ## Risk-scaled execution
 
-Orchestrator assigns edits exclusively to Coder except under the Orchestrator direct path below, and determines affected
-behavior, risk,
-and smallest meaningful verification.
-
-| Risk | Minimum flow |
-|---|---|
-| Small, low risk | Coder, or Orchestrator direct path → Orchestrator's focused checks → acceptance |
-| Ordinary behavior | Coder → independent QA → acceptance |
-| Significant/high risk | Coder → QA → independent Reviewer of the final full change → acceptance; with a plan, each plan task Coder → FRESH QA → acceptance/commit satisfies the QA step, then independent Reviewer once on the final full change after all plan tasks |
-
-Ordinary and significant plan tasks need a FRESH QA before acceptance; only small, low-risk tasks may be accepted on
-Orchestrator focused checks. Small, low risk means narrow, understood, readily reversible, and verifiable by focused
-checks. Ordinary behavior
-fails those conditions without a significant-risk trigger. Significant risk includes shared role/behavior contracts,
-shared state, lifecycle/integration order, security/permissions, data loss/migration, public interfaces, or costly
-installation/deployment/rollback. Substantial behavior or contract changes are significant regardless of file count.
-Unclear risk requires
-investigation or the higher flow. Environment failure does not waive checks or determine design depth.
-
-Do not add per-task gates automatically. Reviewer is never a plan-task acceptance prerequisite; for significant work
-with a
-plan, it reviews the final full change once after all plan tasks are accepted with their risk-scaled checks,
-following the last plan task's required checks and any QA recheck at the final relevant state; significant work without
-a plan
-keeps Reviewer after QA before acceptance. Preserve specific approved obligations and complete risky dependency checks
-before dependent implementation. Reuse evidence only when scope, relevant state, independence, freshness, and flow
-position satisfy each covered requirement; changes, failures, or missing/conflicting evidence invalidate affected reuse.
-QA checks independently without edits; Reviewer independently reads the final full change after QA for significant
-work, without QA, planning, edits, delegation, or completion decisions. Orchestrator routes fixes to Coder,
-obtains affected QA rechecks outside the final plan Reviewer correction exception and required final review, and accepts after findings/evidence gaps are resolved or
-explicitly dispositioned.
-
-Criterion verdicts follow the Evidence verdict.
-
-### Final plan Reviewer correction loop
+Read [verification](references/verification.md#risk-scaled-execution) before risk classification, verification design, assignment or acceptance. It holds the risk table, risk definitions, evidence-reuse rule and role order.
 
-For a plan's final overall Reviewer findings, including behavior findings, Orchestrator assigns
-Coder → Reviewer recheck with no QA reassignment. Repeat corrections and Reviewer rechecks until findings are resolved;
-the initial single full review does not prohibit necessary rechecks. Before the initial final overall Reviewer,
-risk-required checks and QA execution failures or unmet criteria still require Coder correction → QA recheck.
-This exception applies only to findings from the final overall Reviewer of work with a plan.
-Work without a plan retains its existing verification flow. Scope expansion, separate mandatory obligations,
-or unresolved evidence gaps hold affected work for Orchestrator to resolve and obtain required approvals.
-Orchestrator assigns corrections/rechecks and decides acceptance. Reviewer remains read-only, must not run QA
-checks or decide acceptance. Previous QA evidence must not be presented as post-fix execution evidence;
-report only checks actually performed, their actor, target state, results and remaining limits.
-
-Read verification for evidence fields, failure/finding flow, UI permissions, cleanup and acceptance reporting.
-
-Authorization evidence and probe/combined scope are owned by [planning](references/planning.md#authorization-and-scope);
-valid reuse and actual-state refresh by [handoff](references/handoff.md#authorization-continuity).
-After gates hold, continue approved no-doc scope through required checks and Orchestrator acceptance under
-[verification](references/verification.md#completion-continuity); a role report alone does not complete the work.
-
-## Orchestrator direct path for small tasks
-
-Orchestrator may edit directly only when every small, low-risk criterion (Risk-scaled execution) holds.
-Every plan-skip criterion must also hold: one local change, no dependent stages, no cross-component shared state,
-lifecycle, or integration-order concerns, and one focused verification path. Significant, architectural,
-ordinary-behavior, unclear-risk work and edits overlapping a running Coder's assigned files are ineligible.
-
-Significant risk is defined in Risk-scaled execution and excludes work from the Orchestrator direct path;
-do not infer eligibility from a small file count.
-
-Before editing, Orchestrator records a scope record (not a brainstorming design) with scope and files,
-why every criterion holds, acceptance criteria, and focused verification. Apply authorization in
-[planning](references/planning.md#authorization-and-scope): an existing sufficiently specific user request can approve
-that scope; no duplicate approval is needed. Otherwise present the scope record to the user and obtain explicit
-approval before editing. Silence, an ambiguous response, or approval of other work is not approval.
-Orchestrator then verifies the same handoff gate as a Coder first start: explicit execution-target choice or valid
-reuse, accessible intended workspace and repository, branch or detached HEAD, HEAD, staged/unstaged/untracked state,
-preservation and ownership, and no unresolved failure or partial completion. Read the [handoff](references/handoff.md)
-and [handoff preparation](references/handoff-prep.md) references before checking this gate.
-
-Orchestrator edits only the approved files, preserves others' edits, and makes surgical changes without unrelated
-refactoring or unapproved dependencies. Behavior edits follow the Coder TDD rules and applicable recorded waiver
-criteria; an explicit user or task-specific TDD request still requires test-driven-development.
-Do not claim TDD under a waiver. After editing, Orchestrator records changed files, runs focused checks,
-connects each acceptance criterion to evidence, and reports unverified scope. Orchestrator is not an independent
-reviewer of its own edits; assign QA when evidence is incomplete. If scope expands, risk becomes unclear,
-or any criterion fails, stop editing, record completed changes, and return subsequent edits to the normal Planner/Coder
-flow. A failed focused check or a QA finding routes the correction to Coder, and it is rechecked; Orchestrator does not
-self-correct.
-
-Like other plan-skip
-paths, there is no automatic task commit; commits follow applicable guidance and user requests.
-
-## Automatic commit after plan-task acceptance
-
-Orchestrator accepts each approved top-level task by its own judgment and immediately creates one focused local commit
-for that
-task without additional user commit approval. Read [commit](references/commit.md) before the acceptance and commit.
-Push, merge, publish, deploy, and install still follow their separate guidance and approval rules.
-
-## Token discipline and handoffs
-
-- Only Orchestrator invokes Claude native subagents or assigns specialist tasks. Give each invocation a descriptive role
-  and bounded objective; the installed native profile determines its role and local model declarations.
-
-- Keep one shared brief with fixed field order: Goal; Criteria (IDs); Exact scope/ownership (absolute workspace,
-  branch or detached HEAD and HEAD, handoff record path, when one exists, files);
-  Constraints/decisions; Evidence (paths/lines, commands, artifact links); Prior findings; Exact next objective (one
-  bounded objective); Return format (conclusion, evidence locations, unresolved points, next step).
-  On follow-ups send only changed fields and mark the rest `unchanged` (relative to a brief the recipient received);
-  restart briefs follow handoff; a fresh specialist gets every other field in full. Send only the
-  self-contained subset needed by the next role and links to accessible artifacts; omit full history, repeated
-  instructions, and raw logs. No findings may be brief; requested deliverables such as complete plan drafts remain
-  complete. Cite paths/lines/pages/commands/links instead of logs; investigate gaps only.
-- `AskUserQuestion` questions use only `question`, a `header` of at most 12 characters, 2-4 `options` each with `label`
-  and `description`, and `multiSelect`.
-- Always start an ARC role by its installed native name (`arc-*`) with only the supplied scoped brief;
-  never use a context-inheriting fork (such as the `fork` subagent type) for an ARC role; do not claim fresh context
-  isolation without evidence. Reuse an existing specialist for related follow-up with only changed facts/objective when
-  its context
-  remains relevant; start fresh for unrelated or bloated context. Coder and QA freshness follow the Role gate.
-- Cite in the brief the absolute path of each required local ARC reference's SKILL.md (`test-driven-development` for Coder,
-  `brainstorming`/`writing-plans` for Planner); the role Reads it before dependent work.
-- For Reviewer, Orchestrator writes the final base..HEAD diff plus changed-file list to
-  `<git-common-dir>/arc/review/<slug>.diff` (same slug as the handoff record; base is the approved base HEAD recorded at
-  handoff; inline when small or write denied) and cites its absolute path in the brief; Reviewer reads it and states
-  limits. See verification.
-- In Coder briefs, cite the plan/spec path with the task section's line range and include only the needed excerpts,
-  acceptance criteria, and constraints; do not ask Coder to read whole plans or specs.
-- Before optional calls, name the unresolved question and expected artifact. Skip calls whose questions are resolved
-  by available evidence or direct inspection.
-- Run each ARC role as a foreground Agent call and use its returned result, or run it in the background and wait for the
-  completion notification; report unavailable execution to Orchestrator rather than inventing an API.
-  Do not poll status in loops; never sleep-poll. A timeout or delay is not a reason to poll or check status in between.
-  Send one complete brief per objective and batch related corrections. For long Bash commands set a sufficient `timeout`
-  or use `run_in_background` and wait for its completion notification.
-
-- Read only the needed ranges of files and outputs (for example `rg -n`, `sed -n`, `head`/`tail`) and cap long command
-  output. Do not re-read files or outputs already in context unless they changed. A mandatory reference already read in
-  this context and unchanged need not be re-read, and this skill file, once read in this context and unchanged,
-  is not re-read on follow-up turns;
-  this does not shorten any triggered mandatory reference read.
-- When a plan completes or before starting another plan in a session with long history, Orchestrator records the
-  canonical
-  handoff state in the handoff record file and recommends that the user continue in a new session.
-- Before handoff, post one short update with role/objective/expected output; after return, combine findings and next
-  stage concisely. Do not expose hidden reasoning or raw prompts.
-
-### Local superpowers references
-
-Orchestrator briefs absolute paths under the selected installed ARC directory: Planner reads
-`references/superpowers/brainstorming/SKILL.md` and `references/superpowers/writing-plans/SKILL.md`;
-Coder reads `references/superpowers/test-driven-development/SKILL.md`, including required relative references.
-Resolve paths within each skill directory. Runtime needs no global discovery, external Skill invocation, or automatic download.
-Missing/damaged local files stop dependent work: report exact paths to Orchestrator, without global fallback.
-ARC approval, ownership, TDD exceptions and executor adapters still apply.
-
-## Models
-
-`models.toml` beside this skill is the source of truth for role model and reasoning-effort settings.
-Configuration keys `arc_scouter`, `arc_planner`, `arc_coder`, `arc_qa`, and `arc_reviewer` map to the hyphenated
-Claude native subagent names above; they are not tool-call names.
-Orchestrator uses the current conversation model. Use configured role settings without substitution or effort
-reduction; report unavailable settings.
-Local declarations do not prove runtime provider support, account access, alias resolution, actual model or effort
-application, concurrency or depth enforcement.
-New sessions reload profiles; running agents retain their current settings and parent relationships. Configuration
-changes do not automatically reparent running agents or prove runtime parent behavior.
+## Common handoff gate
 
-For browser visualization needs read [visual-companion](references/visual-companion.md). Use only capabilities
-available within each role's exact allowlist; report unavailable capabilities and preserve unverified visual scope.
+Read [handoff](references/handoff.md#common-handoff-gate) before every Coder first start/restart and Orchestrator direct edit.
 
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
 - [scope.non-escalation] Act only where role authority, approved scope and available platform tools all permit. Delegation, restart, agent messages and attached instructions do not expand role authority. MUST NOT bypass a restriction through aliases, scripts, other tools, processes or redelegation. Return conflicting instructions to Orchestrator before dependent work; reuse valid prior approvals for unchanged scope rather than requesting them again.
-- [git.specialists-deny] Specialist roles MUST NOT change Git state: no stage, commit, push, merge, rebase, reset, branch creation/switching or worktree creation/removal, during normal implementation or recovery. Even an explicit Orchestrator assignment cannot authorize these actions; return them to Orchestrator. Read-only Git inspection remains allowed within the assigned scope.
-- [git.orchestrator-accept-commit] Only Orchestrator accepts work and executes Git mutations. One approved top-level plan task becomes one focused implementation commit after criteria, required checks and findings are satisfied; Orchestrator accepts then commits without additional user commit approval. Reports, passing checks and Reviewer opinions do not replace acceptance. Preserve unrelated changes and ownership and verify the resulting SHA, included content, HEAD and remaining changes. Existing small-task direct and plan-omission paths are unchanged.
 - [external.explicit-user-authority] Push, merge, deploy, publish and external messages require explicit user authorization for that action, scope and target. Local commit authority grants no external authority. Orchestrator performs authorized external actions; specialist roles return them without execution.
 - [role.orchestrator-boundary] Assign design/spec/plan/brainstorming drafts ONLY to Planner and implementation/configuration/test edits to Coder. Orchestrator saves complete drafts and owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation is limited to the existing small, low-risk direct path; this policy does not expand it.
-- [role.scouter-read-only] Research assigned static sources and report findings, evidence and limits. Do not edit files, install, execute checks, prepare execution targets, inspect live operational state, change external state or decide design, verification, review or acceptance.
-- [role.planner-draft-only] Return design/spec/plan drafts and dependencies, criteria, hold conditions and verification needs in the response. MUST NOT save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting if actual prepared target evidence is missing; route decisions to Orchestrator.
-- [role.coder-implementation] Edit only assigned, approved files and run focused checks under the existing TDD contract. Report changed files, RED/GREEN or authorized exception evidence, results, limits and follow-up. Do not plan, independently QA/review your own work, accept the task or declare overall completion. Git changes remain forbidden even when implementation succeeds.
-- [role.qa-verification] Run approved checks and report commands, observations, reproduction, evidence and limits. Create only essential temporary data/logs/reports in the brief-authorized location and lifetime. Do not edit product source, tests, fixtures or configuration to pass checks, deploy or accept work. Persistent product-state checks require explicit scope and cleanup ownership. Return failures for Coder correction and required QA recheck.
-- [role.reviewer-independent] Independently inspect the assigned final changes and evidence and report actionable findings and limits. Remain read-only. MUST NOT execute QA tests, edit files, perform Git mutations or decide acceptance.
-- [review.significant-no-plan] For significant/high-risk work without a plan: Coder → QA and required QA rechecks → Reviewer of the final full change → Orchestrator acceptance. MUST NOT omit Reviewer merely because no plan exists. This creates no new plan obligation.
-- [review.significant-plan] For significant/high-risk plan work: each task uses Coder → fresh QA as required → Orchestrator acceptance and focused commit. After all tasks are accepted and required QA is complete, Reviewer reviews the final full change once. Reviewer is NOT a per-task or per-commit required gate. Preserve required checks and necessary finding rechecks.
-- [review.final-plan-recheck] For final overall Reviewer findings on plan work, including behavior findings, use Coder → Reviewer without QA reassignment; repeat until resolved. This exception applies only at the final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
 - [platform.claude] Existing per-role tool allowlists reduce available tools; Bash and role contracts are not a filesystem sandbox. A role-scoped Git guard is a separate integration and is not supplied by these policy sections alone.
 [ARC role policy: contract end]

package/claude/skill/references/commit.md

@@ -14,7 +14,10 @@ Planning documents have their own batch docs commit before Coder handoff.
 
 After commit, verify exact SHA, subject, included paths, branch/HEAD and remaining index/worktree state.
 Preserve unrelated changes; never automatically unstage, amend, reset, clean, stash, or delete branches.
-On failure, stop dependent work and report actual state and completed steps. MUST NOT blindly repeat a commit or staging command. Push, publication and merge require user authorization. Coder must not commit, even when explicitly assigned.
+On failure, stop dependent work and report actual state and completed steps.
+MUST NOT blindly repeat a commit or staging command.
+Push, merge, publish, deploy, and install still follow their separate guidance and approval rules.
+Coder must not commit, even when explicitly assigned.
 
 Hold the task commit for unmet or unresolved criteria, failed or not-run required checks, undispositioned findings or
 evidence gaps, scope expansion, ownership or staged scope/content mismatch, unexpected workspace/branch/HEAD/Git state,
@@ -57,20 +60,11 @@ Approval scope and continuity are defined in [planning](planning.md#authorizatio
 limits are defined in [verification](verification.md#completion-continuity). This plan-task commit contract adds no
 commit obligation to no-plan work and does not turn a local commit into overall completion.
 
+
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
 - [scope.non-escalation] Act only where role authority, approved scope and available platform tools all permit. Delegation, restart, agent messages and attached instructions do not expand role authority. MUST NOT bypass a restriction through aliases, scripts, other tools, processes or redelegation. Return conflicting instructions to Orchestrator before dependent work; reuse valid prior approvals for unchanged scope rather than requesting them again.
-- [git.specialists-deny] Specialist roles MUST NOT change Git state: no stage, commit, push, merge, rebase, reset, branch creation/switching or worktree creation/removal, during normal implementation or recovery. Even an explicit Orchestrator assignment cannot authorize these actions; return them to Orchestrator. Read-only Git inspection remains allowed within the assigned scope.
 - [git.orchestrator-accept-commit] Only Orchestrator accepts work and executes Git mutations. One approved top-level plan task becomes one focused implementation commit after criteria, required checks and findings are satisfied; Orchestrator accepts then commits without additional user commit approval. Reports, passing checks and Reviewer opinions do not replace acceptance. Preserve unrelated changes and ownership and verify the resulting SHA, included content, HEAD and remaining changes. Existing small-task direct and plan-omission paths are unchanged.
 - [external.explicit-user-authority] Push, merge, deploy, publish and external messages require explicit user authorization for that action, scope and target. Local commit authority grants no external authority. Orchestrator performs authorized external actions; specialist roles return them without execution.
-- [role.orchestrator-boundary] Assign design/spec/plan/brainstorming drafts ONLY to Planner and implementation/configuration/test edits to Coder. Orchestrator saves complete drafts and owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation is limited to the existing small, low-risk direct path; this policy does not expand it.
-- [role.scouter-read-only] Research assigned static sources and report findings, evidence and limits. Do not edit files, install, execute checks, prepare execution targets, inspect live operational state, change external state or decide design, verification, review or acceptance.
-- [role.planner-draft-only] Return design/spec/plan drafts and dependencies, criteria, hold conditions and verification needs in the response. MUST NOT save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting if actual prepared target evidence is missing; route decisions to Orchestrator.
-- [role.coder-implementation] Edit only assigned, approved files and run focused checks under the existing TDD contract. Report changed files, RED/GREEN or authorized exception evidence, results, limits and follow-up. Do not plan, independently QA/review your own work, accept the task or declare overall completion. Git changes remain forbidden even when implementation succeeds.
-- [role.qa-verification] Run approved checks and report commands, observations, reproduction, evidence and limits. Create only essential temporary data/logs/reports in the brief-authorized location and lifetime. Do not edit product source, tests, fixtures or configuration to pass checks, deploy or accept work. Persistent product-state checks require explicit scope and cleanup ownership. Return failures for Coder correction and required QA recheck.
-- [role.reviewer-independent] Independently inspect the assigned final changes and evidence and report actionable findings and limits. Remain read-only. MUST NOT execute QA tests, edit files, perform Git mutations or decide acceptance.
-- [review.significant-no-plan] For significant/high-risk work without a plan: Coder → QA and required QA rechecks → Reviewer of the final full change → Orchestrator acceptance. MUST NOT omit Reviewer merely because no plan exists. This creates no new plan obligation.
-- [review.significant-plan] For significant/high-risk plan work: each task uses Coder → fresh QA as required → Orchestrator acceptance and focused commit. After all tasks are accepted and required QA is complete, Reviewer reviews the final full change once. Reviewer is NOT a per-task or per-commit required gate. Preserve required checks and necessary finding rechecks.
-- [review.final-plan-recheck] For final overall Reviewer findings on plan work, including behavior findings, use Coder → Reviewer without QA reassignment; repeat until resolved. This exception applies only at the final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
 - [platform.claude] Existing per-role tool allowlists reduce available tools; Bash and role contracts are not a filesystem sandbox. A role-scoped Git guard is a separate integration and is not supplied by these policy sections alone.
 [ARC role policy: contract end]