Focus

---
name: focus
position: none
description: 'Show the tracked issues worth attention right now — read the issue host, apply one of three fixed modes (today = open work you could pick up now; review = open work already in flight; recent = issues closed inside the last 7 days), and present a deterministic, capped list of at most 10 entries, each carrying its issue number, title, a plain-language reason built from the signals that selected it, what kind of issue it is (defect / epic / refactor / feature / docs / chore / unlabelled), and — only where the table names one — which garura play to run for it. The issue host is the single source: no backlog, sprint plan, product model or work queue is consulted or created — this is the issue-side counterpart to /next, which reads the product model and is forbidden from reading issues. The mode is a named argument with today as the default; an unrecognised mode halts rather than being guessed. Kind and recommendation are fixed table lookups over the issue''s own labels, held in an editable kind map beside the play; the cardinal rule is that silence beats a wrong answer, so a kind the table has no play for, and any unlabelled issue, carry NO recommendation at all — no default, no generic pointer, no substitute — and the play reports how many entries it could not recommend for; /focus never derives a recommendation from the product model, which is /next''s job. Selection, ordering, kind and recommendation are fully deterministic (scripts, never inference), so the same issue set and mode always give the same list. Read-only and position none: it never creates, edits, closes, comments on, labels or assigns an issue, and runs on any branch at any point in the pipeline. Use when the user asks "what should I focus on today", "what is open", "what is in flight", "what got done recently", or wants the long issue list cut down to a workable few.'
user-invokable: true
---

# focus

Read the tracked issue host, cut its long list down to a workable few using one of
three fixed modes, and present them — each entry with its number, its title, and a
plain-language reason for why it is showing, what kind of issue it is, and — where the
kind map names one — the play to run for it. Where it names none, the entry says so and
stops. Silence beats a wrong answer.

`/focus` is the issue-side counterpart to `/next`. `/next` reads the product model
and its own C1 forbids it from reading any issue store. `/focus` reads issues and
never touches the model. Neither play duplicates the other.

## Compiled From

This play was compiled from the focus ICE (`reference/ice.md`) by play-creator.
Intent defines constraints (C1–C12) and failure conditions (F1–F10); the expectation
defines success scenarios (S1–S8), a Done means (D1–D6, baked to
`stop-condition.yaml`), and one recovery entry per failure condition.
To modify this play, update `reference/ice.md` and recompile with play-editor.
Do NOT edit this file manually — it is a compiled artifact.

## Role

You are the orchestrator. You own the workflow and the step order. Every mechanical
part of this play — resolving the mode, selecting and ordering the issues, building
each entry's reason, stamping its kind and recommended play from the kind map, and
grading the output — is deterministic code in `scripts/`,
never re-reasoned prose (C7). You delegate exactly one thing: the live read of the
issue host, which is a skill's job invoked through an agent, because scripts never
shell out to the host (layer rule). At close, after the list is verified and
presented, you delete the working folder yourself — the play leaves no scratch
behind (C9); the evidence record is never deleted.

**Forbidden:** any write verb against the issue host — `create-issue`,
`close-issue`, `comment-issue`, `add-label`, `attach-sub-issue`, assign, or edit
(C2/F1); launching another play; reading the product model, a backlog, a sprint
plan, or any work queue (C1); selecting, ordering or explaining entries by
reasoning instead of `scripts/select_focus.py` (C7); guessing a mode instead of
halting on an unrecognised one (C5/F5); presenting a list when the capture came
back partial or failed (F6); falling back to another mode or widening the window
when a mode matches nothing (C8); inferring an issue's kind, naming a play the kind map
does not contain, or working a recommendation out from the product model — model-derived
recommendation belongs to `/next`, never to this play (C11/F9); giving an entry a
recommendation the kind map has no play for — a default, a generic pointer, another
play's name — instead of leaving it blank (C12/F10) — the cardinal rule,
`standards/rules/no-unbacked-recommendation.md`, of which this play is the reference
implementation.

