# Grill Discipline — apt:discuss posture loader

This appendix loads into `apt:discuss`'s reasoning context whenever the
skill is invoked in decision-lock posture (or as a sub-step inside
`apt:improve` / `apt:triage`'s grill loop). It carries two load-bearing
artifacts:

1. The 100-token **reframe sentence** validated by the V2 grill-comparison
   experiment (43/44 vs 38/44 blind-judge score against the verbatim
   `grill-with-docs`).
2. The **autonomy-aware degradation table** that prevents full-auto runs
   from grinding to a halt grilling every gray area.

## The reframe sentence (validated, 43/44 vs 38/44)

> **Your job is not to emit a plan; your job is to resolve the design
> tree until planning is mechanical.**

This sentence is the *first thing* you load into your reasoning context
when entering decision-lock posture. It does two things at once:

- It refuses the "I'll just emit a plan and let the executor figure
  out the gaps" anti-pattern. Plans with unresolved gray areas push the
  cost into execution where rollbacks are 10× more expensive.
- It frames the goal as *resolving a design tree*, not *answering a
  questionnaire*. The interview-style "ask the user 47 clarifying
  questions" is the failure mode this reframe blocks.

The empirical V1 + V2 evidence is in
`.aperant/experiments/grill-comparison-20260513/SUMMARY-FOR-AGENT-REVIEW.md`.

## Autonomy-aware degradation table (load-bearing)

The grill discipline runs at every autonomy level — the *interaction
shape* degrades, not the discipline itself. This is the canonical
source for this rule; new skills (apt:improve, apt:triage) reference
THIS table rather than re-stating the policy.

| Autonomy | Mode | Behavior |
|---|---|---|
| **1 (Supervised)** | Grill everything | Ask the user for every load-bearing decision. The user reviews each Q&A turn before the next one fires. |
| **2 (Balanced / Semi)** | Batch-recommend | Auto-recommend per decision; collect all recommendations into a single batch the user reviews at the end. This is the existing `--review-auto` pattern. |
| **3 (Full auto / YOLO)** | Auto-lock with escalation triggers | Auto-recommend and lock decisions silently. Escalate to the user only when one of THREE triggers fires (below). |

## The three escalation triggers (Autonomy 3 only)

At Autonomy 3, the agent locks recommendations silently — **EXCEPT** when:

1. **Conflict with a prior locked decision.** The new recommendation
   contradicts a decision already written to
   `.aperant/context/notes/{task-id}.md` (or any other notes file under
   `.aperant/context/notes/`). Re-litigating a locked decision needs
   human sign-off.
2. **Critical-path file touched.** The decision's downstream effect
   modifies a file matching a glob in
   `.aperant/config.json.risk_map.critical_paths` (e.g., auth, billing,
   migration paths). Critical-path changes always escalate at every
   autonomy level — this trigger is the autonomy-3 surface for the same
   policy.
3. **No defensible default exists.** Neither AGENTS.md nor an existing
   codebase pattern provides a defensible answer. "Just pick one" is
   not a defensible default; the agent must say "I see two viable
   paths and no precedent — which do you want?"

These three triggers cover the cases where a silent auto-lock would
cause real harm. Everything else gets locked, logged, and surfaced in
the final report only — not as a blocking prompt.

## Practical consequence for new skills

When `apt:improve`'s deepening loop, `apt:triage`'s priority resolution,
or any other agent reaches a gray area:

- It loads THIS appendix into reasoning context.
- It reads the current autonomy from `.aperant/config.json` (or the
  per-task autonomy from `apt-tools task get`).
- It enters the matching row of the degradation table.
- At Autonomy 3, it walks the three triggers before deciding to lock or
  escalate.

The "ask first vs lock first" decision is NOT a per-skill policy.
Reasoning lives here; every grill-loop-bearing skill references it.

## When NOT to load this appendix

This appendix is for **decision-lock** posture (convergent discussion
where the user has a concrete task with implicit gray areas). The
**brainstorm** posture (divergent — user has a rough vision, exploring
options) does NOT load this appendix; brainstorm has its own posture
encoded in apt:discuss's `<objective>` block.

`apt:zoom-out` (a sibling skill, also adopted) does NOT load
this appendix. Zoom-out is descriptive ("show me the broader picture"),
not normative ("lock this decision"). Loading grill-discipline there
would mis-fire the reframe sentence on a read-only operation.
