@ai-is-gonna/get-tasks-done 0.2.0

package/get-tasks-done/workflows/note.md

@@ -0,0 +1,158 @@
+<purpose>
+Zero-friction idea capture. One Write call, one confirmation line. No questions, no prompts.
+
+**Text mode (`workflow.text_mode: true` in config or `--text` flag):** Set `TEXT_MODE=true` if `--text` is present in `$ARGUMENTS` OR `text_mode` from init JSON is `true`. When TEXT_MODE is active, replace every `AskUserQuestion` call with a plain-text numbered list and ask the user to type their choice number. This is required for non-Claude runtimes (OpenAI Codex, Gemini CLI, etc.) where `AskUserQuestion` is not available.
+Runs inline — no Task, no AskUserQuestion, no Bash.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="storage_format">
+**Note storage format.**
+
+Notes are stored as individual markdown files:
+
+- **Project scope**: `.planning/notes/{YYYY-MM-DD}-{slug}.md` — used when `.planning/` exists in cwd
+- **Global scope**: `~/.claude/notes/{YYYY-MM-DD}-{slug}.md` — fallback when no `.planning/`, or when `--global` flag is present
+
+Each note file:
+
+```markdown
+---
+date: "YYYY-MM-DD HH:mm"
+promoted: false
+---
+
+{note text verbatim}
+```
+
+**`--global` flag**: Strip `--global` from anywhere in `$ARGUMENTS` before parsing. When present, force global scope regardless of whether `.planning/` exists.
+
+**Important**: Do NOT create `.planning/` if it doesn't exist. Fall back to global scope silently.
+</step>
+
+<step name="parse_subcommand">
+**Parse subcommand from $ARGUMENTS (after stripping --global).**
+
+| Condition | Subcommand |
+|-----------|------------|
+| Arguments are exactly `list` (case-insensitive) | **list** |
+| Arguments are exactly `promote <N>` where N is a number | **promote** |
+| Arguments are empty (no text at all) | **list** |
+| Anything else | **append** (the text IS the note) |
+
+**Critical**: `list` is only a subcommand when it's the ENTIRE argument. `/gtd-note list of groceries` saves a note with text "list of groceries". Same for `promote` — only a subcommand when followed by exactly one number.
+</step>
+
+<step name="append">
+**Subcommand: append — create a timestamped note file.**
+
+1. Determine scope (project or global) per storage format above
+2. Ensure the notes directory exists (`.planning/notes/` or `~/.claude/notes/`)
+3. Generate slug: first ~4 meaningful words of the note text, lowercase, hyphen-separated (strip articles/prepositions from the start)
+4. Generate filename: `{YYYY-MM-DD}-{slug}.md`
+   - If a file with that name already exists, append `-2`, `-3`, etc.
+5. Write the file with frontmatter and note text (see storage format)
+6. Confirm with exactly one line: `Noted ({scope}): {note text}`
+   - Where `{scope}` is "project" or "global"
+
+**Constraints:**
+- **Never modify the note text** — capture verbatim, including typos
+- **Never ask questions** — just write and confirm
+- **Timestamp format**: Use local time, `YYYY-MM-DD HH:mm` (24-hour, no seconds)
+</step>
+
+<step name="list">
+**Subcommand: list — show notes from both scopes.**
+
+1. Glob `.planning/notes/*.md` (if directory exists) — project notes
+2. Glob `~/.claude/notes/*.md` (if directory exists) — global notes
+3. For each file, read frontmatter to get `date` and `promoted` status
+4. Exclude files where `promoted: true` from active counts (but still show them, dimmed)
+5. Sort by date, number all active entries sequentially starting at 1
+6. If total active entries > 20, show only the last 10 with a note about how many were omitted
+
+**Display format:**
+
+```
+Notes:
+
+Project (.planning/notes/):
+  1. [2026-02-08 14:32] refactor the hook system to support async validators
+  2. [promoted] [2026-02-08 14:40] add rate limiting to the API endpoints
+  3. [2026-02-08 15:10] consider adding a --dry-run flag to build
+
+Global (~/.claude/notes/):
+  4. [2026-02-08 10:00] cross-project idea about shared config
+
+{count} active note(s). Use `/gtd-note promote <N>` to convert to a todo.
+```
+
+If a scope has no directory or no entries, show: `(no notes)`
+</step>
+
+<step name="promote">
+**Subcommand: promote — convert a note into a todo.**
+
+1. Run the **list** logic to build the numbered index (both scopes)
+2. Find entry N from the numbered list
+3. If N is invalid or refers to an already-promoted note, tell the user and stop
+4. **Requires `.planning/` directory** — if it doesn't exist, warn: "Todos require a GTD project. Run `/gtd:new-project` to initialize one."
+5. Ensure `.planning/todos/pending/` directory exists
+6. Generate todo ID: `{NNN}-{slug}` where NNN is the next sequential number (scan both `.planning/todos/pending/` and `.planning/todos/completed/` for the highest existing number, increment by 1, zero-pad to 3 digits) and slug is the first ~4 meaningful words of the note text
+7. Extract the note text from the source file (body after frontmatter)
+8. Create `.planning/todos/pending/{id}.md`:
+
+```yaml
+---
+title: "{note text}"
+status: pending
+priority: P2
+source: "promoted from /gtd-note"
+created: {YYYY-MM-DD}
+theme: general
+---
+
+## Goal
+
+{note text}
+
+## Context
+
+Promoted from quick note captured on {original date}.
+
+## Acceptance Criteria
+
+- [ ] {primary criterion derived from note text}
+```
+
+9. Mark the source note file as promoted: update its frontmatter to `promoted: true`
+10. Confirm: `Promoted note {N} to todo {id}: {note text}`
+</step>
+
+</process>
+
+<edge_cases>
+1. **"list" as note text**: `/gtd-note list of things` saves note "list of things" (subcommand only when `list` is the entire arg)
+2. **No `.planning/`**: Falls back to global `~/.claude/notes/` — works in any directory
+3. **Promote without project**: Warns that todos require `.planning/`, suggests `/gtd:new-project`
+4. **Large files**: `list` shows last 10 when >20 active entries
+5. **Duplicate slugs**: Append `-2`, `-3` etc. to filename if slug already used on same date
+6. **`--global` position**: Stripped from anywhere — `--global my idea` and `my idea --global` both save "my idea" globally
+7. **Promote already-promoted**: Tell user "Note {N} is already promoted" and stop
+8. **Empty note text after stripping flags**: Treat as `list` subcommand
+</edge_cases>
+
+<success_criteria>
+- [ ] Append: Note file written with correct frontmatter and verbatim text
+- [ ] Append: No questions asked — instant capture
+- [ ] List: Both scopes shown with sequential numbering
+- [ ] List: Promoted notes shown but dimmed
+- [ ] Promote: Todo created with correct format
+- [ ] Promote: Source note marked as promoted
+- [ ] Global fallback: Works when no `.planning/` exists
+</success_criteria>