**Agent boundaries:**

| Agent | Domain | Skills it invokes | Phases |
|-------|--------|-------------------|--------|
| `project-orchestrator` | Read the tracked issue host for the mode's queries and capture the raw result set to disk | `platform-adapter` (`list-issues` verb, read-only) | Capture |

`project-orchestrator` is the single **domain agent** this play uses (1 of the ≤5
budget). No utility agents. The agent exists solely because live host reads belong
to the skill layer; it makes no selection decision — selection is `select_focus.py`.

## Pre-flight

| Check | Constraint | Action on Failure |
|-------|-----------|-------------------|
| Resolve config (`.garura/core/config.yaml`) via `scripts/preflight.py` | — | Hard halt |
| Mode resolves to `today`, `review` or `recent` via `scripts/resolve_mode.py` | C5 / F5 | **Hard halt** — print the three valid modes; never guess (REC5) |
| Issue host platform resolved from config (`github` / `gitlab`) | C1 | Hard halt |
| Host CLI authenticated and the repo reachable | F6 | Hard halt — no partial list is ever rendered (REC6) |
| Kind map resolves (`<play-dir>/reference/kind-map.yaml`, readable, carries `kinds` + `fallback` + `no_command_note`) | C11 / C12 | Hard halt — without the table there is no non-inferred way to name a kind or a play (REC9) |

```
python3 scripts/preflight.py --play focus --config .garura/core/config.yaml
python3 scripts/resolve_mode.py --mode "<mode-arg>" --window-days 7 --cap 10 \
        --out <working>/mode.json
```

`preflight.py` returns the config facts (`product_base`, `stm_base`, `platform`,
`evidence_record`). `resolve_mode.py` exits **2** on an unrecognised mode — that
exit is the hard halt; the play stops there and prints the record's `error` line.
Resolve the working dir as `<working> = ${product_base}_status/focus/`. `/focus`
has no branch or issue resolution (position `none`): it runs on whatever branch it
finds, including main, and leaves it untouched.

Right after the mode resolves, record the session identity stamp's start marker
(#463 — soft-fail, never a halt). `/focus` is read-only and issue-less, so the
marker lives in the play's own working folder; it travels with the run and is
removed by Step 7's self-clean, its durable copy being the evidence record:

```
python3 scripts/session_stamp.py --phase start \
    --marker "<working>/session-stamp-focus.json" \
    --cwd "$(pwd)" --branch "$(git branch --show-current)"
```

**Resume check:** `/focus` is cheap and advisory — a re-run is always a fresh run.
If `<working>/` holds artifacts from a prior run, overwrite them; never resume a
stale list against a host that may have moved.

## Task DAG

Create ALL tasks immediately after resolving config — before any domain work.
The play owns this DAG; the agent must not edit its top-level tasks.

```
[T1] Capture the issue set          blockedBy: []
[T2] Select, order and cap          blockedBy: [T1]
[T3] Verify the output              blockedBy: [T2]
[T4] Present the list               blockedBy: [T3]
[T5] Scenario Validation            blockedBy: [T4]
[T6] Close                          blockedBy: [T5]
[T7] Self-clean (delete working dir) blockedBy: [T6]
```

Mark each task in-progress before its step and completed right after its eval
passes. No runtime reordering.

## Workflow

### Phase: Capture

**Step 1 — Capture the issue set** · Owner: `project-orchestrator` · Depends on: pre-flight
The only live host read in the play, and the only step that is not a script. The
play dispatches a JSON contract; the agent invokes `platform-adapter` with the
**read-only** `list-issues` verb once per query the mode needs, merges and
deduplicates by issue number, and writes the raw result to disk — paths only,
never inline content:

    {
      "task":    "read the tracked issue host for /focus's chosen mode and capture the raw issue set to disk. Invoke platform-adapter with verb list-issues ONLY — never a write verb. For mode `today` or `review`: one query with state=open. For mode `recent`: one query with state=closed limited to issues closed within window_days. Pass fields=number,title,url,state,createdAt,updatedAt,closedAt,labels,assignees and a limit high enough to cover the repo (200). Merge, deduplicate by number, and write {capture_complete, operator, queries, issues:[...]} to out_json. `operator` is the host login of the person running — read it with platform-adapter's `view-user` verb, which returns the authenticated user's login on GitHub and GitLab alike; leave it null if that verb fails. Append the NAME of every platform-adapter verb you invoke, one per line, to verbs_log as you go — that log is the play's read-only proof at Step 3, and a missing log fails the run. Set capture_complete=false and return the host error if ANY query failed or was truncated — never write a partial set as complete. Make no selection, ordering, or ranking decision; capture only.",
      "intent":  "core/components/plays/focus/reference/ice.md",
      "inputs":  { "mode_record": "<working>/mode.json",
                   "config":      ".garura/core/config.yaml" },
      "outputs": { "out_json":  "<working>/issues.json",
                   "verbs_log": "<working>/host-verbs.log" }
    }

**SE-1 (C1/C5, F6):** `issues.json` exists; `capture_complete` is `true` (a `false`
or missing flag is a hard halt — REC6, no list is rendered); every issue in the set
came from the issue host via `list-issues` and no other source was read (C1); the
captured `state` values match `mode.json`'s `expected_state` (GitLab's
`opened` normalizes to `open`); and `host-verbs.log` exists and names only
`list-issues` and `view-user` — a missing log is a GAP, never a pass (F1/C2).

