armelhbobdad/bmad-module-ultracode-goal / skills/ultracode-goal
ultracode-goal
FlaggedRuns a BMAD Epic autonomously to a machine-checked Definition-of-Done. Use when the user requests to 'run an epic autonomously', 'execute this epic', 'ultracode goal', or 'autonomously deliver the epic'.
scripts/tests/fixtures/execute_pre_verification_axes.md
View on GitHub# Stage 4 — Execute
Drive each in-scope story from its red-phase acceptance tests (generated in Stage 3) to a green, committed state. This stage **produces and prints evidence**; it does **not** decide completion. The completion verdict belongs to Stage 5 (`scripts/gate_eval.py` reading TEA's `gate-decision.json`) — never the `/goal` transcript evaluator, which can only see what you surface and cannot read the gate file. Run prose in `{communication_language}`.
Two paths. **Sequential `/goal` spine is the default.** `--parallel` worktree fan-out is an additive, **experimental** opt-in. Both share the same hooks and the same Stage 5 gate.
Preconditions (asserted, not assumed): you are on the Epic branch (`{workflow.epic_branch_prefix}…`, off a `{workflow.protected_branches}` branch), PreToolUse + Stop hooks are active in `.claude/settings.local.json`, the allowlist is pre-populated, and — **in production** — every in-scope story has an `atdd-checklist-{story_key}.md` with `test.skip` acceptance tests. (Under `--light` there is no atdd-checklist by design; the story file's clear acceptance criteria are the Stage-5 trace oracle instead — see define-done.md's `--light` note. The clear-ACs precondition still holds.) If any is false, return to Stage 2.
**On resume, re-enter Execute at the first story whose last logged gate verdict is not advance; advanced stories are not re-run; re-assert (do not rebuild) the Epic branch, hooks, the allowlist, the `.mem-state.json` recall latch, and the in-flight story's baseline marker before continuing** — the latch is *re-written* by re-running Stage 1's latch step (`references/ingest-and-scope.md`), because Stage 6 removes it at every close-out and the PreToolUse hook reads an absent latch as "no run active" and stops gating claude-mem entirely; the baseline marker is the opposite, *re-read* and never regenerated: the resumed story may already carry commits, and a rebuilt baseline silently re-anchors its evidence range to a mid-story HEAD.
## Default — Sequential `/goal` spine
For each in-scope story, in sprint order, run this loop:
0. **Set the current story and record its baseline commit** — both **before any implementation**, before step 1 touches a single file. First, so the PreToolUse hook can locate this story's marker: write the story id to `{workflow.implementation_artifacts}/.current-story` (or export `ULTRACODE_STORY_ID=<story_id>` for the run). The guard reads the story id from `ULTRACODE_STORY_ID`, falling back to that `.current-story` file — without one set, it cannot find the marker and denies every commit. Then anchor the story: **if `{workflow.implementation_artifacts}/.baseline-<story_id>` is absent, write it now** with the output of `git rev-parse HEAD` — **exactly one newline-terminated line carrying the full 40-hex SHA**. This format is a contract, not a style choice: later stages bound this story's commit range from it and compare it as a verbatim whitespace-stripped string, so a `git rev-parse --short` abbreviation or a write with no trailing newline is a silent breakage, not a cosmetic one. **If the marker is already present, this story is a resume: read it and keep it — never overwrite it.** No later step refreshes it; a multi-commit story must keep the SHA it started from even after HEAD moves.
1. `bmad-create-story` (if not already current) → `bmad-dev-story` implementing the feature and **un-skipping** the story's ATDD acceptance tests (remove `test.skip()`) — **production only**; under `--light` there are no ATDD tests to un-skip, so the DoD is the story's acceptance criteria satisfied with lint and build green. Before delegating, check the run's `.decision-log.md` for an **Operator notes** entry naming this story (a pre-launch hint like "watch the auth flow in story 3") and surface that note into the `bmad-dev-story` / review context for this story so the operator's last words actually reach the work.
2. Run the tests, lint, and build, and **PRINT the raw output** (pass/fail counts, lint result, build result) into the transcript. **In a monorepo, scope that test run wide enough to catch cross-package regressions** — run the full suite, or the changed package(s) plus everything downstream of them (e.g. an `--affected` set *and its dependents*), not just this story's own package. A story's change can regress a *sibling* package's conformance gate (a cross-package RBAC, ownership, or architecture-boundary check), and a run scoped to only this story's package reports green while that sibling gate is red — deferring the red (and its fix) to a later story or the Epic gate instead of catching it at the story that caused it. This printed evidence is what keeps the run judgeable mid-flight and what the `/goal` driver reads to pace itself — but it is *evidence*, not the gate. **Once all three go green, write the tests-ran marker** `{workflow.implementation_artifacts}/.tests-ran-<story_id>` (mirroring `assets/execute-epic.workflow.js` step 3) — the PreToolUse guard denies the step-4 commit unless this marker exists for the current story, so write it only after a real green run. **That marker must carry a `baseline=<sha>` line** whose value is the verbatim, whitespace-stripped content of `{workflow.implementation_artifacts}/.baseline-<story_id>` written at step 0 — **copied, never re-derived from `git rev-parse HEAD`** at marker-write time. The guard compares the two strings character for character and denies the commit when they differ or when the line is missing, which is what stops a marker written against an older code state from being replayed to satisfy a later commit. Re-deriving the value here instead of copying it is the trap: on a story that commits more than once, HEAD has already moved past the baseline, so a re-derived line denies the story's own second commit.
3. **Production profile only:** `bmad-testarch-test-review`, then `bmad-code-review`. A `CONCERNS`-grade or non-critical finding appends to `{workflow.deferred_work_path}` and the story proceeds. A **P0 / critical FAIL never defers** — re-loop within the turn budget or escalate.
4. **Commit at green** (one commit per green story). The PreToolUse hook blocks a commit on a protected branch, blocks a commit when no "tests-ran" marker exists for the current story, and — its marker-freshness clause — blocks a commit when that marker's `baseline=` line does not match the story's recorded baseline, so step 0 must have set the current story and step 2 must have actually run and written `{workflow.implementation_artifacts}/.tests-ran-<story_id>`, in the format step 2 pins, **in a prior, SEPARATE command**. The guard pre-evaluates the command *string* before it runs, so a marker written by a `printf`/`echo` in the SAME compound command as the commit (e.g. `printf … > .tests-ran-<id> && git commit …`) does not yet exist at hook-eval time and the commit is denied. Write the marker, then commit — two distinct tool calls. **Append `.decision-log.md` with Write/Edit, never a Bash heredoc.** Stages 4 and 6 require a log of what happened during the run, and what happened *is* commit behaviour — so the log quotes the verbs. The guard evaluates Bash command strings, and a heredoc carrying that prose is a Bash command string: a line leading with the verb is a verb-leading segment, and backticked identifiers or an apostrophe send the whole segment down the fail-closed matches-anywhere path. The guard never sees Write/Edit at all, so writing the log with the file tools removes the collision instead of phrasing around it, and keeps Bash for commands you actually mean to run. **Stage only the current story's paths.** In production, Stage 3 generated *every* in-scope story's red-phase tests up front, so a sibling story's still-skipped tests can co-reside in the same shared dirs as this story's (one `test/` package may hold two stories' acceptance specs before either commits). A blanket `git add -A` here sweeps those uncommitted sibling tests into this story's commit and pollutes the per-story boundary — stage this story's source + test paths explicitly (`git add <this story's paths>`) instead. The allowlist ships plain `git add` (a prefix covering both `-A` and a scoped `git add <paths>`) so the targeted add needs no extra approval. **Staging is itself a prior, SEPARATE tool call**: `git add <this story's paths>` as one call, then `git commit` as a second — the same two-distinct-tool-calls rule the marker follows, and for the same reason. The guard also denies a commit whose staged index is empty, and a chained `git add … && git commit` has staged nothing at the moment it pre-evaluates that command string, so the chained form is denied even though the add would have worked. `git commit -a` and commit-time pathspecs (`git commit <paths>`) are unsupported inside the story loop for exactly that reason. (Under `--light` no ATDD tests are generated, so the collision cannot arise; under `--parallel` each story owns its worktree, so it does not arise there either.)
5. **Re-verify on the committed HEAD.** Re-run the authoritative full suite (tests + lint + build, the same wide scope as step 2) on the just-committed, clean tree and **PRINT** the result before advancing. Step 2's pre-commit run cannot see a **conformance gate scoped to *tracked* files** — a `git ls-files`-based ref/ownership/architecture-boundary check: a story's **new** files are still untracked at step 2, so the gate skips them and reports green, then reds the instant the commit tracks them (generated or `.gitignore`d files hide the same way). This committed tree is the exact fileset CI and the Stage-5 gate will see, so a story that is green pre-commit but red here is a **false green** the pre-commit run and the `/goal` transcript evaluator both miss. A red means the story is **not** done: remediate, write a fresh `.tests-ran-<story_id>` marker, and re-commit (amend or a follow-up within the story boundary) until the committed HEAD is green — only then advance. **That fresh marker carries the same `baseline=<sha>` line as step 2's**: the verbatim, whitespace-stripped content of `{workflow.implementation_artifacts}/.baseline-<story_id>` — **copied, never re-derived from `git rev-parse HEAD`**. The story's baseline has not moved; HEAD has, because step 4 just committed. Re-deriving it here would re-anchor the story to that commit and quietly retire the freshness net for the rest of it, which is the very replayed-marker hole the line exists to close — and without the line the guard denies the re-commit outright, so a story that legitimately needs remediation could never close. That re-commit carries the SAME staging rule as step 4: stage in a prior, SEPARATE tool call (`git add <this story's paths>`), then run the commit (or `git commit --amend`) as a second, distinct call. `git commit -a` and a chained `git add … && git commit` are unsupported here too — the staged index is still empty when the guard pre-evaluates the command string, so the re-commit is denied.
**Sub-skill halt catch-all.** If any orchestrated sub-skill blocks on interactive input mid-run, treat it as escalate for that story — write the typed escalation sidecar `{workflow.implementation_artifacts}/escalation-<story_id>.json` (shape below, under "Escalation sidecar") and stop; do not answer its prompt blind.
### The per-invocation work bound (`--max-stories N`)
When the operator passed `--max-stories N`, count the stories this **invocation** has taken all the way to a Stage-5 verdict, and once that count reaches N with in-scope stories still remaining, leave the spine and go to Stage 6. **Not "as if the Epic had run out of stories" — it has not.** The Epic-level trace gate is triggered by `references/gate.md`'s own condition (*every* story of the Epic is `done`), which a bounded stop leaves false, so that gate does not fire and Stage 6 must not author one: an Epic-level PASS over an Epic that still owes stories is precisely the misrepresentation `gate.md`'s partial-by-design exception exists to prevent.
**It bounds work, not scope.** In-scope is still every not-`done` story of the Epic (Stage 1 rule 3; headless never narrows it), so the remaining stories are not skipped, not deferred, and not logged as `skipped-already-done` — they are simply *not driven this time*. The next invocation's resume routing re-enters at the first story whose last logged gate verdict is not advance, which is precisely where this one stopped, so nothing about resume needs to know the bound existed. Log the bound and the carried-over story ids in `.decision-log.md` so the stop is reconstructable after compaction; an unexplained early exit and a crash look identical in a log.
**Check it at the story boundary and nowhere else.** The tempting place is wherever the count happens to tick over, and that is the trap: the loop above writes a baseline marker at step 0, a tests-ran marker at step 2, and commits at step 4, so a bound applied mid-story abandons a story with markers on disk and no commit. Evaluate it only after the story's Stage-5 verdict has landed, i.e. between laps, never inside one.
**A bounded stop is a completion, not an abort — Stage 6 still runs in full.** Auto Memory capture, the decision-log audit, the run report, the gate trail over the run's **in-scope** stories (finalize.md requires every in-scope id, so the ones this invocation did not drive render `n/a` under its fail-soft source rule rather than being omitted), and (headless) the terminal health check all happen exactly as they would on a full run, and the emit is the ordinary five-key envelope with `status` `complete`. The one thing that does *not* happen is the Epic-level gate, per the paragraph above, and for the same reason the `on_epic_complete` hook stays unfired: the Epic did not complete. Returning early *past* finalize would produce no report and, worse, no `run-result.json` at the pinned path — and the documented automator tests for that file's presence, so a bounded invocation that skipped the terminal would be indistinguishable from one that was killed. There is deliberately **no third status value**: `complete` here means "this invocation finished its work without blocking", and a caller that needs to know whether the Epic still owes stories re-reads sprint-status, never the status word.
**This bound belongs to the sequential spine**, and it deliberately claims nothing about `--parallel`: that path hands the whole in-scope list to the fan-out workflow up front, so a bound there would have to trim the list itself, which is the scope narrowing this flag exists not to be. Under `--parallel`, ignore `--max-stories` and log the one-line note that it was ignored rather than silently honoring it as a shorter `stories` array.
`scripts/drive_epic.py` is the intended caller: it spawns one `claude -p` per story under `--max-stories 1`, deleting the pinned `run-result.json` before each spawn so the file's presence means *that* spawn reached a terminal, and it stops the drive if a session reports `complete` without its story having advanced to `done`. That last check is only sound because Stage 5's `advance` route **writes** the `done` row itself (`references/gate.md`) — the sub-skills leave a passing story at `review` or `in-progress`. If that sync is ever dropped, the driver's progress check goes with it: an unattended loop would read a healthy advance as no progress and halt.
### Authoring the `/goal` condition
Wrap the loop in a single `/goal` whose condition is **under 4000 characters** and encodes the per-story Definition-of-Done as the success criterion, with an explicit escape clause. The condition must:
- State the DoD in checkable terms: ATDD acceptance tests for the story un-skipped and **passing** (production) — or, under `--light`, the story's acceptance criteria demonstrably satisfied — plus lint clean, build green, and (production) test-review + code-review passed — mirroring the printed evidence so the transcript-only evaluator can corroborate it.
- Include the literal escape: **"…or stop after {workflow.max_turns_per_story} turns."** This is the in-condition runaway guard. The `budget_stop.py` Stop hook is belt-and-suspenders — it counts turns against `{workflow.max_turns_per_story}` and writes an escalation marker when exceeded — but a Stop hook **cannot force `/goal` to halt mid-condition**, so the turn clause inside the condition is the real bound. State it.
- Make explicit that **passing the condition is not completion** — the authoritative verdict is Stage 5's `gate_eval.py`. The `/goal` condition gets a story to a *plausibly* done, evidence-printed state; the gate decides.
Keep it under the character limit by referencing the story's `atdd-checklist` (or, under `--light`, its acceptance criteria) and printed test output rather than restating ACs verbatim.
After the spine finishes (all stories committed-at-green, or a story hit its turn bound and wrote an escalation marker), proceed to Stage 5 for the deterministic per-story and epic-level gate.
**Escalation ping.** Before proceeding, scan `{workflow.implementation_artifacts}` for the escalation markers *this* run produced. A `.escalation-<story_id>.md` is in scope only when it **both** names a story in this run's plan **and** was written after this run's start — both conjuncts, never either one alone. A marker naming an unplanned story belongs to another Epic escalating concurrently; a marker naming a planned story but predating this run's start is residue from an earlier run of the same Epic, and firing on either would tell an absent operator about an escalation nobody is having. On the first in-scope marker, promote it to the typed sidecar `{workflow.implementation_artifacts}/escalation-<story_id>.json` (see "Escalation sidecar" below) before firing anything, so a hook that reads the sidecar finds it already on disk. Then fire, **check-then-write** against `{workflow.implementation_artifacts}/.on-escalation-fired-<run-id>`, where `<run-id>` is the run id minted at Stage 1 and carried forward verbatim — never re-derived here, since re-minting that timestamp would produce a fresh marker on every read and defeat the dedup entirely. If that marker is already present, skip silently: the other fire site already pinged for this run. If it is absent, resolve `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_escalation`; when the resolved value is non-empty, follow it as an instruction (a prompt to run or a shell command), stating alongside it **the escalating story id** and the path to that story's typed `escalation-<story_id>.json` sidecar as the context it carries, and only then write the fired-marker. A resolved-empty value is a silent no-op — nothing fires and no fired-marker is written — so an empty hook can never suppress a later real one. This ping belongs to the sequential spine: under `--parallel` each worktree agent sees its own `{workflow.implementation_artifacts}`, so a fired-marker written inside a worktree deduplicates nothing across worktrees, and the Finalize site is the only reachable one. That is sufficient, because Finalize always runs in the conductor.
### Escalation sidecar
Every escalation route — the sub-skill halt catch-all above, the gate's `escalate` verdict, and a story that exhausted its turn bound — writes **one** typed sidecar at `{workflow.implementation_artifacts}/escalation-<story_id>.json`, on top of whatever it logs in prose. A status read and a resume both have to reconstruct *which* decision is pending, and the run that escalated is exactly the run whose transcript is no longer in front of anyone. Prose alone leaves them re-parsing a log; a typed file does not.
It is a single JSON object, exactly these four string fields and no fifth:
```json
{"source": "<the path:line, or marker file, the escalation came from>",
"kind": "<short slug naming the escalation's origin>",
"decision_needed": "<the exact decision a human must make>",
"evidence": "<one quoted line supporting it>"}
```
One object, never an array: the file is already named per story, so a list would only re-encode the story id inside a file that carries it in its name.
`kind` is **open vocabulary**. A reader renders whatever string it finds and never validates it against a fixed list — in particular never against the red-kind vocabulary the semantic scan returns in `references/preflight.md`, which classifies *planning-artifact* reds and has no term for anything that happens at run time. `budget-overrun` is a live `kind` and sits deliberately outside that vocabulary; a reader that validated against it would silently drop the most common escalation there is.
**Promoting the turn-budget marker.** The `budget_stop.py` Stop hook writes only its own markdown, `{workflow.implementation_artifacts}/.escalation-<story_id>.md`. It stays a recorder: it emits no JSON and starts no process. **Execute is the sole promoter of that markdown** — after `/goal` returns, read any `.escalation-<story_id>.md` the hook left behind and write the typed sidecar from it, mapping `source` to that markdown's path, `kind` to `budget-overrun`, `decision_needed` to the human decision the marker asks for (re-scope, split, or hand off), and `evidence` to one line quoted from the marker. Keeping promotion here means one code path produces the typed JSON whatever the escalation's origin, instead of two writers racing on a file three readers depend on.
**Leave the markdown in place — never delete it, never rewrite it.** It is the residual that survives a session which died between the hook's write and this promotion, so consuming it would destroy the only evidence that an escalation happened at all.
This promotion belongs to the sequential spine. Under the `--parallel` fan-out each worktree sees its own `{workflow.implementation_artifacts}`, so nothing here claims to cover a sidecar written inside a worktree.
## Experimental — `--parallel` worktree fan-out
Only when the user passed `--parallel`. Invoke the saved dynamic workflow `assets/execute-epic.workflow.js` (registered as `/ultracode-goal-execute`) with:
```
args = {
epic, # Epic id
stories, # in-scope story ids/keys, sprint order
profile, # "production" | "light"
paths: {
trace_output: {workflow.trace_output_dir},
deferred_work: {workflow.deferred_work_path},
implementation_artifacts: {workflow.implementation_artifacts},
tea_config: {workflow.tea_config_path},
skill_root: {skill-root} # resolved absolute skill dir; the .js has no
# {skill-root} resolver, so it must arrive pre-resolved
},
max_concurrency: {workflow.parallel_max_concurrency}
}
```
Pass `paths.skill_root` as the **resolved** `{skill-root}` (the absolute install dir). The workflow runtime executes the `.js` directly and has no `{skill-root}` resolver, so it substitutes this value into the `gate_eval.py` invocations it emits to each subagent; without it the spawned worktree agent receives a literal `{skill-root}` and must guess the script's path.
Each story runs isolated in its own worktree: `bmad-dev-story` (un-skip ATDD — production; under `--light` there are none) → run tests/lint/build → (production) `bmad-testarch-test-review` → `bmad-code-review` → commit at green → per-story `gate_eval`. After all stories, an epic-level trace gate. The workflow returns `{ perStory: [{story, verdict, gate_status}], epicGate, deferred: […] }`, which feeds Stage 5/6.
**This path is experimental — be explicit about its limits and do not silently rely on it:**
- **No mid-run input.** The fan-out takes no interactive input once launched; every blocker must be resolved at preflight or not at all. This is why launch requires post-remediation budget == 0.
- **Shared Auto Memory.** Concurrent worktrees write to **one** Auto Memory directory — there is no per-worktree isolation of learned facts; expect interleaving.
- **Under-documented interplay.** The workflow↔skill handoff (how args bind, how subagents inherit the allowlist and hooks) is not fully specified by the platform docs; treat its behavior as empirically validated, not guaranteed.
- **No `run-status.json` heartbeat.** Worktree agents cannot reliably write one shared snapshot (each worktree sees its own copy of `{workflow.implementation_artifacts}`), so this path does not write it — progress is watched via the workflow progress view (`/workflows`) and its run log, and the launch briefing says so.
- **No post-commit re-verify.** Unlike the sequential spine's step 5, the fan-out commits at green and goes straight to per-story `gate_eval` without re-running the suite on the committed tree — so a **tracked-files-scoped conformance gate** (a `git ls-files`-based ref/ownership/boundary check) that only reds once a worktree's new files are committed can slip a per-worktree green through to the merge. Until this path re-verifies on the committed HEAD, treat the epic-level gate over the merged result as the backstop for that class, and prefer the sequential spine for repos that carry such a gate.
### Graceful degradation
If dynamic workflows are **unavailable** (wrong Claude Code version, workflows feature off, or the saved command does not resolve), **fall back to the sequential `/goal` spine above** and log a one-line note in `.decision-log.md` recording why `--parallel` degraded. The Epic still ships; it just ships sequentially.
## Record
Log to `.decision-log.md`: the path taken (sequential / parallel / degraded-fallback), per-story turn-budget outcomes, every commit-at-green, every deferral appended to `{workflow.deferred_work_path}`, and any escalation marker. The printed test/lint/build evidence stays in the transcript; the decision log carries the durable account across compaction.
## Run-status heartbeat
As the spine advances — each time you move to a new story, log a gate verdict, or spend a re-loop — write `{workflow.implementation_artifacts}/run-status.json` so an automator (or an anxious human) polling a long/headless run has something structured to read instead of prose. Overwrite it in place; it is a single live snapshot, not an append log:
```json
{"epic": "<epic id>",
"story": "<current story id>",
"index": <1-based position of the current story>,
"total": <in-scope story count>,
"last_verdict": "<advance|defer|reloop|escalate, or null before the first gate>",
"last_reasons": [<the reason strings from the gate result just read, empty before the first gate>],
"reloop_count": <re-loops spent so far this run>,
"stories": [{"story": "<story id>",
"phase": "<where the spine has this story>",
"verdict": "<that story's last gate verdict, or null before its gate>",
"dev_attempts": <implementation passes spent on this story>,
"reloop_count": <re-loops spent on this story>}],
"budget_used": {"turns": <turns spent on the current story>, "max_turns": <the resolved per-story turn ceiling>},
"profile": "production|light",
"updated": "<ISO-8601 timestamp>"}
```
`last_reasons` and `budget_used` are machine-derived, not narrated. `last_reasons` is the `reasons` array from the `gate_eval.py` result the spine just read, copied across unedited, so a poller sees *why* the last verdict landed instead of only the verdict word; `stories` carries one entry per in-scope story on the same cadence, so an entry appears as soon as the spine reaches that story and its `verdict` stays null until the gate runs. The two `reloop_count`s are deliberately the same name at two nesting levels and are not duplicates: the top-level one is **run-scoped** (every re-loop spent this run), the one inside a `stories` entry is **story-scoped** (that story's own re-loops).
`budget_used` has exactly two sub-keys and no third: `turns`, copied from the `turns` value in `{workflow.implementation_artifacts}/.budget-<story>.json` that the Stop hook maintains, and `max_turns`, the resolved `{workflow.max_turns_per_story}` — the same value preflight already injects into the hook environment, so the ceiling reported here and the ceiling the hook enforces cannot drift apart.
When the prior snapshot's `budget_used.turns` and the current `.budget-<story>.json` disagree, the hook file wins: re-read it on every write and never carry the snapshot's own number forward, because the hook file is the only counter that observes every Stop event while a number already sitting in the snapshot is a stale copy written before the last turns landed.
Before the Stop hook has fired for a story, no `.budget-<story>.json` exists yet. That is a normal early-story state, not an error: render `budget_used` as `{"turns": 0, "max_turns": <the resolved ceiling>}` and write the snapshot anyway — an absent hook file is never a reason to skip the write, defer it, or leave the heartbeat partially written.
This is the file the Stage 2 launch briefing points the operator at ("where to watch"); Stage 6 (finalize) records the terminal state into it when the run closes, carrying every key above forward rather than overwriting the file with a narrower object.
**Attended runs also get a ticker.** Each time you write the heartbeat, print one line into the transcript — `epic-7 ▸ story 3/6 — last verdict: advance` — so the watching human sees motion without opening a JSON file. Skip the ticker in headless (`-H`): the file is the interface there, and transcript prose has no reader.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |