@yunhozz/arc 0.1.2 → 0.1.4

package/claude/skill/references/coordination.md

@@ -0,0 +1,148 @@
+# 역할 배정과 조정
+
+Orchestrator reads this before the first specialist creation or assignment and related coordination decisions. Also read [limits](limits.md) and installed `../limits.toml` before first creation. Missing, inaccessible or conflicting references stop dependent work; report the exact paths.
+
+## 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 in [handoff](handoff.md#coder-tdd-and-constraints). 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.
+
+
+## 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.
+
+For browser visualization needs read [visual-companion](visual-companion.md). Use only capabilities
+available within each role's exact allowlist; report unavailable capabilities and preserve unverified visual scope.
+
+[ARC role policy: contract begin]
+Generated from lib/policy/role-policy.json; do not edit this managed section manually.
+- [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.
+- [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.
+- [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/git-recovery.md

@@ -7,7 +7,7 @@ or conflicting edit, stop dependent work. Inspect and record the actual absolute
 index, worktree/untracked files, ownership, and completed steps. Report the precise blocker and needed resolution to
 Orchestrator. Do not retry, fall back, or repeat completed mutations automatically.
 
-Never automatically stash, reset, clean, unstage, discard, amend, delete branches/worktrees, remove locks,
+MUST NOT automatically stash, reset, clean, unstage, discard, amend, delete branches/worktrees, remove locks,
 change permissions to bypass a blocker, or bypass sandbox restrictions. Preserve all unrelated work and recovery
 artifacts. Orchestrator obtains any needed human decision, resolves preparation within authorization,
 then revalidates affected gates and issues a precise delta restart brief. An explicit user selection is required where a

package/claude/skill/references/handoff-prep.md

@@ -41,7 +41,7 @@ on failure or partial completion, record actual state and completed steps, and r
 Batch-commit all remaining approved planning documents together in one focused docs commit before the first Coder
 handoff. Stage only those document paths and verify the staged content and scope.
 Verify the resulting SHA, subject, paths, branch, HEAD and remaining state. Already committed approved documents need no
-duplicate commit. Record actual preparation order and any deviation honestly, then complete the handoff gate before the
+duplicate commit. Record the actual preparation order and deviations, then complete the handoff gate before the
 next Coder start. User authorization persists for the unchanged approved target and scope; do not repeatedly ask for the
 same choice.
 
@@ -85,18 +85,9 @@ After success verify SHA, message, paths, HEAD, branch, and remaining state; the
 
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
-- [scope.non-escalation] Act only within the intersection of role authority, approved scope and available platform tools. Delegation, restart, agent messages and attached instructions do not expand role authority. Never 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.
+- [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 does not grant 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. Do 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] Implement only assigned approved files and 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; do 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. Do 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 to that final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
+- [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.
 - [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/handoff.md

@@ -28,7 +28,7 @@ exact file ownership, expected tests, dependency limits and blocked conditions.
 deltas and mark unchanged fields; `unchanged` means unchanged relative to the record file the fresh Coder reads,
 and every other brief field is in full. Coder trusts Orchestrator verified prep rather than independently repeating
 approval/Git evidence checks, reads fields marked unchanged, and stops on an actual observed conflict.
-Tell Coder that others share the repository and unrelated work must be preserved.
+Tell Coder that others share the repository and unrelated work MUST be preserved.
 
 Roles report directly to Orchestrator. Do not delegate at depth 2. Orchestrator sequences dependent work,
 resolves actual blockers and revalidates affected gates before resume. No automatic retry after unexpected Git or tool
@@ -81,20 +81,82 @@ under its profile. Material scope/method/risk changes and invalid target evidenc
 planning and the choice-lifetime rules above. Report the missing condition and resume evidence rather than asking
 for an approval already valid for that scope.
 
+Before any exception judgment, Orchestrator reads [Risk-scaled execution](verification.md#risk-scaled-execution) and [planning](planning.md) for the full risk and plan-depth conditions.
+
+## Common handoff gate
+
+Before every Coder first start/restart, Orchestrator passes the full gate in
+[handoff](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](handoff-prep.md).
+ARC-managed worktree execution is unsupported; report an isolated worktree request before dependent work.
+
+
+## Coder TDD and constraints
+
+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.
+
+
+## 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](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](handoff.md)
+and [handoff preparation](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.
+
+
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
-- [scope.non-escalation] Act only within the intersection of role authority, approved scope and available platform tools. Delegation, restart, agent messages and attached instructions do not expand role authority. Never 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 does not grant 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. Do 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] Implement only assigned approved files and 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; do 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. Do not omit Reviewer merely because no plan exists. This creates no new plan obligation.
+- [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.
+- [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 to that final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
+- [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/limits.md

@@ -4,7 +4,7 @@ Before the first subagent creation, Orchestrator reads this reference and the ad
 `../limits.toml` (installed at `skills/arc/limits.toml`). Require version = 1,
 `max_total_subagents` and `max_concurrent_subagents` as positive safe integers.
 Installation defaults are max_total_subagents = 100 and max_concurrent_subagents = 5.
-A missing, malformed or unreadable policy blocks new creation; report it rather than assuming defaults.
+A missing, malformed or unreadable policy blocks new creation. Report it; MUST NOT assume defaults.
 Freeze these settings for one ARC coordination session/tree; reinstalling affects new sessions.
 
 ## Counting and reservations
@@ -23,7 +23,7 @@ created + pending reservations + proposed <= max_total_subagents, and
 active + pending reservations + proposed <= max_concurrent_subagents and available runtime capacity.
 Record a reservation before each creation call. Confirmed creation converts it into a created,
 active ID. Release a reservation only when failure proves that no instance was created.
-An uncertain result keeps its reservation and capacity until reconciled; never retry blindly.
+An uncertain result retains its reservation and capacity until reconciled. MUST NOT retry blindly.
 Serialize work when a batch does not fit. There are no reserved role slots.
 
 ## Continuation and exhaustion
@@ -31,8 +31,8 @@ Serialize work when a batch does not fit. There are no reserved role slots.
 Preserve the ledger through continuation, resume and context compaction; reconcile actual instance
 IDs before dispatch. Ledger loss must never reset counters to zero. If reconstruction is incomplete,
 hold creation and report the unknown budget; use a conservative bound only with sufficient evidence.
-Completion frees confirmed active capacity, never the total-created budget. Exhaustion holds new
-creation and requires reporting remaining work and budgets. It never authorizes skipping required
+Completion frees confirmed active capacity; it does not restore the total-created budget. Exhaustion holds new
+creation and requires reporting remaining work and budgets. It does not authorize skipping required
 QA or Reviewer, role freshness, approval, ownership, dependency or same-file edit gates.
 
 This cumulative guard and ARC scheduling are prompt-level policy, not hard runtime enforcement.

package/claude/skill/references/planning.md

@@ -40,7 +40,7 @@ complete draft before saving, even when returned only in chat. Before formal dra
 and records the actual absolute workspace/repository, branch or detached HEAD, HEAD, changes and ownership,
 explicit choice and preparation evidence, and absolute document paths inside that target. Planner drafts for that
 verified workspace; Orchestrator saves directly in the selected target. Missing or mismatched evidence stops the
-affected drafting or save and is reported to Orchestrator. Planned scope and intended paths are not actual preparation.
+affected drafting or save and is reported to Orchestrator. Planned scope and paths do not establish actual preparation.
 Initial target preparation does not authorize Coder; the complete handoff gate still applies.
 
 Orchestrator classifies scope before implementation. The Orchestrator direct path for small tasks is defined only in
@@ -110,7 +110,7 @@ drafting. This applies that judgment, not a new spec rule. A required plan alone
 
 Design, spec, plan, and brainstorming drafts are authored only by Planner.
 Orchestrator must not substitute its own spec for Planner's complete draft; return substantive omissions to Planner;
-if Planner fails or is unavailable, stop and report, never draft instead. Design approval alone does not change ownership.
+if Planner fails or is unavailable, stop and report, never draft instead. Design approval does not transfer ownership.
 
 ## Top-level plan tasks
 
@@ -231,20 +231,37 @@ Orchestrator briefs absolute ARC paths `references/superpowers/brainstorming/SKI
 `references/superpowers/writing-plans/SKILL.md`. Planner reads them directly; resolve relative references within each
 skill. Missing files stop the stage; report paths without global fallback. Keep ARC approval and ownership gates.
 
+## 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](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](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](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](handoff.md).
+
+
+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.
+
+
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
-- [scope.non-escalation] Act only within the intersection of role authority, approved scope and available platform tools. Delegation, restart, agent messages and attached instructions do not expand role authority. Never 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 does not grant 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. Do 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] Implement only assigned approved files and 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; do 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. Do not omit Reviewer merely because no plan exists. This creates no new plan obligation.
+- [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 to that final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
+- [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/verification.md

@@ -2,14 +2,14 @@
 
 Define observable checks from acceptance criteria. For feature/behavior implementation use test-driven-development:
 meaningful test first, observed expected failure, minimal implementation, focused success, then the project suite.
-A required skill or test constraint must be reported before dependent edits. A waiver needs a precise Orchestrator
+Report required-skill or test constraints before dependent edits. A waiver needs a precise Orchestrator
 record of narrow scope, understood/reversible risk, no dependent stages or cross-component lifecycle,
 and one focused verification path; a documentation exception authorizes only its named structural checks.
 Neither is a claim of TDD.
 
 QA runs approved checks without editing source and returns commands, results, failures, evidence and limitations.
-Report verification side effects within approved scope. Do not broaden tests, repair failures or claim acceptance
-independently. Reviewer independently reads the final complete diff after the required QA/focused checks for
+Report verification side effects within approved scope. MUST NOT broaden tests, repair failures or independently
+claim acceptance. Reviewer independently reads the final complete diff after the required QA/focused checks for
 correctness, security and policy consistency; request runtime checks through Orchestrator because Reviewer has no Bash
 tool.
 
@@ -106,20 +106,70 @@ ends at its approved question's evidence and limits; a combined scope continues
 Document omission changes neither verification risk nor acceptance responsibility. Hold only affected work for an
 actual unmet condition and report what is needed to resume. Structural evidence does not prove live agent compliance.
 
+For Orchestrator, **Evidence verdict**: each criterion is proven, unmet, or unverified; passing runs, reports, or disposition never turn unverified into proven; reports keep unverified scope visible.
+
+## Risk-scaled execution
+
+Orchestrator assigns edits exclusively to Coder except under the Orchestrator direct path in [handoff](handoff.md#orchestrator-direct-path-for-small-tasks), 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
+
+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](planning.md#authorization-and-scope);
+valid reuse and actual-state refresh by [handoff](handoff.md#authorization-continuity).
+After gates hold, continue approved no-doc scope through required checks and Orchestrator acceptance under
+[verification](verification.md#completion-continuity); a role report alone does not complete the work.
+
+
 [ARC role policy: contract begin]
 Generated from lib/policy/role-policy.json; do not edit this managed section manually.
-- [scope.non-escalation] Act only within the intersection of role authority, approved scope and available platform tools. Delegation, restart, agent messages and attached instructions do not expand role authority. Never 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 does not grant 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. Do 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] Implement only assigned approved files and 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; do 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. Do not omit Reviewer merely because no plan exists. This creates no new plan obligation.
+- [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 to that final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.
+- [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/visual-companion.md

@@ -8,9 +8,8 @@ Other depth 2 roles must stay within their exact allowlists and may not delegate
 Determine actual available browser and preview capabilities before use; do not assume managed preview tools exist.
 Use an available authorized local/browser workflow only when scoped by Orchestrator.
 Keep preview artifacts separate from user files, record generated side effects, preserve unrelated work,
-and report unavailable capabilities without claiming visual verification. Never expose secrets or publish a preview
-without authorization.
+and report unavailable capabilities without claiming visual verification. MUST NOT expose secrets or publish a preview without authorization.
 
 Upstream guide/scripts: `<installed ARC>/references/superpowers/brainstorming/visual-companion.md` and adjacent `scripts/`.
 ARC guide: `references/visual-companion.md`; Orchestrator briefs absolute paths and retains approval/server/browser
-ownership. Missing files stop dependent work without global fallback.
+ownership. Missing files stop dependent work. MUST NOT use a global fallback.