Immediately after the capture, snapshot it so Step 3 can prove the play changed
nothing (F1/C2). The agent has already written `host-verbs.log`; if that file is
absent the run halts here — an unwritten log is not evidence of no writes:

```
test -s <working>/host-verbs.log || { echo "no host-verb log — halt (F1/REC1)"; exit 1; }
cp <working>/issues.json <working>/issues-after.json
```

### Phase: Selection

**Step 2 — Select, order and cap** · Owner: play · Depends on: Step 1
Apply the mode's filter table, order the survivors by fixed rules, cap at 10, count the
surplus, build each entry's reason from the signals that selected it, and stamp its kind
and recommended play by first-match lookup in the kind map. A pure function of the
captured set, the mode record and the map — no judgment anywhere (C7/C11):

```
python3 scripts/select_focus.py --issues <working>/issues.json \
        --mode-record <working>/mode.json \
        --kind-map <play-dir>/reference/kind-map.yaml \
        --out-json <working>/selection.json \
        --out-md <working>/focus.md
```

**SE-2 (C3/C4/C6/C7/C8/C11/C12, F2/F3/F4/F9/F10):** both artifacts exist; `selection.json` carries
`mode`, `matched_count`, `shown_count` (≤ `cap`), `surplus_count`,
`entries_missing_fields`, `entries_off_map`, `entries_without_recommendation`,
`known_commands`, and an `empty` flag; every entry carries an integer `number`, a
non-empty `title`, a non-empty `reason` assembled from its `signals`, and a `kind` drawn
from the map (or its declared fallback); an entry carries a `recommendation` **only**
where the map gives it a `command`, and that command is in `known_commands` — every other
entry's `recommendation` is null, so `entries_off_map` is 0: no play name was invented
(C11/F9) and none was substituted where the table had none (C12/F10); entry order is
total (no duplicates, deterministic tie-break on issue number). On a GAP, apply
REC2/REC3/REC4/REC9/REC10 and re-run this step.

**Step 3 — Verify the output** · Owner: play · Depends on: Step 2
Run the enforcer. This is where the read-only proof, the cap, the state-matches-mode
rule, the entry shape, the determinism of the ordering, and the honest-empty rule are
all checked mechanically:

