@uzysjung/agent-harness 26.152.0 → 26.154.0

package/templates/skills/external-model-consult/scripts/codex-ask.sh

@@ -146,17 +146,22 @@ env -i PATH="$PATH" HOME="$HOME" TERM="${TERM:-dumb}" \
   "$CODEX" "${ARGS[@]}" 1>&2 &
 CPID=$!
 TIMED_OUT=0
-ELAPSED=0
+# Poll at 200 ms, not 1 s (#411): with a 1 s tick every call paid up to a full second of idle
+# wait after the CLI had already exited, which is what pushed the wrapper's test cases toward
+# vitest's 5 s budget on a busy machine. TICKS counts fifths of a second; both BSD and GNU
+# `sleep` accept the fractional argument.
+TICKS=0
+TICK_LIMIT=$((TIMEOUT_S * 5))
 while kill -0 "$CPID" 2>/dev/null; do
-  if [ "$ELAPSED" -ge "$TIMEOUT_S" ]; then
+  if [ "$TICKS" -ge "$TICK_LIMIT" ]; then
     TIMED_OUT=1
     kill "$CPID" 2>/dev/null || true
     sleep 2
     kill -9 "$CPID" 2>/dev/null || true
     break
   fi
-  sleep 1
-  ELAPSED=$((ELAPSED + 1))
+  sleep 0.2
+  TICKS=$((TICKS + 1))
 done
 set +e
 wait "$CPID"

package/templates/skills/external-model-consult/scripts/gemini-ask.sh

@@ -183,17 +183,22 @@ env -i PATH="$PATH" HOME="$HOME" TERM="${TERM:-dumb}" \
   "$AGY" --model="$MODEL" -p "$PROMPT" >"$MSGFILE" &
 APID=$!
 TIMED_OUT=0
-ELAPSED=0
+# Poll at 200 ms, not 1 s (#411): with a 1 s tick every call paid up to a full second of idle
+# wait after the CLI had already exited, which is what pushed the wrapper's test cases toward
+# vitest's 5 s budget on a busy machine. TICKS counts fifths of a second; both BSD and GNU
+# `sleep` accept the fractional argument.
+TICKS=0
+TICK_LIMIT=$((TIMEOUT_S * 5))
 while kill -0 "$APID" 2>/dev/null; do
-  if [ "$ELAPSED" -ge "$TIMEOUT_S" ]; then
+  if [ "$TICKS" -ge "$TICK_LIMIT" ]; then
     TIMED_OUT=1
     kill "$APID" 2>/dev/null || true
     sleep 2
     kill -9 "$APID" 2>/dev/null || true
     break
   fi
-  sleep 1
-  ELAPSED=$((ELAPSED + 1))
+  sleep 0.2
+  TICKS=$((TICKS + 1))
 done
 set +e
 wait "$APID"

package/templates/skills/model-orchestration/SKILL.md

@@ -1,273 +1,129 @@
 ---
 name: model-orchestration
 description: >-
-  Apply the fixed model-role and thinking-effort policy whenever work is delegated to subagents
-  or a model/effort choice is made: the orchestrator (top-tier model, Fable) DIRECTLY owns
-  설계·기획·분배·리뷰 — sets direction, reviews plan/spec docs, improves shipped features, and hunts
-  perf/security problems; core implementation, test authoring/execution
-  (E2E included), and code verification/V&V go to Opus at xhigh or above;
-  repetitive/simple implementation goes to Sonnet at high or above — Sonnet is never used for
-  tests or verification; plan/spec drafts may be produced by Opus from a Fable direction brief,
-  but the review/decision is always Fable's. Never delegate below the effort floors. Use whenever
-  you are about to spawn an Agent/Task/Workflow worker, pick a model for a subtask, set a
-  thinking/effort level, or assign verification. Trigger on "위임해", "오케스트레이션", "모델 역할분담", "어떤 모델로",
-  "effort 얼마로", "서브에이전트", "delegate this", "which model should". Fire even when the
-  user doesn't name the policy — any delegation is in scope.
+  Select models, reasoning effort, and delegation boundaries for a task. Use when
+  choosing direct execution versus subagents, allocating parallel work or
+  independent review, or reducing multi-agent token and context overhead. Favor
+  context reuse and add model calls or workers when their expected contribution
+  justifies the cost.
 ---
 