package/get-tasks-done/workflows/orchestrate-tasks.md

@@ -0,0 +1,209 @@
+<purpose>
+Coordinate multiple exported GitHub task issues through one bulk execution
+branch and one final comprehensive PR.
+</purpose>
+
+<boundary>
+The orchestrator may create or resume an orchestration manifest, create and push
+a bulk branch, claim selected child task issues, spawn `gtd-task-executor` in
+task worktrees, open task PRs into the bulk branch, comment review findings on
+task PRs, squash accepted task PRs into the bulk branch, and open one final PR
+from the bulk branch to the default branch.
+
+Forbidden:
+- Do not run a mutating `orchestrate-tasks` helper command before the Start
+  Gate dry-run has passed.
+- Do not spawn an executor before the pre-agent reviewability gate passes.
+- Do not spawn an executor for checkpoint gates.
+- Do not close child task issues from task PRs.
+- Do not put task issue closing keywords in task PR titles, bodies, commits, or
+  squash commit messages.
+- Do not store full executor transcripts or long validation logs locally; use PR
+  comments/reviews and keep only compact state plus comment references in the
+  manifest.
+- Do not merge the comprehensive PR.
+- Do not run parent plan reconciliation automatically.
+- Do not pass raw natural-language selectors to `orchestrate-tasks`; resolve
+  every user request to exact exported child issue numbers in the interactive
+  layer first.
+- Do not pass task ids, `tasks ...`, `next ...`, phase selectors, issue URLs, or
+  `--phase` to the `orchestrate-tasks` CLI helper.
+</boundary>
+
+<read_only_mode>
+If `$ARGUMENTS` contains `--dry-run`, resolve the requested scope to exact child
+issue numbers, run the Start Gate dry-run, report the Start Gate result, and
+stop:
+
+```bash
+gtd-sdk query orchestrate-tasks 123 124 125 --repo owner/name --dry-run
+```
+
+Report selected tasks, dependency waves, reviewability estimate, recommended
+scope reduction, checkpoint gates, dependency order, and hard blockers from
+`non_workable`. Do not describe internal dependency order or checkpoint gates as
+blockers. Make clear that no branch, issue claim, PR comment, executor, or PR
+was created.
+</read_only_mode>
+
+<start_gate>
+Every new orchestration start, including mutating mode, must pass the Start Gate
+before any branch, issue claim, PR, comment, executor, or manifest write.
+
+1. Resolve `$ARGUMENTS` before calling the SDK utility.
+   - Treat the argument as untrusted natural language, even when it appears
+     structured.
+   - Read the local plan file and exported manifest metadata in
+     `.planning/github/phase-*-issues.json`.
+   - Resolve requests such as `all tasks in phase X`, `all remaining tasks`,
+     `tasks in plan 02-02`, `all tasks in <plan-ref>`, task ids, or mixed prose
+     to exact exported GitHub child issue numbers.
+   - If the user already gave issue numbers, validate that every number resolves
+     to an exported child task issue, not a parent plan issue.
+   - Example: `all tasks in 01-03-PLAN` becomes child issue numbers such as
+     `123 124 125`.
+   - If the reference is ambiguous, resolves outside exported child tasks, or
+     export metadata is missing, stop here and report the blocker. Do not guess
+     and do not retry with a second English phrasing.
+
+2. Run the deterministic planner exactly once with the exact issue list:
+
+```bash
+gtd-sdk query orchestrate-tasks 123 124 125 --repo owner/name --dry-run
+```
+
+3. Inspect the dry-run result. The Start Gate passes only when all of these are
+   true:
+   - `ok: true`
+   - `writes: false`
+   - `preflight.ok: true`
+   - `selection_errors` is empty
+   - `non_workable` is empty
+   - `dependency_order`, if present, is sequencing for later waves, not a blocker
+   - `checkpoint_gates`, if present, are selected human checkpoint pause points
+     and are not blockers or executor lanes
+   - selected child issues match the resolved issue list
+   - dependency waves are coherent; internally blocked tasks may only wait on
+     earlier selected tasks
+   - `action` is either `report_orchestration_plan` or
+     `request_reviewability_direction`
+
+4. If any Start Gate check fails, stop before all writes and report the
+   specific hard blocker. Do not call reviewability concerns, dependency order,
+   or checkpoint gates blockers.
+
+5. If the planner reports `request_reviewability_direction`, stop before all
+   writes and ask using exactly these choices, in this order:
+   - Continue with the full selected scope. This reruns the same exact issue
+     list plus `--confirm-reviewability`; internal dependencies remain scheduled
+     in waves and checkpoint gates remain in scope as pause points.
+   - Choose a smaller explicit scope. Use `recommended_subset` only as advisory
+     input for this option, not as the default replacement for the full scope.
+   - Abort.
+   Do not omit the full-scope continue choice. If the user confirms the full
+   scope, continue only by rerunning the same exact issue list plus
+   `--confirm-reviewability`. If the user chooses a smaller scope, resolve it to
+   exact child issues and rerun the Start Gate from step 1.
+</start_gate>
+
+<execution_flow>
+1. Run the Start Gate. If `$ARGUMENTS` contains `--dry-run`, report the Start
+   Gate result and stop.
+
+2. If the Start Gate passes with `report_orchestration_plan`, start
+   orchestration by rerunning the same exact issue list without `--dry-run`:
+
+```bash
+gtd-sdk query orchestrate-tasks 123 124 125 --repo owner/name
+```
+
+3. If the user explicitly confirmed the oversized scope, start by rerunning the
+   same exact issue list with `--confirm-reviewability`:
+
+```bash
+gtd-sdk query orchestrate-tasks 123 124 125 --repo owner/name --confirm-reviewability
+```
+
+4. Do not treat `--allow-partial` as a startup decision. Partial finalization
+   remains a later resume/finalization concern after rejected or skipped tasks
+   are known and still requires explicit confirmation with `--confirm-partial`.
+5. Do not resume unless the user explicitly provides an orchestration id or asks
+   to resume.
+6. Create the bulk branch only after the Start Gate passes. Resume an existing
+   orchestration only through an explicit resume request.
+   The default executor backend is agent-managed; the deterministic SDK helper
+   prepares the bulk branch, manifest, claims, and agent lane contexts. Do not
+   assume a local `gtd-task-executor` binary exists unless the user explicitly
+   configured the command executor backend and preflight verified it.
+7. If the helper returns `agent_lanes_required`, spawn the listed
+   `gtd-task-executor` agents using model `gpt-5.4-mini`. Follow the returned
+   waves exactly: later waves may depend on earlier selected tasks, while tasks
+   inside one wave can run in parallel up to the concurrency cap. The listed
+   lanes never include checkpoint gates.
+8. If the helper returns `human_checkpoint_required`, stop and ask the human to
+   complete the checkpoint instructions in the GitHub issue, then close that
+   issue. Issue closure is the only hard resume signal; comments are optional
+   audit evidence and must not block resume.
+9. Each lane creates/reuses a task branch from the bulk branch and spawns a
+   fresh `gtd-task-executor` context for that task. On rework, do not paste long
+   inline feedback; write exact findings to the PR and spawn a fresh executor
+   that reads those comments/reviews/checks.
+10. After an executor returns commit evidence, the orchestrator pushes the task
+   branch and opens or updates the task PR with base set to the bulk branch. The
+   body must use `Refs #issue`, not closing keywords.
+11. Before accepting a task PR, validate the exact merge result against the
+   current bulk branch:
+   - PR base is the bulk branch.
+   - PR title/body/commits/squash message contain no task closing keywords.
+   - Diff stays in scope and avoids GTD completion artifacts.
+   - Task validation contract passes.
+   - Required GitHub checks pass, or missing task-PR CI is recorded and local
+     fallback validation passes.
+   - The result still fits the full selected task set and parent plan intent.
+12. Track findings with PR comments or reviews. The manifest stores only status,
+   decisions, and comment references.
+13. Accept by squash-merging the task PR into the bulk branch. Require changes
+   by commenting and relaunching a fresh executor. Reject unsafe or repeatedly
+   failing work and keep the child issue open.
+14. After all selected implementation tasks are accepted and all checkpoint
+   gates are resolved, run final integration validation on
+   the whole bulk branch. If the failure is not attributable to one task, stop
+   and ask for human direction.
+15. Open the comprehensive PR from the bulk branch to the default branch. This
+    PR is the only PR that contains `Closes #child_issue` lines, and those lines
+    are only for accepted implementation tasks. Never close checkpoint issues
+    from the final PR.
+16. When checkpoint-paused output includes `user_next_step`, present that
+    message to the user instead of any helper command. The user-facing action is
+    to complete the checkpoint issue, close it, and tell the agent to continue;
+    the agent resumes the recorded orchestration internally.
+17. If an internal resume still reports `human_checkpoint_pending`, the
+    checkpoint issue is still open. If it reports `human_checkpoint_resolved`,
+    the checkpoint issue was closed and orchestration can continue internally.
+18. After the comprehensive PR merges, resume the recorded orchestration
+    internally. The resume sync may update compact orchestration state and child
+    task labels, then print ready parent-plan reconciliation commands. Do not create
+`*-SUMMARY.md`, `.planning/STATE.md`, `.planning/ROADMAP.md`, or requirements
+completion metadata from `orchestrate-tasks`; run the reported
+`work-task-issue --reconcile --execute` command for each ready parent plan.
+</execution_flow>
+
+<technical_lead_review>
+Provide technical-lead review, not just task execution. Review each PR against
+the whole selected task set: functional intent, duplicated solutions, shared
+workflow breakage, dependency assumptions, generated artifact drift, migrations,
+manual acceptance criteria, and final reviewability for one developer.
+</technical_lead_review>
+
+<output_contract>
+Report:
+- orchestration id and bulk branch
+- selected task issues and dependency waves
+- reviewability gate result and any user decision
+- task PR URLs and decisions
+- validation findings that remain open, linked by PR comment
+- final comprehensive PR URL, or the blocking reason if no final PR was opened
+- `user_next_step.message` for checkpoint pauses; do not ask the user to run
+  internal helper commands
+- ready parent-plan reconciliation commands after a merged final PR
+</output_contract>