```
python3 scripts/check_output.py \
        --selection    <working>/selection.json \
        --mode-record  <working>/mode.json \
        --issues       <working>/issues.json \
        --issues-after <working>/issues-after.json \
        --md           <working>/focus.md \
        --host-writes  <working>/host-verbs.log \
        --kind-map     <play-dir>/reference/kind-map.yaml
```

**SE-3 (F1, F2, F3, F4, F5, F6, F9, F10 / C1, C2, C3, C4, C5, C6, C7, C8, C11, C12):**
`check_output.py` exits 0 — the captured set is byte-identical before and after and
the host-verb log is present and names no write verb — an absent log is a GAP, not a pass (F1/C2); the mode is one of the three and the selection used
it (F5/C5); the cap holds and the surplus is both correct and stated in the report
(F3/C4); every entry has a number, title and reason, and every number is rendered in
the report (F2/C3); every entry's state matches its mode, `recent` entries closed
inside the window (F4/C6); every entry's kind is one the map declares and every
recommendation present is a mapped command — nothing invented and nothing model-derived
(F9/C11); no entry the map has no command for carries a recommendation, none of them
names a play, the no-recommendation count is correct, and that count appears in the
report so the gap is visible rather than papered over (F10/C12); the order is total and duplicate-free (C7); an empty result
carries the explicit no-fallback message (C8); the capture was complete (F6); and no
entry appears that was not in the captured set (C1).
On any GAP, apply the matching recovery (REC1–REC6, REC9, REC10) and re-run this step.

**Step 4 — Present the list** · Owner: play · Depends on: Step 3
Output `<working>/focus.md` to the user **inline** — the mode and its plain label as
the lead, the matched and shown counts, the entries in order, each with its reason line and
its `kind — recommendation` line (or, where the map names no play, its
`kind — no-recommendation note` line), the no-recommendation count when any entry has
none, and the surplus count when the cap bit. Never fill a blank recommendation with a
default when presenting (C12). When nothing matched, print the empty
message as written and stop: never switch mode, widen the window, or relax a filter
(C8). The operator picks an issue and acts on it themselves — this play launches
nothing and writes nothing (C2).

### Phase: Scenario Validation

**Step 5 — Scenario evals** · Owner: play · Depends on: Step 4
- **SCE-1 (S1 — solo builder, no mode supplied):** `mode.json` has `defaulted: true`
  and `mode: today`; every entry in `selection.json` has `state: open`;
  `shown_count` ≤ 10; every entry has a non-empty `reason`, an integer `number` and a
  `kind`; an entry has a `recommendation` only where the map gave it a `command`.
- **SCE-2 (S2 — lead, work in flight):** under `--mode review`, every entry's
  `signals` contain at least one in-flight signal (an `assigned to` signal, a
  `has a branch or PR open` signal, or a `stale` signal); no open issue lacking all
  three appears in `entries`.
- **SCE-3 (S3 — anyone, what got done):** under `--mode recent`, every entry has
  `state: closed` and a `closed_at` whose age is within `window_days`; no entry has
  `state: open`; `shown_count` ≤ 10.
- **SCE-4 (S4 — big repo, over the cap):** when `matched_count` > `cap`,
  `shown_count` equals `cap` exactly and `surplus_count` equals
  `matched_count - cap`, with that number present in `focus.md`.
- **SCE-5 (S5 — empty result):** when nothing matches, `entries` is empty,
  `empty` is `true`, `focus.md` carries the explicit "Nothing matched" message, and
  `selection.json`'s `mode` equals `mode.json`'s `mode` — no fallback occurred.
- **SCE-7 (S7 — full-garura project, labelled issues):** on a repo whose issues carry the
  standard labels, the `defect`-labelled entry's `command` is `fix-bug`, the `epic` one's is
  `grill`, the `refactor` one's is `refactor`, the `feature` one's is `shape`, and the
  unlabelled one has no `command` and no `recommendation` at all; `entries_off_map` is 0.
  Checkable from `selection.json` + `kind-map.yaml` alone.