-# Model Orchestration Policy
+# Model Orchestration
 
-**What is policy and what is vocabulary.** The policy is the role split — orchestrator ≠ builder ≠
-verifier — and the rule that verification never goes to a lower tier than the work it verifies.
-`Fable` · `Opus` · `Sonnet` and the effort levels (`xhigh` · `high` · `max`) are Claude Code
-vocabulary. On Codex, OpenCode, or Antigravity apply the same split with that vendor's top tier for
-orchestration and verification and its mid tier for repetitive implementation; an effort knob that
-does not exist there is not a violation — putting verification on a lower tier is.
-
-A fixed role split between model tiers, set by the user (2026-07-04, revised 2026-07-07 and
-2026-08-02 — *"설계·분배·기획·리뷰는 Fable5, 핵심 구현·테스트·검증은 opus5, 반복·단순 구현은
-sonnet"*). The premise is
-**quality-over-cost**: delegation floors are set at the effort levels Anthropic itself
-recommends for intelligence-sensitive work ("start with xhigh for coding and agentic use
-cases, high as the minimum for most intelligence-sensitive workloads" — official effort
-guidance), not at the cost-saving end ("low ... like subagents"). When this policy and a
-cost instinct conflict, the policy wins; surface the cost, don't silently downgrade.
-
-## Role split
-
-| Role | Who | Effort floor | Duties |
-|------|-----|--------------|--------|
-| **Orchestrator + Product Manager** | Top-tier session model (Fable) | session level | 설계·기획·분배·**리뷰** 전부. Directly: 서비스 방향성 수립·논의, 설계 결정·트레이드오프 확정, 작업 분배, 기획/스펙문서 **리뷰·중재**, 기개발 기능 **개선**, 문제점(성능·보안) 발굴 — see below |
-| **Core builder + Tester + V&V** | `opus` | **xhigh** (or `max`) | **핵심 구현**(새 설계 표면·경계 판단이 남는 것) + **테스트 작성·실행**(E2E 포함) + **코드 리뷰·검증/V&V**(fresh instance). 기획/스펙 문서 *초안*은 Fable의 방향 브리프를 받아 작성 가능하되, 확정은 Fable 리뷰를 거친다. **리뷰의 분업**: 설계·기획·스펙 문서 리뷰 = Fable / 코드(diff) 리뷰 = Opus V&V |
-| **Repetitive builder + read-only assist** | `sonnet` | **high** (or above) | **반복·단순 구현** — 확립된 패턴의 적용, 설계 판단이 이미 끝난 기계적 구현 (산출물은 Opus 교차검증) + 리서치 스윕. **테스트·검증 투입 금지** |
-| **Orchestrator stand-in** (quota exhausted) | `opus` @ `max` | max | Takes over orchestration via a handoff — see "Orchestrator handoff" |
-
-The orchestrator assigns a thinking/effort level **per task** at delegation time. Delegating
-below a floor is a policy violation, not a tuning choice.
-
-## The orchestrator's own lane: direction, review, judgment
-
-The orchestrator authors **direction**, not documents. 서비스 방향성(where the product goes),
-스펙 리뷰(is this plan right?), 기능 개선(what should get better in what shipped?), and
-성능·보안 문제 발굴 stay in the orchestrator's window — that's where user intent, constraints,
-and history live, and judgment is the one thing a delegation prompt can't carry.
-
-Document *drafting* is delegated to Opus with a direction brief (intent, constraints, decided
-trade-offs). This buys an author≠reviewer split for documents themselves: **Opus writes, the
-orchestrator reviews** — a draft you review with fresh eyes gets scrutiny your own draft never
-would. For 기획/스펙문서 리뷰, run the [[multi-persona-review]] skill (3–5 disjoint persona
-reviewers, severity-ranked synthesis) instead of a single-pass read; the orchestrator arbitrates
-its findings rather than line-editing alone.
-
-## Routing test
-
-Before routing to any model: **deterministic transforms don't get a model at all.** A rename,
-a format sweep, a mechanical find-and-replace is `sed`/`grep`/script work — spending model
-tokens on what code answers deterministically fails the routing test at step zero.
-
-Past that gate (2026-08-02 사용자 결정):
-
-- **Core implementation, all tests, anything that judges code** — new design surface, boundary
-  decisions, test authoring and execution (E2E included), code verification/V&V — route to
-  **Opus @ xhigh+**.
-- **Repetitive/simple implementation** — applying an established pattern where the design
-  decisions are already made (N번째 유사 변환, 확정 스펙의 기계적 구현) — routes to
-  **Sonnet @ high+**, and its output gets Opus cross-verification before it gates anything.
-  The routing question is *"새 판단이 남아 있는가?"* — 남아 있으면 핵심(Opus), 없으면 반복(Sonnet).
-- **Read-only assists** (research sweeps) may also go to Sonnet; tests and verification never do.
-- **Judgment-free implementation whose pass condition is a command** — the repetitive lane above
-  stays the default; only when every predicate in the next section holds may that work go to an
-  external executor instead.
-- **Korean the user will read** · **shorter and better structured** — an external advisory
-  round-trip. Which provider takes which is `external-model-consult`'s provider table; that table
-  is the SSOT and is not copied here.
-- **A judgment that needs several perspectives** → [[multi-persona-review]] (native panel). **One
-  non-Claude perspective** → `external-model-consult` persona mode. A panel that mixes both asks
-  the user before it runs, and that gate belongs to [[multi-persona-review]].
-- 설계·기획·분배·리뷰 decisions never route down at all — they are the orchestrator's own
-  (see above).
-
-Parallelism rule of thumb (three independent sources converge on this): **parallel reads are
-safe, parallel writes are dangerous**. Fan out freely for research/search/review; keep writes
-sequential or isolated (worktree) so two workers never make conflicting implicit decisions in
-the same files.
-
-## External executors — the lane outside the harness
-
-This lane buys **capacity, not quality.** It is not a fourth rank below Sonnet — the ranking above
-is by judgment, and an outside CLI has not earned a place in it. What it can hold is work whose
-**quality a command decides**, the only case where "cheaper" doesn't also mean "worse." Choosing it
-because some other vendor is supposedly better inverts this policy's quality-over-cost premise.
-
-**All five predicates must hold; any one false closes the lane.** Each is a question you can answer
-right now, not a "use it if it helps."
-
-| # | Predicate | How you answer it now |
-|---|---|---|
-| **P1** | No judgment is left | The routing question above, unchanged — *"새 판단이 남아 있는가?"* 남아 있으면 닫힌다 |
-| **P2** | Passing is machine-decided | Write the pass command on one line, right now. Can't? Closed |
-| **P3** | The output gates nothing | It gates no merge, no release, no decision until in-harness cross-verification clears it |
-| **P4** | The repo may go to that provider | The first-use approval below is done, and this file set is inside what was approved |
-| **P5** | It is **not the CLI you are running on**, and it can use a shell | Delegating to yourself is not a round trip; with no shell, this lane doesn't exist for you |
-
-Even with all five true, **the in-harness repetitive lane is still the default.** Go outside when
-mechanical work is eating capacity a judgment lane needs — and reach for the fewest tools that
-answer the task, not every tool installed.
-
-**First use in a repository is the user's call, not yours.** Routing implementation to an external
-CLI puts this repository's code into another vendor's session — a disclosure none of the in-harness
-lanes make. Before the first such delegation in a project, say which tool, which provider its own
-config resolves to, which files the worker may touch, and what comes back; then wait. After that one
-approval, routing inside the predicates above is yours. Ask again when the boundary moves — a
-different tool, or files outside what was approved.
-
-**Tool missing, auth expired, provider refused → step down a lane and report what you could not
-use.** Never install it, never log in for them, and never quietly substitute a different provider:
-the user knows which tool answered, so a silent swap makes your report false. Recognizing each
-failure — and the exact wording for it — belongs to [[external-model-consult]]; where that skill
-isn't installed, only the conclusion survives: stop and ask.
-
-**This lane does not choose models.** The tool runs whatever its own config resolves to, and you
-report what answered. A model id written down here goes stale and pins the user to a retired model.
-
-**Call the tool's non-interactive mode from the shell.** Read the subcommand off `--help` rather
-than typing one from memory, and stop and report if it isn't there. Writes stay isolated (worktree
-or equivalent) — the parallel-write rule above holds for outside workers too.
-
-The delegation prompt spec and the file-handoff contract below apply here unchanged: an outside
-worker is still a worker.
-
-## Effort floors — and the inheritance gotcha
-
-Effort tiers: `low` < `medium` < `high` < `xhigh` < `max`. Fable 5, Sonnet 5, and Opus 4.8/4.7
-support all five; on models without `xhigh` the request silently falls back to the nearest
-lower level — check the model before assuming the floor holds.
-
-**The gotcha that breaks this policy silently:** the Agent/Task tool accepts a per-invocation
-`model`, but **not a per-invocation `effort`** — a spawned agent inherits the session effort
-unless its definition says otherwise. Session default is `high`, so a plain
-`Agent(model: "opus")` runs at `high`, **below the xhigh floor**, with no warning. Enforce the
-floor through one of these three paths:
-
-1. **Pre-defined agent roles** — `.claude/agents/<role>.md` frontmatter pins both knobs.
-   This is the durable path for recurring roles:
-
-   ```yaml
-   ---
-   name: verifier
-   description: Fresh-context V&V per model-orchestration policy
-   model: opus
-   effort: xhigh
-   ---
-   ```
-
-2. **Workflow scripts** — `agent(prompt, {model: "opus", effort: "xhigh"})` supports both
-   per call. Use for scripted fan-outs.
-
-3. **Session inheritance** — if the session already runs at `xhigh` (e.g. `/effort xhigh` or
-   ultracode), a bare `Agent(model: "opus")` inherits a compliant level. Verify with
-   `/effort`; don't assume.
-
-One environment caveat: `CLAUDE_CODE_SUBAGENT_MODEL` outranks every per-invocation and
-frontmatter model choice. If delegation models look wrong, check that env var first.
-
-## Delegation prompt spec
-
-[[objective-brief]] owns the delegation prompt format — write the brief there and hand it over.
-Without that skill installed, the five elements are: objective (and why it matters), output
-format, tool/source guidance, boundaries, acceptance criteria.
-
-Scale worker count to the task, stated up front in your own plan: trivial lookup → no agent at
-all (do it directly); bounded question → one agent; genuinely independent axes → one agent per
-axis. Over-spawning is a documented failure mode, and multi-agent runs cost ~15× a plain chat
-turn — delegate when the task's value justifies it, not by reflex.
-
-## Worker lifecycle — 다 쓴 에이전트는 닫는다
-
-Closing what you spawned is owned by the `git-policy` rule's Session Cleanup section — the
-sweep there uses an enumeration probe rather than memory, because compaction wipes the
-orchestrator's own ledger of open workers.
-
-### Collect results as a file, not as a return message
-
-A worker's final message is not durable transport — long results get truncated silently, and
-what was cut is gone. This burned three separate times — most
-recently a panel run that lost three reviewers' output — before it was codified as a gate.
-The contract: the worker writes its deliverable to a scratchpad/output **file whose path the
-orchestrator fixes in the spawn prompt** — collection is a spawn-time decision, because a
-truncated reply cannot be retrofit into a file after the fact. The final message then carries
-only the file path plus a short summary. Treat any delegation whose prompt names no output
-file as not yet dispatched.
-
-## V&V separation
-
-The implementer never verifies its own work — the *instance* that wrote something never judges
-it. How that plays out per lane:
-
-- **Sonnet implemented** (반복·단순 구현) → **Opus cross-verifies** — a different model has
-  different blind spots, which is the cheapest anchoring break available.
-- **Opus implemented** (핵심 구현·테스트) → a **fresh Opus instance** verifies: a NEW agent with no
-  shared history. A verifier that watched the implementation happen inherits the implementer's
-  mental model and anchors on it — same-session self-review reliably misses the same edge
-  cases the implementation missed. Instance separation is what makes "Opus builds AND Opus
-  verifies" coherent.
-- **Orchestrator layer on top**: the orchestrator hunts 성능·보안 문제점 in shipped features —
-  a second, higher-altitude pass that judges what a diff-level verifier doesn't (product fit,
-  systemic risk). Documents get the same split: Opus authors, the orchestrator reviews via
-  [[multi-persona-review]].
-
-This pairs with, not replaces, deterministic gates (tests, typecheck, CI) — the verifier
-judges what automation can't: spec fit, missed edge cases, design drift.
-
-## Orchestrator handoff (quota exhaustion)
-
-When the top-tier orchestrator's quota runs out mid-project, **Opus @ `max` takes over
-orchestration**. There is no reliable automatic path — documented fallback chains explicitly
-exclude rate-limit errors, and plan-level auto-switching is undocumented behavior you must not
-build on. Hand off manually:
-
-1. Run the [[compaction-handoff]] protocol: persist durable facts to memory, take an atomic
-   git snapshot (clean tree + open-PR check), emit the fixed-field resume anchor
-   (current state / verified / what's left / next action).
-2. The successor session starts on `opus` at `max` (`/model opus` + `/effort max`), reads the
-   anchor, and continues as orchestrator under this same policy — setting direction, reviewing,
-   and hunting problems itself (it can author documents directly too, since it already runs at
-   the Opus doc-author tier — no separate delegation needed while it stands in).
-3. When the top-tier model becomes available again, hand back the same way.
-
-## Anti-patterns
-
-| Anti-pattern | Why it's a violation |
-|---|---|
-| `Agent(model: "opus")` with session at default effort | Inherits `high` < xhigh floor — use a pinned agent role, Workflow opts, or raise session effort |
-| Delegating 방향성 수립 or a final judgment call to a worker | Direction is the orchestrator's own — a delegation prompt can't carry the shaping context |
-| Accepting an Opus-authored spec/plan without orchestrator review | Author≠reviewer applies to documents too — run [[multi-persona-review]] before accepting |
-| Orchestrator hand-writing full spec/plan drafts itself | Authoring is Opus's lane — brief the direction, delegate the draft, review the result |
-| Sonnet on tests, verification, or **core** implementation | Sonnet 의 레인은 반복·단순 구현(확립 패턴 적용)과 읽기 전용 보조까지다 — 테스트·V&V·새 설계 판단은 Opus/Fable 몫 |
-| Sonnet 반복 구현물이 Opus 교차검증 없이 머지를 게이트 | 교차검증이 Sonnet 레인의 존립 조건이다 — 검증 없는 반복 구현은 레인 위반과 같다 |
-| Effort below floor "to save tokens" | The floors ARE the policy; surface cost concerns to the user instead |
-| Implementer verifying its own diff | Anchoring — verification needs fresh context, prefer a different model |
-| Two agents writing the same files in parallel | Conflicting implicit decisions; keep writes sequential or worktree-isolated |
-| Spawning an agent for what one direct tool call answers | 15× token multiplier for zero value — do trivial work directly |
-| Relying on plan-level auto-fallback for continuity | Undocumented behavior; use the manual handoff protocol |
-| Finished worker left running after its result is consumed | Subagent panes/windows accumulate (iTerm2 등) and idle pings pollute the session — TaskStop as one motion with consuming the result |
-| 외부 실행기에 **테스트 작성·검증**·핵심 구현을 넘김 | 이 레인은 판단 잔여 0 인 일만 받는다 — 무엇을 단언할지 정하는 일을 밖으로 내보내면 외부 산출물을 검사할 기준 자체가 밖에 있게 된다. 형태가 이미 고정된 표에 케이스 한 줄을 복제하는 일은 무엇을 단언할지 정하지 않으므로 여기 해당하지 않는다 |
-| 도구가 없어서 조용히 다른 제공자로 갈아타 실행 | 사용자는 어느 도구가 답했는지 알고 있다 — 대체는 보고 대상이지 판단 대상이 아니다 |
-| 외부 실행기를 "품질이 더 낫다"는 이유로 고름 | 이 레인이 사는 것은 용량이다. 품질을 근거로 들면 이 정책의 quality-over-cost 전제를 뒤집는 것이다 |
-
-## Quick reference
-
-```
-방향성 수립 / 설계·기획 확정 / 작업 분배 / 스펙 리뷰(multi-persona-review) / 기능 개선 / 성능·보안 문제발굴
-                               → 오케스트레이터(Fable) 직접
-스펙 문서 초안(Fable 브리프 기반) / 핵심 구현 / 테스트 작성·실행(E2E 포함) / 코드 리뷰·검증(V&V)
-                               → opus  @ xhigh (또는 max)   — pinned role 또는 Workflow opts
-반복·단순 구현(확립 패턴 적용) / 리서치 스윕
-                               → sonnet @ high 이상 — 테스트·검증 투입 금지, 산출물은 Opus 교차검증
-결정적 변환 (rename·포맷)      → 모델 위임 금지 — sed/grep/스크립트 직접
-판단 잔여 0 + 합격을 명령 하나로 판정
-                               → sonnet 기본 / 다섯 술어 충족 시 외부 실행기 — 최초 1회 사용자 확인, 산출물은 in-harness 교차검증
-도구 부재·인증 만료            → 레인을 내리고 무엇을 못 썼는지 보고 — 대신 설치/로그인 금지, 조용한 제공자 교체 금지
-위임 완료                      → 결과 수거와 동시에 TaskStop (SendMessage 재사용 예정 시만 유지 선언)
-Fable 소진                     → compaction-handoff → opus @ max 가 오케스트레이터 대행
-```
+Apply intelligence where it most improves a verified, usable outcome. Optimize
+whole-task cost and delay, including context duplication, coordination,
+verification, and likely rework, while preserving required quality and authority.
+These are allocation principles, not a mandatory multi-agent workflow. Explicit
+project requirements remain binding.
+
+## 1. Keep ownership with useful context
+
+The agent holding the user's intent and relevant project context owns the
+integrated result. It may plan, draft, implement, run checks, and refine directly.
+Roles describe responsibilities; they do not require separate workers.
+
+Keep tightly coupled work together when a handoff would mostly make another
+agent reconstruct the same understanding. Completing the task in one capable
+context is a valid orchestration choice, not a failure to delegate.
+
+Treat model capability, reasoning effort, and context count as separate choices.
+Where supported, changing model or effort within an existing context may be more
+useful than spawning another agent. Reuse applicable routing decisions rather
+than reopening them for every tool call or phase.
+
+## 2. Put capability at the bottleneck
+
+Use stronger reasoning for unresolved design choices, difficult diagnosis,
+cross-boundary behavior, and consequential mistakes. Choose sufficient capability
+early when uncertainty or recovery cost warrants it; there is no need to exhaust
+weaker models first. A stronger model doing the work directly may cost less
+overall than a weaker implementation followed by repeated review and repair.
+
+For well-specified work, choose between direct execution, deterministic tools,
+and a lighter capable model by total completion cost. Running a known test command
+and deciding whether its coverage is adequate are different demands on judgment.
+Use tools for execution and measurement; allocate reasoning to decisions they
+cannot settle.
+
+Choose from actual capabilities and task evidence rather than fixed vendor-role
+assignments or universal effort floors. Honor explicit model, effort, budget,
+and data-processing constraints. Adapt when capabilities or evidence change.
+
+## 3. Make additional contexts earn their cost
+
+Add a worker for a concrete benefit: needed expertise or tools, useful context or
+permission isolation, independent scrutiny, or genuinely parallel work that
+shortens the critical path after startup and integration costs. Compare this
+with direct or batched tool use and continuing an existing worker.
+
+Choose coherent, independently ownable units. Bundle related work that shares
+context and acceptance criteria instead of splitting by file, phase, or role.
+Independence makes parallel work possible; its expected contribution makes it
+worthwhile. Each additional worker should provide a distinct useful result.
+
+Parallel changes need clear interfaces and non-overlapping ownership or suitable
+isolation, including shared test resources and integration assumptions. Use the
+main context for complementary work rather than repeating a delegated task.
+Apply the same benefit test to nested delegation and account for its total cost.
+
+Several perspectives can be considered in one context. Separate them when
+independent scrutiny, different evidence, or specialized capability adds value,
+not merely to fill a persona panel. Simulated perspectives are not independent
+review or observed user feedback.
+
+## 4. Transfer sufficient context, not entire histories
+
+Reuse valid findings and existing worker contexts for related follow-up when
+supported. Start fresh when independence, context overload, or a changed purpose
+makes reuse counterproductive.
+
+Give a worker the objective, essential constraints, relevant artifact and evidence
+references, unresolved question, allowed changes, and completion criteria. Supply
+enough context to decide correctly, including material failed approaches; favor
+accessible source references over replaying the conversation. Keep critical
+constraints explicit rather than relying on a lossy summary or hidden context.
+
+Ask for the result needed for integration, its evidence, and remaining gaps.
+Short results can return directly. Use durable files or artifacts for large,
+reusable, or truncation-prone output, agreeing on the destination before it is
+produced. Preserve relevant version information so evidence stays attributable.
+
+## 5. Review consequential uncertainty, not every stage
+
+Implementers should execute relevant checks and correct their work. This is
+verification, but not independent review. Add independent review when a fresh
+perspective materially improves assurance or when explicitly required.
+
+Give the reviewer the original objective, constraints, actual artifacts, and
+execution evidence, with sufficient capability to assess the material risks.
+Focus independent assessment on consequential assumptions and blind spots rather
+than replaying the author's reasoning or assigning a reviewer to each artifact.
+Neither model prestige nor agreement among agents substitutes for evidence.
+
+Own acceptance and integration: inspect the artifacts and evidence material to
+the outcome, resolve substantiated gaps, and check affected integration behavior.
+Reuse applicable execution and review evidence across stages; revisit areas when
+changes or new information invalidate it. Finish when required readiness is
+supported, rather than commissioning another pass without a likely benefit.
+
+## 6. Preserve authority and continuity
+
+Resolve model availability, effort controls, inheritance, and tool behavior from
+the actual environment or applicable documentation when needed; reuse current
+evidence. Distinguish requested settings from observed execution. Do not claim
+a model, effort level, or independent review that was not established.
+
+Apply the same scope, data protections, and approval boundaries to every worker,
+whether native or external. Confirm that the actual provider, disclosed data,
+and permitted actions are covered by existing authorization before routing.
+Obtain approval when that boundary changes; an installed tool is not permission
+to disclose repository content or apply changes to shared systems.
+
+When a capability is unavailable, continue through an authorized alternative
+that still meets required quality, reporting material substitutions or limits.
+If a required gate cannot be satisfied, pause only dependent actions.
+
+For interruptions or ownership changes, preserve the current state, artifact
+locations, verified evidence, unresolved issues, and next action. Resume useful
+contexts when supported. Collect results and release workers that no longer have
+useful pending work, preserving required evidence and existing user work.

package/templates/skills/objective-brief/SKILL.md

@@ -131,7 +131,7 @@ One shape means a worker never has to infer where the boundaries are stated, and
 delegation missing a field is visibly missing it.
 
 Where the `model-orchestration` skill is installed, its delegation-prompt spec is the routing-side
-authority (which model, which effort floor, who verifies). This template **carries** that spec
+authority (which model and effort, whether another context earns its cost, who verifies). This template **carries** that spec
 rather than competing with it — the mapping is one-to-one:
 
 | Delegation element | Brief field |
@@ -148,8 +148,8 @@ Two of those rows are the ones people drop, so state them explicitly:
 
 - **Resource limit is where model and effort live.** "One agent, opus, effort floor xhigh, no
   further fan-out" belongs here as a hard cap, not as an aside in prose. A cap that is not in the
-  brief is not a cap. Where `model-orchestration` is installed, take the floors from it; where it
-  is not, still name the model and effort you intend, because a worker that inherits an unstated
+  brief is not a cap. Where `model-orchestration` is installed, take the model and effort choice
+  from its allocation principles; where it is not, still name the model and effort you intend, because a worker that inherits an unstated
   level runs at whatever the session happened to be set to.
 - **리뷰어 위임형 is the lane split, written down.** Choosing it tells the worker that a different
   lane writes the tests and issues the verdict, so it must not spend the run self-certifying —