create-issflow 1.2.0 → 1.4.0

package/template/.claude/commands/sprint.md

@@ -0,0 +1,233 @@
+---
+description: The Scrum sprint layer — group PLAN phases into time-/scope-boxed sprints and run the full ceremony set (planning → standups → review/demo → retrospective → close) with burndown + velocity. AUTO-facilitated: the orchestrator runs every ceremony itself and drives the sprint end-to-end without stopping, pausing only at the real hard-stops. The layer between PLAN (backlog) and PHASE (build loop).
+argument-hint: [run|plan|standup|review|retro|close|status] [sprint number]
+---
+
+Caveman ULTRA mode. You are the ORCHESTRATOR / SCRUM MASTER. You FACILITATE the
+ceremonies and ROUTE build work to subagents — you do NOT implement or debug yourself.
+
+Subcommand: $ARGUMENTS  (default: `status`)
+
+Hierarchy: **PLAN (product backlog) → SPRINT (committed slice of phases) → PHASE
+(the build loop)**. A sprint groups consecutive PLAN phases behind ONE sprint goal
+and ships ONE deployable increment. Phases still run via `/phase` exactly as before
+— the sprint layer wraps them with planning, standups, a review, and a retro.
+
+**AUTONOMY (read first).** Sprint planning only SLICES the already-approved
+`docs/PLAN.md` — the requirements gate already happened at `/overview` plan approval —
+so the ceremonies are AUTO-safe and the orchestrator runs them WITHOUT stopping.
+- **AUTO (default):** `/sprint run` drives the whole sprint hands-off — plan → loop
+  `/phase` → standup tick after each phase → review → retro → close → roll forward →
+  start the next sprint. Decisions (points, scope-fit, accept/carry) are made from the
+  PLAN + velocity, logged, and the run continues. Pause ONLY for a methodology
+  hard-stop (deploy/irreversible/outbound, security-sensitive change, contradictory
+  spec, or debug budget spent with no independent slice left).
+- **GUIDED:** each ceremony presents its result and waits for you before the next.
+The PLAN-approval, commercial (`/propose`, `/change-request`), and release
+(`/release`, `/uat`, prod promote) gates are SEPARATE and stay interactive in both
+modes — the sprint layer never auto-passes them.
+
+Artifacts: `docs/sprints/sprint-<n>.md` (one per sprint — goal, committed phases,
+burndown, standups, review, retro) and `docs/sprints/VELOCITY.md` (the rolling
+velocity table). Create `docs/sprints/` if absent. STATE.md carries the active sprint.
+
+=====================================================================
+## ROUTER
+
+- `run`     → §RUN  (AUTO end-to-end driver — the default way to use this)
+- `plan`    → §1 PLANNING
+- `standup` → §2 STANDUP
+- `review`  → §3 REVIEW
+- `retro`   → §4 RETRO
+- `close`   → §5 CLOSE
+- `status`  → §STATUS  (default when no subcommand)
+
+=====================================================================
+## §1 — SPRINT PLANNING  (ceremony)
+
+Pre: `docs/PLAN.md` exists AND its `> Approval:` header reads `approved …` (the
+PLAN-APPROVAL gate, hard rule 13). Still `PENDING` / missing → STOP, route to the
+`/overview` plan-approval gate. A sprint only SLICES an already-signed-off plan.
+
+a. **Estimate (one-time, lazy).** Every pending PLAN phase needs a points estimate
+   (Fibonacci `1 2 3 5 8`, relative effort from the phase `slice` + `acceptance`
+   size; a phase that feels `>8` is too big — note it for `/replan` to split). If the
+   planner already wrote `[N pts]` tags, reuse them; otherwise assign now and write
+   them back into PLAN.md next to each phase header.
+
+b. **Capacity.** Read `docs/sprints/VELOCITY.md`.
+   - Have history → capacity = rolling-average completed velocity (last ≤3 sprints).
+   - First sprint (no history) → capacity = `flow-config.json` `sprint.defaultCapacity`
+     (fallback 8 pts).
+
+c. **Commit.** Walk the PLAN in dependency order, pull pending phases into this sprint
+   until the next phase would exceed capacity. Don't split a phase across a sprint
+   boundary; respect dependencies (never commit a phase whose dependency is in a later
+   sprint). Keep one coherent theme → that becomes the **sprint goal** (one line: the
+   user-visible increment this sprint ships). Optionally mark 1 phase `stretch`.
+
+d. **Write** `docs/sprints/sprint-<n>.md` from the template below; set
+   `status: active`; seed the burndown tick 0 = total committed points. Group the
+   committed phases under a `## Sprint <n>` header in PLAN.md if not already grouped.
+   Update STATE.md: `sprint: <n> (active)`.
+
+AUTO: auto-commit the computed backlog, log the goal + points + capacity, continue.
+GUIDED: present goal + committed phases + points, wait for confirm.
+
+=====================================================================
+## §2 — STANDUP  (auto-tick — fires once per phase close inside an active sprint)
+
+The AI dev loop has no calendar days, so the "daily" standup is rebound to a
+**per-phase-close tick** — the natural cadence of progress. After each `/phase` CLOSE
+while a sprint is active (the `/phase` command fires this; `/sprint run` fires it
+inline; or run `/sprint standup` by hand):
+
+1. Append a standup line to the active sprint doc:
+   `- tick <k> (Phase <p> <done|blocked>): done <what>; next <phase/none>; blockers <none|ref>`
+2. Update the **burndown**: append a row `tick <k> | Phase <p> <state> | <remaining pts>`
+   where remaining = committed points minus points of phases now `done`. Re-render the
+   ASCII sparkline.
+3. Surface blockers immediately if any (a blocked phase is the standup's whole point).
+   AUTO: the blocker is already parked per the circuit breaker — just record it here
+   and keep the burndown honest. GUIDED: relay it.
+
+Keep it ONE line per tick. No prose. The burndown is the signal.
+
+=====================================================================
+## §3 — SPRINT REVIEW / DEMO  (ceremony — at sprint boundary)
+
+Run when every committed phase is `done` or `blocked` (sprint timebox reached).
+
+a. **Demo.** Summarise the shipped increment: for each accepted phase, the
+   user-visible behaviour now working (pull from the phase `slice` + `docs/ENDPOINTS.md`).
+   This is the "done = demoable" check — a phase that can't be demoed isn't done.
+
+b. **Boundary audits.** Run the whole-product audits ONCE for the increment (cheaper
+   here than per-phase, broader than the inline gates):
+   `/ui-audit` (if UI shipped) · `/qa-audit` · `/security-audit`. Fold the scores in.
+   Open BLOCKER/HIGH/CRITICAL → route to FIX (`debugger`/`implementer`), re-audit.
+   (Security findings remain an autonomy hard-stop.)
+
+c. **Accept / carry.** Mark each phase `accepted` (demoed + audits clean) or
+   `carried` (not done / failed audit → rolls to the next sprint at §5).
+
+d. Write the `## Review` block into the sprint doc (demo bullets, audit scores,
+   accepted vs carried).
+
+=====================================================================
+## §4 — RETROSPECTIVE  (ceremony — after review)
+
+Inspect-and-adapt on the PROCESS, not the product. Write the `## Retro` block:
+
+- **went well** — what to keep (2–4 bullets).
+- **didn't** — friction, repeated debugging, churned tests, estimate misses.
+- **actions** — each a CONCRETE, routed change, not a wish. Route every action to a
+  durable home so it actually happens:
+  - a recurring bug/root-cause pattern → it's already in `docs/ISSUES.md`; note the ref.
+  - a workflow/structure change → `/log-decision` (`docs/DESIGN_LOG.md`).
+  - an ops/incident lesson → `/runbook`.
+  - a plan correction (re-estimate, split, reorder) → `/replan`.
+  - a durable, cross-project lesson → flag for `/store-wisdom`.
+- **estimate accuracy** — committed vs completed points; note phases that blew their
+  estimate so the next sprint's poker is calibrated.
+
+AUTO: auto-apply the routed actions (log/replan) and continue. GUIDED: list actions,
+confirm before applying.
+
+=====================================================================
+## §5 — SPRINT CLOSE
+
+a. **Velocity.** completed = sum of `accepted` phase points. Append a row to
+   `docs/sprints/VELOCITY.md`:
+   `| <n> | <committed> | <completed> | <goal met? yes/no> |` and recompute the rolling
+   average (last ≤3 sprints).
+b. **Carry forward.** Each `carried`/`blocked` phase stays pending in PLAN.md — the
+   next `/sprint plan` re-commits it first (carried work has priority). Don't lose it.
+c. Set the sprint doc `status: done`; stamp the close date. HISTORY line:
+   `sprint <n> closed — <completed>/<committed> pts, goal <met|missed> (<date>)`.
+d. Update STATE.md: clear the active sprint (or set the next one if `/sprint run`
+   continues).
+
+=====================================================================
+## §RUN — AUTO END-TO-END DRIVER  (the headline: "do all the process automatically")
+
+`/sprint run [n]` drives one full sprint — or, if you keep going, every remaining
+sprint until the PLAN is exhausted — with NO human stop except a hard-stop:
+
+```
+loop while pending phases remain in PLAN.md:
+  1. §1 PLANNING            → commit the next sprint from PLAN + velocity
+  2. for each committed phase, in dependency order:
+       run /phase <p>       → the full build loop (its own gates + circuit breaker)
+       §2 STANDUP tick      → append standup + update burndown
+       phase BLOCKED (circuit breaker parked it) → record, keep going to the next
+         INDEPENDENT phase; if none remain, end the sprint early (timebox)
+  3. §3 REVIEW              → demo + boundary audits (fix blockers, re-audit)
+  4. §4 RETRO               → routed actions, applied
+  5. §5 CLOSE              → velocity + carry-forward + HISTORY
+  6. /synthesize → suggest /clear  (token reset at the sprint boundary, like a phase)
+  AUTO: start the next sprint automatically.  GUIDED: stop, report, wait.
+HARD-STOP at any point: deploy/irreversible/outbound action, security-sensitive
+change, contradictory spec, or debug budget spent with no independent slice left →
+pause, surface the consolidated report, hand to the human.
+```
+
+When the last PLAN phase is `accepted`, the build is sprint-complete → recommend
+`/release` (the pre-production pipeline) as the next step. Do NOT auto-promote to prod
+— that is a separate, human-signed hard-stop.
+
+=====================================================================
+## §STATUS
+
+Read STATE.md + the active `docs/sprints/sprint-<n>.md` + VELOCITY.md and print:
+sprint number + goal, status, the burndown sparkline, committed vs done points,
+the current/next phase, any open blockers, and rolling velocity. One screen. No edits.
+
+=====================================================================
+## SPRINT DOC TEMPLATE  (`docs/sprints/sprint-<n>.md`)
+
+```
+# Sprint <n> — <short name>
+goal: <one line — the user-visible increment this sprint ships>
+status: active            # planning | active | review | done
+capacity: <cap> pts  (basis: velocity avg | default)
+
+## Committed
+- Phase <p>: <name>  [<pts> pts]  [status: pending|done|blocked|accepted|carried]
+- ...
+## Stretch
+- Phase <q>: <name>  [<pts> pts]   # optional, pulled in only if capacity frees up
+
+## Burndown
+tick | event                  | remaining pts
+0    | sprint start           | <total>
+1    | Phase <p> done         | <rem>
+...
+<ascii sparkline of remaining pts, e.g.  8 ▆▅▃▂ 0>
+
+## Standups
+- tick 1 (Phase <p> done): done <what>; next Phase <q>; blockers none
+- ...
+
+## Review (<date>)
+- demo: <increment shipped — user-visible behaviour now working>
+- audits: ui <score|n/a> · qa <score> · security <score> · code <clean|issues>
+- accepted: <phases>   carried: <phases or —>
+
+## Retro (<date>)
+- went well: ...
+- didn't: ...
+- actions: <each routed → ISSUES | DESIGN_LOG | RUNBOOK | replan | store-wisdom>
+- estimates: committed <c> pts / completed <d> pts — <misses noted>
+```
+
+## VELOCITY TEMPLATE  (`docs/sprints/VELOCITY.md`)
+
+```
+# Velocity
+| sprint | committed | completed | goal met? |
+|--------|-----------|-----------|-----------|
+| 1      | <c>       | <d>       | yes/no    |
+
+rolling avg (last ≤3): <v> pts/sprint
+```

package/template/.claude/commands/uat.md

@@ -0,0 +1,36 @@
+---
+description: Manual UAT cycle — generate an all-case test-scenario document for human testers, hand it off, capture their pasted results, and drive the defect loop until every scenario passes. Used inside /release; the human-in-the-loop acceptance gate.
+argument-hint: [optional: feature scope, or "failed" to re-issue only failures]
+---
+
+Caveman ULTRA mode. You are the ORCHESTRATOR.
+
+UAT is a HUMAN gate: real testers run the product and report results. Your job is to
+make that easy — produce a clear scenario sheet, capture results, and loop on defects.
+
+## STEP 1 — BUILD SCENARIOS
+From `docs/OVERVIEW.md` (flows) + `docs/PLAN.md` (acceptance) + `docs/ENDPOINTS.md`,
+write `docs/UAT-<date>.md` covering ALL cases a tester should run:
+```
+## UAT — <project>   (<date>, build <ref>)
+| # | scenario | preconditions | steps | expected | Result (PASS/FAIL) | Notes |
+|---|----------|---------------|-------|----------|--------------------|-------|
+| 1 | …        | …             | …     | …        |                    |       |
+```
+Cover: every happy path, every acceptance criterion, edge / negative cases, each user
+role, and each critical flow. Group by feature, number them, leave Result + Notes
+blank for the tester. Keep steps concrete enough to follow without you.
+
+## STEP 2 — HAND OFF
+Show me the scenario sheet, ready to run. Tell me to execute it (or pass it to QA /
+the client), then **paste the results back** here. WAIT — do not assume results.
+
+## STEP 3 — CAPTURE RESULTS
+Take the pasted results, fill PASS/FAIL + notes into `docs/UAT-<date>.md`, and
+summarise: **X / Y passed**, list the failures with their scenario IDs.
+
+## STEP 4 — DEFECT LOOP
+For each FAIL: log to `docs/ISSUES.md` (repro = the scenario steps), fix
+(`implementer` / `debugger`, debug cap 3), re-run the automated tests for that area,
+then re-issue **only the failed scenarios** to me for re-test. Loop until 100% PASS.
+On all-green, hand back to `/release` for sign-off.

package/template/.claude/hooks/context-guard.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+'use strict';
+// PreToolUse context watchdog (iStartSoftFlow). Two tiers, one hook:
+//   warnPct  -> non-blocking nudge (additionalContext) once per climb into the band
+//   gatePct  -> HARD block of NEW build work (Edit/Write-to-source/feature Task)
+// Reads REAL token usage from the transcript. Fail-OPEN: any error -> allow,
+// never wedge the tool loop on a hook bug.
+const path = require('path');
+const fs = require('fs');
+
+const silent = () => process.exit(0);
+const out = (obj) => { process.stdout.write(JSON.stringify(obj)); process.exit(0); };
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (d) => (input += d));
+process.stdin.on('end', () => {
+  let evt;
+  try { evt = JSON.parse(input); } catch (_) { return silent(); }
+  try { run(evt); } catch (_) { silent(); }
+});
+
+function run(evt) {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || evt.cwd || '.';
+  let ctx;
+  try { ctx = require(path.join(projectDir, '.claude/hooks/lib/ctx.js')); } catch (_) { return silent(); }
+  const cfg = ctx.loadConfig(projectDir);
+  const warn = cfg.warnPct || 60;
+  const gate = cfg.gatePct || 78;
+
+  const u = ctx.contextUsage(evt.transcript_path, cfg);
+  if (!u) return silent();
+
+  const tool = evt.tool_name || '';
+  const ti = evt.tool_input || {};
+  const band = u.pct >= gate ? 'gate' : u.pct >= warn ? 'warn' : 'ok';
+  const BLOCKABLE = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'Task']);
+
+  // HARD GATE — block new build mutations; reason is fed to the model.
+  if (band === 'gate' && BLOCKABLE.has(tool) && !isEscape(tool, ti)) {
+    return out({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: gateReason(u, gate),
+      },
+    });
+  }
+
+  // NON-BLOCKING WARN — emit once each time we climb into a higher band.
+  const bandFile = path.join(projectDir, 'docs/.snapshots/.ctx-band');
+  const rank = (b) => (b === 'gate' ? 2 : b === 'warn' ? 1 : 0);
+  let prev = 'ok';
+  try { prev = (fs.readFileSync(bandFile, 'utf8').trim() || 'ok'); } catch (_) {}
+
+  if (rank(band) !== rank(prev)) {
+    try { fs.mkdirSync(path.dirname(bandFile), { recursive: true }); fs.writeFileSync(bandFile, band); } catch (_) {}
+  }
+  if (rank(band) > rank(prev) && band !== 'ok') {
+    return out({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: band === 'gate' ? gateReason(u, gate) : warnReason(u, warn, gate),
+      },
+    });
+  }
+  return silent();
+}
+
+// Checkpoint/logging writes + the synthesizer ritual are never blocked, so the
+// model always has an escape path out of the gate.
+function isEscape(tool, ti) {
+  if (tool === 'Edit' || tool === 'Write' || tool === 'MultiEdit' || tool === 'NotebookEdit') {
+    const fp = ti.file_path || ti.path || ti.notebook_path || '';
+    return /(^|\/)docs\//.test(fp) || /STATE\.md|ISSUES\.md|\.snapshots\//.test(fp);
+  }
+  if (tool === 'Task') return (ti.subagent_type || '').toLowerCase() === 'synthesizer';
+  return false;
+}
+
+const fmt = (n) => (n >= 1000 ? Math.round(n / 1000) + 'k' : String(n));
+
+function gateReason(u, gate) {
+  return [
+    `⛔ CONTEXT GATE — ${u.pct}% (${fmt(u.tokens)}/${fmt(u.window)} tok), เกิน ${gate}% = หยุดเปิดงาน build ใหม่.`,
+    'ทำก่อนไปต่อ:',
+    '  1) ปิด/commit งานค้างให้จบ (Bash/git ไม่ถูก block)',
+    '  2) /synthesize  (อัด handoff docs — subagent นี้ไม่ถูก block)',
+    '  3) /clear       (session ใหม่ บางลง)',
+    'build ต่อหลัง clear. กลาง irreversible op? ใช้ Bash ปิดให้จบก่อน clear.',
+    'ปลดล็อกชั่วคราว: เพิ่ม gatePct ใน .claude/flow-config.json.',
+  ].join('\n');
+}
+
+function warnReason(u, warn, gate) {
+  return [
+    `⚠️ CONTEXT ${u.pct}% (${fmt(u.tokens)}/${fmt(u.window)} tok) — แตะ warn band ${warn}%.`,
+    `วางแผนปิด phase: ทยอย /synthesize → /clear ก่อนถึง gate ${gate}% (เลยจุดนั้น hook block งาน build ใหม่).`,
+    'Delegate งาน noisy ให้ subagent เพื่อกัน context โต.',
+  ].join('\n');
+}