- **SCE-8 (S8 — operator, why is this one blank):** every entry with no `command` has a
  null `recommendation` and no play name anywhere in its rendered line;
  `entries_without_recommendation` equals the number of such entries; and that count is
  printed in `focus.md`. Checkable from `selection.json` + `focus.md` alone.
- **SCE-6 (S6 — audit, it changed nothing):** `check_output.py`'s `C2/F1 read-only`
  check reads PASS — `issues.json` and `issues-after.json` hash identical, `host-verbs.log` is
  present, and it contains zero write verbs.

### Phase: Evidence & Close

**Step 6 — Close** · Owner: play · Depends on: Step 5
Run the Standard Play Close. `/focus` is a **product-scoped** play (no issue of its
own — it reads issues, it does not open one) — use the product-scoped evidence base
and slug. Evidence recording is play-only and config-gated per the D1 evidence rule
(`standards/rules/evidence-recording.md`).

This phase ends with **Step 7 — Self-clean** (the bash block after the close): once
the evidence record and delivery report are written, the working folder is deleted as
the terminal action, so the run leaves no scratch behind (C9). Only the working
folder is removed — never the evidence folder, which is the durable record.
**SE-4 (C9/F7):** after Step 7, `${working}` no longer exists on disk while the
evidence folder (when evidence recording is on) is intact — the play's only surviving
products are the presented list and the evidence record. On a GAP (working files
remain), apply REC7 and re-run Step 7.
**SE-5 (F8/C10):** the close is stop-condition gated — `check_stop_condition.py` over
the baked `stop-condition.yaml` (D1 the captured issue set exists; D2 the mode
resolved; D3 the capped selection exists; D4 no entry is missing a reason, number or kind; D5 the presented list exists; D6 no recommendation is off-map or unbacked) reads **held** before the run closes COMPLETED; anything
else closes HALTED with the unmet clauses named. The gate runs at Step 6, BEFORE Step
7's self-clean removes the working folder. This play has no checkpoint, so there are
no gates to class under `gate-config.md` — the stop-condition gate and the evidence
flag are the close's only switches.

```bash
# --- Standard Play Close (canonical; see standards/rules/play-close.md) ---
# Path tokens resolved at pre-flight (resolve here if not already):
#   ltm_project_target  = yq '.ltm.project-target' .garura/core/config.yaml
#   evidence_base, slug:
#     project-scoped play : evidence_base="${stm_base}${issue}/evidence/focus/"  ; slug="#${issue}"
#     product-scoped play : evidence_base="${product_base}_evidence/focus/"      ; slug="${product_slug}"
evidence_template=$(cat "${ltm_project_target}standards/templates/evidence-file.md")
delivery_template=$(cat "${ltm_project_target}standards/templates/delivery-report.md")
ts=$(date -u +%Y%m%d-%H%M%S)
evidence_dest="${evidence_base}${ts}.md"
mkdir -p "$(dirname "$evidence_dest")"
# Session identity stamp (#463) — close phase; start phase ran at pre-flight
session_stamp=$(python3 scripts/session_stamp.py --phase close \
    --marker "<working>/session-stamp-focus.json")
# Stop-condition gate (#464) — Step C0: this play carries a baked manifest, so the
# gate is LIVE. Evaluate the Done means here — BEFORE Step 7's self-clean deletes
# the working folder — as the close's authoritative input.
python3 scripts/check_stop_condition.py \
    --manifest "<play-dir>/stop-condition.yaml" \
    --base "<working>/" \
    --out "<working>/stop-condition-focus.yaml"
sc_exit=$?   # 0 held · 1 unmet · 2 error
```

`/focus` is product-scoped: `evidence_base="${product_base}_evidence/focus/"` and
`slug="${product_slug}"`.

**Step C0 — bind the verdict.** `sc_exit == 0` (held) permits `status: COMPLETED`.
Anything else closes `HALTED` with `exit_reason: stop_condition_unmet` and the
evidence's Stop Condition section names every unmet clause. An unevaluable verdict is
never a pass.