package/get-tasks-done/workflows/pause-work.md

@@ -0,0 +1,243 @@
+<purpose>
+Create structured `.planning/HANDOFF.json` and `.continue-here.md` handoff files to preserve complete work state across sessions. The JSON provides machine-readable state for `/gtd:resume-work`; the markdown provides human-readable context.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="detect">
+## Context Detection
+
+Determine what kind of work is being paused and set the handoff destination accordingly:
+
+```bash
+# Check for active phase
+phase=$(( ls -lt .planning/phases/*/PLAN.md 2>/dev/null || true ) | head -1 | grep -oP 'phases/\K[^/]+' || true)
+
+# Check for active spike
+spike=$(( ls -lt .planning/spikes/*/SPIKE.md .planning/spikes/*/DESIGN.md .planning/spikes/*/README.md 2>/dev/null || true ) | head -1 | grep -oP 'spikes/\K[^/]+' || true)
+
+# Check for active sketch
+sketch=$(( ls -lt .planning/sketches/*/README.md .planning/sketches/*/index.html 2>/dev/null || true ) | head -1 | grep -oP 'sketches/\K[^/]+' || true)
+
+# Check for active deliberation
+deliberation=$(ls .planning/deliberations/*.md 2>/dev/null | head -1 || true)
+```
+
+- **Phase work**: active phase directory → handoff to `.planning/phases/XX-name/.continue-here.md`
+- **Spike work**: active spike directory or spike-related files (no active phase) → handoff to `.planning/spikes/SPIKE-NNN/.continue-here.md` (create directory if needed)
+- **Sketch work**: active sketch directory (no active phase/spike) → handoff to `.planning/sketches/.continue-here.md`
+- **Deliberation work**: active deliberation file (no phase/spike/sketch) → handoff to `.planning/deliberations/.continue-here.md`
+- **Research work**: research notes exist but no phase/spike/sketch/deliberation → handoff to `.planning/.continue-here.md`
+- **Default**: no detectable context → handoff to `.planning/.continue-here.md`, note the ambiguity in `<current_state>`
+
+If phase is detected, proceed with phase handoff path. Otherwise use the first matching non-phase path above.
+</step>
+
+<step name="gather">
+**Collect complete state for handoff:**
+
+1. **Current position**: Which phase, which plan, which task
+2. **Work completed**: What got done this session
+3. **Work remaining**: What's left in current plan/phase
+4. **Decisions made**: Key decisions and rationale
+5. **Blockers/issues**: Anything stuck
+6. **Human actions pending**: Things that need manual intervention (MCP setup, API keys, approvals, manual testing)
+7. **Background processes**: Any running servers/watchers that were part of the workflow
+8. **Files modified**: What's changed but not committed
+9. **Blocking constraints**: Anti-patterns or methodological failures encountered during this session that a resuming agent MUST be aware of before proceeding. Only include items discovered through actual failure — not warnings or predictions. Assign each constraint a `severity`:
+   - `blocking` — The resuming agent MUST demonstrate understanding before proceeding. The discuss-phase and task orchestration flow workflows will enforce a mandatory understanding check.
+   - `advisory` — Important context but does not gate resumption.
+
+Ask user for clarifications if needed via conversational questions.
+
+**Also inspect SUMMARY.md files for false completions:**
+```bash
+# Check for placeholder content in existing summaries
+grep -l "To be filled\|placeholder\|TBD" .planning/phases/*/*.md 2>/dev/null || true
+```
+Report any summaries with placeholder content as incomplete items.
+</step>
+
+<step name="write_structured">
+**Write structured handoff to `.planning/HANDOFF.json`:**
+
+```bash
+timestamp=$(gtd-sdk query current-timestamp full --raw)
+```
+
+```json
+{
+  "version": "1.0",
+  "timestamp": "{timestamp}",
+  "phase": "{phase_number}",
+  "phase_name": "{phase_name}",
+  "phase_dir": "{phase_dir}",
+  "plan": {current_plan_number},
+  "task": {current_task_number},
+  "total_tasks": {total_task_count},
+  "status": "paused",
+  "completed_tasks": [
+    {"id": 1, "name": "{task_name}", "status": "done", "commit": "{short_hash}"},
+    {"id": 2, "name": "{task_name}", "status": "done", "commit": "{short_hash}"},
+    {"id": 3, "name": "{task_name}", "status": "in_progress", "progress": "{what_done}"}
+  ],
+  "remaining_tasks": [
+    {"id": 4, "name": "{task_name}", "status": "not_started"},
+    {"id": 5, "name": "{task_name}", "status": "not_started"}
+  ],
+  "blockers": [
+    {"description": "{blocker}", "type": "technical|human_action|external", "workaround": "{if any}"}
+  ],
+  "human_actions_pending": [
+    {"action": "{what needs to be done}", "context": "{why}", "blocking": true}
+  ],
+  "decisions": [
+    {"decision": "{what}", "rationale": "{why}", "phase": "{phase_number}"}
+  ],
+  "uncommitted_files": [],
+  "next_action": "{specific first action when resuming}",
+  "context_notes": "{mental state, approach, what you were thinking}"
+}
+```
+</step>
+
+<step name="write">
+**Write handoff to the path determined in the detect step** (e.g. `.planning/phases/XX-name/.continue-here.md`, `.planning/spikes/SPIKE-NNN/.continue-here.md`, or `.planning/.continue-here.md`):
+
+```markdown
+---
+context: [phase|spike|sketch|deliberation|research|default]
+phase: XX-name
+task: 3
+total_tasks: 7
+status: in_progress
+last_updated: [timestamp from current-timestamp]
+---
+
+# BLOCKING CONSTRAINTS — Read Before Anything Else
+
+> These are not suggestions. Each constraint below was discovered through failure.
+> Acknowledge each one explicitly before proceeding.
+
+- [ ] CONSTRAINT: [name] — [what it is] — [structural mitigation required]
+
+**Do not proceed until all boxes are checked.**
+
+_If no constraints have been identified yet, remove this section._
+
+## Critical Anti-Patterns
+
+| Pattern | Description | Severity | Prevention Mechanism |
+|---------|-------------|----------|---------------------|
+| [pattern name] | [what it is and how it manifested] | blocking | [structural step that prevents recurrence — not acknowledgment] |
+| [pattern name] | [what it is and how it manifested] | advisory | [guidance for avoiding it] |
+
+**Severity values:** `blocking` — resuming agent must pass understanding check before proceeding. `advisory` — important context, does not gate resumption.
+
+_Remove rows that do not apply. The discuss-phase and task orchestration flow workflows parse this table and enforce a mandatory understanding check for any `blocking` rows._
+
+<current_state>
+[Where exactly are we? Immediate context]
+</current_state>
+
+<completed_work>
+
+Completed Tasks:
+- Task 1: [name] - Done
+- Task 2: [name] - Done
+- Task 3: [name] - In progress, [what's done]
+</completed_work>
+
+<remaining_work>
+
+- Task 3: [what's left]
+- Task 4: Not started
+- Task 5: Not started
+</remaining_work>
+
+<decisions_made>
+
+- Decided to use [X] because [reason]
+- Chose [approach] over [alternative] because [reason]
+</decisions_made>
+
+<blockers>
+- [Blocker 1]: [status/workaround]
+</blockers>
+
+## Required Reading (in order)
+<!-- List documents the resuming agent must read before acting -->
+1. [document] — [why it matters]
+1. `.planning/METHODOLOGY.md` (if it exists) — project analytical lenses; apply before any assumption analysis
+
+## Critical Anti-Patterns (do NOT repeat these)
+<!-- Mistakes discovered this session that must be structurally avoided -->
+- [ANTI-PATTERN]: [what it is] → [structural mitigation]
+
+## Infrastructure State
+<!-- Running services, external state, environment specifics -->
+- [service/env]: [current state]
+
+## Pre-Execution Critique Required
+<!-- Fill in ONLY if pausing between design and execution (e.g. spike design done, not yet run) -->
+- Design artifact: [path]
+- Critique focus: [key questions the critic should probe]
+- Gate: Do NOT begin execution until critique is complete and design is revised
+
+<context>
+[Mental state, what were you thinking, the plan]
+</context>
+
+<next_action>
+Start with: [specific first action when resuming]
+</next_action>
+```
+
+Be specific enough for a fresh Claude to understand immediately.
+
+Use `current-timestamp` for last_updated field. You can use init todos (which provides timestamps) or call directly:
+```bash
+timestamp=$(gtd-sdk query current-timestamp full --raw)
+```
+</step>
+
+<step name="commit">
+```bash
+gtd-sdk query commit "wip: [context-name] paused at [X]/[Y]" --files [handoff-path] .planning/HANDOFF.json
+```
+</step>
+
+<step name="confirm">
+```
+✓ Handoff created:
+  - .planning/HANDOFF.json (structured, machine-readable)
+  - [handoff-path] (human-readable)
+
+Current state:
+
+- Context: [phase|spike|deliberation|research]
+- Location: [XX-name or SPIKE-NNN]
+- Task: [X] of [Y]
+- Status: [in_progress/blocked]
+- Blockers: [count] ({human_actions_pending count} need human action)
+- Committed as WIP
+
+To resume: /gtd:resume-work
+
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Context detected (phase/spike/deliberation/research/default)
+- [ ] .continue-here.md created at correct path for detected context
+- [ ] Required Reading, Anti-Patterns, and Infrastructure State sections filled
+- [ ] Pre-Execution Critique section filled if pausing between design and execution
+- [ ] Committed as WIP
+- [ ] User knows location and how to resume
+</success_criteria>