package/template/.claude/hooks/lib/ctx.js

@@ -0,0 +1,82 @@
+'use strict';
+// Shared context-budget math for iStartSoftFlow watchdog hooks.
+// Reads the live Claude Code transcript (JSONL) and reports how full the
+// model's context window currently is — from the REAL token usage the API
+// reported, not a heuristic. Pure Node, cross-platform.
+const fs = require('fs');
+
+// Known context windows by model-id substring. First match wins. The 1M
+// Opus/Sonnet variants advertise "[1m]" in the model id.
+const WINDOWS = [
+  [/\[1m\]|-1m\b|:1m\b|1m-/i, 1000000],
+  [/opus|sonnet|haiku|claude/i, 200000],
+];
+
+function inferWindow(model) {
+  if (!model) return 200000;
+  for (const [re, w] of WINDOWS) if (re.test(model)) return w;
+  return 200000;
+}
+
+// Read project flow config; returns the `context` block or {}.
+function loadConfig(projectDir) {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(projectDir + '/.claude/flow-config.json', 'utf8'));
+    return (cfg && cfg.context) || {};
+  } catch (_) { return {}; }
+}
+
+// Read only the last `bytes` of a file (the recent assistant turns live at the
+// tail of the JSONL — no need to load a multi-MB transcript on every tool).
+function readTail(p, bytes) {
+  const fd = fs.openSync(p, 'r');
+  try {
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - bytes);
+    const len = size - start;
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    return { text: buf.toString('utf8'), partial: start > 0 };
+  } finally { fs.closeSync(fd); }
+}
+
+// Scan lines (newest first) for the most recent assistant usage block.
+// input_tokens + cache_read + cache_creation == the full prompt size actually
+// sent == current context occupancy.
+function scanUsage(text, dropFirst) {
+  const lines = text.split('\n');
+  const lo = dropFirst ? 1 : 0; // first line may be a truncated tail fragment
+  for (let i = lines.length - 1; i >= lo; i--) {
+    const ln = lines[i].trim();
+    if (!ln) continue;
+    let obj;
+    try { obj = JSON.parse(ln); } catch (_) { continue; }
+    const m = obj && obj.message;
+    if (m && m.role === 'assistant' && m.usage && typeof m.usage.input_tokens === 'number') {
+      return { usage: m.usage, model: m.model || obj.model || null };
+    }
+  }
+  return null;
+}
+
+function contextUsage(transcriptPath, cfg) {
+  if (!transcriptPath) return null;
+  let hit;
+  try {
+    const tail = readTail(transcriptPath, 512 * 1024);
+    hit = scanUsage(tail.text, tail.partial);
+    if (!hit && tail.partial) {
+      // usage not in the tail window — fall back to a full read (rare).
+      hit = scanUsage(fs.readFileSync(transcriptPath, 'utf8'), false);
+    }
+  } catch (_) { return null; }
+  if (!hit) return null;
+  const u = hit.usage;
+  const tokens = (u.input_tokens || 0)
+    + (u.cache_read_input_tokens || 0)
+    + (u.cache_creation_input_tokens || 0);
+  const window = (cfg && cfg.window) ? cfg.window : inferWindow(hit.model);
+  return { tokens, window, model: hit.model, pct: Math.round((tokens / window) * 100) };
+}
+
+module.exports = { contextUsage, inferWindow, loadConfig, readTail, scanUsage };