**Step C1 — Write evidence file.** Gated by the resolved `evidence.record` flag
(global + per-play `evidence.plays.focus`; first match wins, absent ⇒ record). When
false, skip the write and record `evidence skipped (record=false)` in the report's
pointer line. Otherwise fill the `evidence-file.md` slots (play `focus`, run_id
`focus-${ts}`, product_slug, started_at/completed_at, status per C0, exit_reason;
artifacts produced: the mode record, the captured issue set, the host-verb log,
the resolved kind map, the selection, the presented list, the stop-condition verdict; step and scenario eval results SE-1…SE-5 /
SCE-1…SCE-6; checkpoint decisions: none — this play has no gates; the session identity
stamp fields from $session_stamp (#463): session_id, ledger_file, ledger_start_offset,
ledger_end_offset (null when unresolved — never blocks the close); and stop_condition
per C0 with the Stop Condition section filled) and write to `$evidence_dest`. Do NOT
hand-author the body.

**Step C2 — Render delivery report.** Also render the **Next** line: resolve this play
in `standards/rules/pipeline-next.md` and emit `**Next:** /<command> — <why>. Or run
/next to see all recommended actions.` (only the `/next` pointer, or omit, when the
mapped command is null), per `play-close.md`. Fill the `delivery-report.md` slots and
output the report: `## focus Delivered — ${product_slug}`, the Run Summary table, the
Pipeline Steps table from the task DAG, the Artifacts Produced table (the mode, the
matched and shown counts, the surplus, the listed issue numbers), Next Steps (the
issue the operator picked, if any), and a pointer to `$evidence_dest`. Always emitted;
never gated.

```bash
# --- end Standard Play Close ---
```

**Step 7 — Self-clean** · Owner: play · Depends on: Step 6 (declared above; SE-4)
The terminal action. The list has been verified (Step 3), presented (Step 4),
scenario-checked (Step 5), and the evidence record + delivery report written (Step 6)
— the working folder now has no further reader. Delete ONLY the working folder so the
run leaves no scratch behind (C9); never touch the evidence folder
(`${product_base}_evidence/focus/`), the durable record. The stop-condition verdict and
the session-stamp marker go with the working folder — their durable copies live in the
evidence record written at Step 6.

```bash
rm -rf "${working}"            # working = ${product_base}_status/focus/
```

## Scenario Validation

| Scenario | Persona | Eval |
|----------|---------|------|
| S1 — no mode supplied, pick something up | solo builder | SCE-1 |
| S2 — open work already in flight | lead | SCE-2 |
| S3 — what got done recently | anyone | SCE-3 |
| S4 — more matches than the cap | big-repo operator | SCE-4 |
| S5 — nothing matches the mode | any operator | SCE-5 |
| S7 — labelled issues, full garura | product team | SCE-7 |
| S8 — some entries cannot be recommended for | operator | SCE-8 |
| S6 — the run changed nothing | auditor | SCE-6 |

## Recovery

| For | Trigger | Direction | Handoff |
|-----|---------|-----------|---------|
| F1 | a write verb is attempted against the issue host, or the captured set differs before and after | halt the run before the call lands and report the attempted verb; read-only is structural and is never repaired by retry | human |
| F2 | an entry has no reason or no issue number | drop the malformed entry, re-render from the captured issue file, and record the drop | autonomous |
| F3 | the rendered list exceeds the cap, or the surplus count is absent or wrong | re-apply the cap over the captured set and re-render with the correct surplus count | autonomous |
| F4 | an entry's state does not match its mode (a closed issue under `today`/`review`, an open or out-of-window issue under `recent`) | re-run the mode filter over the captured file and re-render | autonomous |
| F5 | the mode argument is not one of `today`, `review`, `recent` | halt and print the three valid modes from `mode.json`'s `error` line; never guess a mode | human |
| F6 | the issue host call fails, is truncated, or returns `capture_complete: false` | halt before rendering; report the host error and that no list was produced — never present a partial list as complete | human |
| F7 | working files remain after the run completes | delete the working folder; the already-presented list is the only product | autonomous |
| F9 | an entry's kind or recommended play is absent from the kind map | re-derive both from `kind-map.yaml` over the captured labels and re-render; if either still fails to resolve the map is incomplete — record the gap and fall the entry back to `unlabelled` + the `/next` pointer, never a play the table does not contain | autonomous |
| F10 | an entry the kind map has no play for was given a recommendation anyway — a default, a generic pointer, or a substitute play name | strip the recommendation from that entry, re-render it as kind-only with the map's no-command note, and re-report the no-recommendation count; never repair by choosing a different play — the absence IS the correct answer | autonomous |
| F8 | the close would report COMPLETED without the Done means held | surface the unmet clauses and re-run the producing step (capture or selection) to restore the missing artifact, or close HALTED with the verdict recorded | autonomous |

## Pause and Resume

Steps run top to bottom. `/focus` does not resume — a list is only as good as the
issue-host state it was captured from, so any interruption means a fresh run:
re-resolve the mode, re-capture, re-select. Prior artifacts in `<working>/` are
overwritten. There is no status marker.

## Compilation Metadata

| Field | Value |
|-------|-------|
| fingerprint | sha256:b6ea6ca90cc1463d401f8130f42b80a1ff28a0ca9c6862bd9690ef11d932422c (of `reference/ice.md`) |
| compiled_by | play-creator; recompiled by play-editor (kind + recommended-play fields, C11/F9/S7/D6; then the cardinal rule — no unbacked recommendation — C12/F10/S8/REC10) |
| pipeline_position | none |
| structural_constraints | C1 (only `platform-adapter`'s read-only `list-issues` verb reaches any source — by construction of Step 1's contract; no model, backlog or queue path is opened anywhere in the play); C7 (selection, ordering, reason text, kind and recommendation are pure functions in `select_focus.py` — the play has no inference step); C11 (kind and recommendation are first-match lookups in `reference/kind-map.yaml`; the play opens no product-model path anywhere, so a model-derived recommendation is structurally impossible); C12 (`select_focus.py` sets `recommendation` to null whenever the matched row has no `command` — there is no code path that can substitute a default, and `check_output.py` fails any entry that acquires one); C9 (the working folder is the play's only write target outside the evidence record, and Step 7 is its terminal deletion) |
| standards_rules | `no-unbacked-recommendation.md` (the cardinal rule — this play is its reference implementation: C12 constraint, F10 failure, S8 scenario, REC10 strip-not-replace recovery, SE-2/SE-3 evals) |
| workflow_structure | readiness-only (analysis, no generation; no checkpoint — the output is advice; nothing to class under gate-config.md) |
| stop_condition | stop-condition.yaml (D1–D6), gate live at Step C0 — evaluated BEFORE the Step 7 self-clean |
| domain_agents | 1 (project-orchestrator) |
| utility_agents | 0 |
| skills_used | platform-adapter (`list-issues` + `view-user` verbs, read-only) |
| data | reference/kind-map.yaml (the label→kind→play table; project-editable, no recompile needed) |
| scripts | 6 (preflight.py, resolve_mode.py, select_focus.py, check_output.py, check_stop_condition.py, session_stamp.py) |
| step_evals | 5 (SE-1…SE-5; every failure condition covered: F1→SE-3, F2→SE-2+SE-3, F3→SE-2+SE-3, F4→SE-2+SE-3, F5→SE-3 (+pre-flight hard halt), F6→SE-1+SE-3, F7→SE-4, F8→SE-5, F9→SE-2+SE-3, F10→SE-2+SE-3) |
| scenario_evals | 8 (SCE-1…SCE-8) |
| recovery_entries | 10 (one per failure condition; 7 autonomous / 3 human) |