| name | workflow:continue |
| description | Principal workflow entry — resolve portfolio mode (swarm resume/handoff or unit state machine), drive work without inventing path; hard-stop when path is not established |
| argument-hint | [--worktree] [optional: work item ID, planning dir, or blank to auto-pick] |
| user-invocable | true |
Continue (/workflow:continue)
Principal entry for /workflow sessions (bare /workflow routes here). Orients from the
resolved planning root (.agent-tools/planning/ preferred; else ./planning/ — see
@workflow references/planning-root.md), never invents a next unit, then selects a
portfolio mode:
| Mode | When |
|---|
| swarm_resume | Active swarm run in progress / paused |
| swarm_handoff | Explicit roadmap ∥ / {wave} group at head (≥2 claimable) + swarm ready |
| unit | One claimable slice → phase state machine (cycles allowed under evidence guards) |
| hard_stop / hard_stop_choice | Nothing named, or sequencing choice / map-only |
When path is clear, run silently (no portfolio monologue). End-of-loop recap and review
ceremony still apply except at user-approval stops (see gates).
Not a recipe engine or horizon author. Phase skills run natively; continue only chooses mode,
unit, and next legal transition. Multi-unit maps: /workflow:roadmap. Multi-item parallel
execution: /swarm (auto-entered from here when eligible; still user-invocable as override).
User Input
$ARGUMENTS
| Input | Meaning |
|---|
| (empty) | Soft-check → portfolio mode resolve → drive |
| Work item ID / PM URL / planning path / slug | Force unit mode on that target |
--worktree | Isolated worktree for unit mode (see Workspace) |
--yield / yield | Regenerate .agent-tools/runs/yield.md from ledger; summarize KPIs; stop (no unit claim unless also given a target) |
Mandatory loads
| When | Load |
|---|
| Always (this skill) | Soft orientation rules below; refuse list |
| Path roots | @workflow references/planning-root.md |
| Before mode select | references/portfolio-router.md |
| Unit mode | references/unit-state-machine.md, references/phase-return.md, @workflow references/tracks.md |
| After phase-return | @workflow references/runs-ledger.md (append event; close-run on done) |
| Yield-only args | @workflow references/runs-ledger.md (regenerate yield.md) |
| Before review / integrate / recap / merge | references/gates.md |
| Cross-session / multi-agent pause | @workflow references/handoff-package.md (optional) |
| Orientation | references/soft-checks.md |
| Conventions present | planning/conventions.md (tracks, gates, merge policy, orientation entrypoint) |
| Schema / family contracts | @workflow (session-state, branch naming, PM mode, claim dialect) |
Hard gates are not optional. gates.md is a mandatory load, not a nice-to-read essay.
Control loop
if yield-only args → regenerate yield.md → summarize → stop
orient (conventions + soft-checks)
→ load portfolio-router → MODE
→ swarm_resume | swarm_handoff | unit SM | hard_stop*
→ on unit: classify → transition → phase → phase-return → runs append → re-classify … until stop
→ on done: close-run ledger row
→ handoff / recap per gates
Orientation
Keep handoffs light — scan state, do not read a heavyweight narrative.
- Resolve planning root (
.agent-tools/planning/ preferred). Conventions
(planning/conventions.md if present): built-in + extra tracks, additive gates,
integration/merge policy (incl. autonomous local merge), visual plan policy, orientation
entrypoint / PM queue. Sparse overlay: absent sections keep built-in defaults. Built-in
tracks always available: feature | micro | research (@workflow references/tracks.md).
- Soft-checks (
references/soft-checks.md) — theater review / missing compound / thrash
counters on the prior or claimed unit before burning new loops.
- Scan claimable units:
planning/*/session-state.md, top-level handoff, roadmap /
initiatives dialect, PM queue only when conventions say so (closed filter — never invent).
Named NEXT without a planning dir is still claimable. Channel paste / issue key /
workflow:claim body → explicit unit (portfolio row 1).
- Portfolio mode (
references/portfolio-router.md) before unit claim. Do not invent
a pseudo-slice to enter the machine.
Path / invent rules (always on)
- Never invent NEXT from fatigue language (“you decide”, “pick something”) or residual-only notes.
- Scaffolding ≠ inventing — creating
planning/<slug>/ for a named unit is normal.
- Named-without-shell → claim and enter unit SM (usually
needs_refine).
- Fatigue without a unit id/path/slug → hard_stop.
- Auto-invoke brainstorm/roadmap only when the unit SM routes there for a claimed unit;
otherwise stop + offer.
Hard-stop template
### Path not established — stopping
Continue will not invent a next unit.
**Options:**
1. Name a concrete unit (issue id, slug, or `planning/<slug>/`) and re-run `/workflow:continue`
2. `/workflow:brainstorm` — single fuzzy concept
3. `/workflow:roadmap` — multi-unit destination + order (or resequence)
Optional thin steering (v1)
Default: no offer. If the claimed unit carries an unacked greppable steering_note: that
affects whether to claim it, present at most one offer; on proceed, ack the note. No density latch.
Portfolio modes (summary)
Full rules: references/portfolio-router.md.
- Explicit args → unit (skip auto-swarm).
- Active swarm run → swarm_resume (
/swarm:continue semantics).
- Explicit
∥ / {wave} at head, ≥2 claimable, swarm ready → swarm_handoff (auto).
- Same but swarm not set up → one ask: setup then handoff, or sequential first peer.
- Else single-unit claim order:
in_progress → handoff/roadmap NEXT → planned queue.
- map-only / sequencing choice without a resolvable unit → hard_stop_choice.
- Nothing named → hard_stop.
Auto-swarm eligibility is narrow: only explicit parallel groups at the active head — not
“several units that look independent.” ⚠ A ∥ B is a collision watch, not a launch package.
Unit phase state machine (summary)
Full table: references/unit-state-machine.md. After each phase: references/phase-return.md.
classify(disk + decisions) → guarded transition → invoke phase → phase_return → re-classify
Track first: feature | micro | research (or conventions custom). Micro uses
direct-issue execute + quick review; research uses conclusion deliverable — see tracks.md.
Feature states: fuzzy · needs_refine · needs_plan · ready_execute · needs_review ·
needs_integrate · needs_compound · done · await_user · blocked.
Cycles are legal when evidence says so (e.g. execute → refine on decision drift; review →
execute on code findings; review → plan on structural findings). Happy path is still one walk.
After plan approve → same-session execute (no emit-and-stop default).
Skip refine/plan only when track is micro (issue-as-plan) or artifacts match the current
governing decision. Stale artifact vs moved decision → re-enter refine (resize). Thrash bound:
2 refine/plan re-entries from execute/review per run_id without new external evidence →
await_user. Corpus fixes → skill-source /skills:evolve (or upstream escalate), not in-loop
skill edits.
Append phase-return events to .agent-tools/runs/ per runs-ledger.md.
Review / merge / recap (always-on refuse)
Full schemas: references/gates.md (mandatory load before these transitions).
- No code → merge without real review + valid evidence (
method, date, verdict, P1–P3
counts, disposition).
- No treating typecheck/lint/test/build as review.
- No inventing
review: clean theater.
- Autonomous merge only if conventions allow and all ratchet preconditions hold (reviewed +
gates + ACs + recap Review block when recap applies).
- Compound after integrate, or explicit
compound: none — <reason>.
- Recap required except at user-approval stops (plan approval, merge confirm, triage choose, …).
Workspace
Default: main workspace. If the unit already has a worktree, enter it. --worktree: create
or enter via @git worktree-create; continue never removes a worktree.
Handoff on stop
Update planning/<project>/session-state.md lightly: status/progress/branch; Current Focus +
next state; compress history (archive verbose detail). Optional light fields only when needed:
pending_gate, last_transition, run_id (see phase-return). After merge: valid review
evidence + compound disposition before advancing top-level NEXT pointer; close-run ledger
row per runs-ledger.md.
Cross-session / multi-agent pause (optional): if stopping mid-unit for another agent or
CLI, emit handoff_package per @workflow references/handoff-package.md. Default remains
same-session drive — do not emit-and-stop after plan by default.
What /continue does not do
- Does not invent a next unit or NEXT pointer (unlisted / fatigue / residual-only).
- Does not hard-stop solely because a named unit lacks a planning directory.
- Does not auto-author roadmaps or brainstorm seeds (stop + offer unless unit SM routes there).
- Does not author plan/requirements content — phase skills do.
- Does not treat visual plan as executable SoT or plan-approval proof.
- Does not skip review or invent review evidence; gates green ≠ reviewed.
- Does not skip compound after integrate without explicit
compound: none.
- Does not push/PR unless project push policy allows — never production promotion.
- Does not implement multi-item parallelism itself — routes to
/swarm when eligible;
does not grab items an active swarm worker owns when in unit mode.
- Does not invent a swarm wave without explicit
∥ / {wave} grouping.
- Does not free-form thrash phases without artifact/decision evidence (thrash bound).
- Does not emit end-of-loop recap on user-approval stops.
- Does not edit the skill corpus mid-loop — process gaps → process memory + skill-source
/skills:evolve when available (else upstream escalate; see references/soft-checks.md).
- Does not invent NEXT from open PM backlog scrape (PM queue only with conventions filter).
Related
@workflow — family contracts; bare /workflow → this skill’s loop@workflow:setup — conventions.md, planning root, runs scaffold@workflow:roadmap — → / ∥ / ⚠ / NEXT maps continue consumes@workflow:brainstorm · refine · plan · execute · review · compound/swarm · /swarm:continue · /swarm:setup — parallel executor; override entry/skills:evolve — skill-source only; mutates process IP from detected gaps (not published to consumer projects)@superpowers:finishing-a-development-branch — integrate decision after clean review