package/template/.claude/hooks/session-start.js

@@ -39,6 +39,21 @@ if (state !== null) {
   emit('');
 }
 
+// 2b. active sprint (sprint layer) — surface goal + burndown if one is active
+const sprintMatch = (state || '').match(/^\s*sprint:\s*(\d+)\s*\(active\)/m);
+if (sprintMatch) {
+  const sf = read(`docs/sprints/sprint-${sprintMatch[1]}.md`);
+  if (sf !== null) {
+    emit(`## Sprint ${sprintMatch[1]} (active)`);
+    const goal = (sf.match(/goal:\s*(.+)/i) || [])[1];
+    if (goal) emit('goal: ' + goal.trim());
+    const burn = sf.split('\n').find((l) => /burndown|remaining|pts? left|[▁▂▃▄▅▆▇█]/i.test(l));
+    if (burn) emit('burndown: ' + burn.trim());
+    emit(`see docs/sprints/sprint-${sprintMatch[1]}.md for the full sprint.`);
+    emit('');
+  }
+}
+
 // 3. issue log — inject only OPEN issues (resolved ones stay in the file for
 //    grep, but are NOT re-paid in tokens every session). Capped.
 const issues = read('docs/ISSUES.md');
@@ -120,6 +135,8 @@ emit('- AUTO mode (default) governs the DEV loop: follow the plan — decide + l
 emit('  continue, do NOT stop to ask. (Planning / grill still asks — that part is fine.)');
 emit('  Hard-stops only: security / irreversible-or-outbound actions / contradictory spec.');
 emit('- caveman ULTRA mode is active.');
+emit('- PLAN-APPROVAL gate (rule 13): no /phase or /sprint while STATE `plan:` reads');
+emit('  PENDING — the plan needs a human sign-off via /overview first.');
 emit('- before debugging ANY error: grep ISSUES.md AND research/INDEX.md first.');
 emit('- debug attempts: WARN at 2; cap 3. AUTO: log + park the slice + continue (batched');
 emit('  report at the phase boundary). GUIDED: stop and ask you.');