@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/workflows/quick.md

@@ -0,0 +1,845 @@
+<purpose>
+Execute small, ad-hoc tasks with DGS guarantees (atomic commits, STATE.md tracking). Quick mode spawns dgs-planner (quick mode) + dgs-executor(s), tracks tasks in `${quick_dir}/`, and updates STATE.md's "Quick Tasks Completed" table.
+
+With `--fast` flag: the lightest DGS path. No subagents — the orchestrator makes edits directly, infers a conventional commit message, and commits atomically. Skips planner/executor entirely. Shares the same ID counter as regular quick tasks.
+
+With `--fast --dry-run`: shows proposed changes as a diff before committing. User can apply or discard.
+
+With `--discuss` flag: lightweight discussion phase before planning. Surfaces assumptions, clarifies gray areas, captures decisions in CONTEXT.md so the planner treats them as locked.
+
+With `--full` flag: enables plan-checking (max 2 iterations) and post-execution verification for quality guarantees without full milestone ceremony.
+
+Flags are composable: `--discuss --full` gives discussion + plan-checking + verification. `--fast` is exclusive — it cannot be combined with `--discuss` or `--full`.
+</purpose>
+
+<context_tier>planning</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+**Step 1: Parse arguments and get task description**
+
+Parse `$ARGUMENTS` for:
+- `--fast` flag → store as `$FAST_MODE` (true/false)
+- `--dry-run` flag → store as `$DRY_RUN` (true/false)
+- `--full` flag → store as `$FULL_MODE` (true/false)
+- `--discuss` flag → store as `$DISCUSS_MODE` (true/false)
+- Remaining text (after stripping all flags) → use as `$DESCRIPTION` if non-empty
+
+If `$DESCRIPTION` is empty after parsing, prompt user interactively:
+
+```
+AskUserQuestion(
+  header: "Quick Task",
+  question: "What do you want to do?",
+  followUp: null
+)
+```
+
+Store response as `$DESCRIPTION`.
+
+If still empty, re-prompt: "Please provide a task description."
+
+Display banner based on active flags:
+
+If `$FAST_MODE`:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS > FAST
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ ${DESCRIPTION}
+```
+
+If `$DISCUSS_MODE` and `$FULL_MODE`:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► QUICK TASK (DISCUSS + FULL)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Discussion + plan checking + verification enabled
+```
+
+If `$DISCUSS_MODE` only:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► QUICK TASK (DISCUSS)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Discussion phase enabled — surfacing gray areas before planning
+```
+
+If `$FULL_MODE` only:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► QUICK TASK (FULL MODE)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Plan checking + verification enabled
+```
+
+---
+
+**Step 2: Initialize**
+
+```bash
+INIT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" init quick "$DESCRIPTION")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON for: `planner_model`, `executor_model`, `checker_model`, `verifier_model`, `commit_docs`, `quick_id`, `slug`, `date`, `timestamp`, `quick_dir`, `task_dir`, `roadmap_exists`, `planning_exists`, `author`.
+
+Load planning-tier context files:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier planning --raw 2>/dev/null)
+```
+
+**If `roadmap_exists` is false:**
+- **If `$FAST_MODE`:** Do NOT error. Set `$TRACKING_SKIPPED = true`. Display: `(tracking skipped — no STATE.md)`
+- **If NOT `$FAST_MODE`:** Error — Quick mode requires an active project with ROADMAP.md. Run `/dgs:new-project` first.
+
+Quick tasks can run mid-phase - validation only checks ROADMAP.md exists, not phase status.
+
+---
+
+**Fast Path (when `$FAST_MODE` is true):**
+
+If `$FAST_MODE` is false, skip this entire block and continue to Step 3.
+
+When `$FAST_MODE` is true, execute this entire block and then end the workflow. Do NOT execute Steps 3 through 8.
+
+**F1. Scope pre-check**
+
+Analyze `$DESCRIPTION` to estimate how many files and lines will be affected. Consider:
+- Does the description mention multiple files? ("update all config files", "change imports across...")
+- Does it suggest large structural changes? ("refactor the module", "rewrite the handler")
+- Is it clearly trivial? ("fix typo", "update port number", "add missing import")
+
+If the estimate suggests >3 files or >30 lines of changes:
+```
+AskUserQuestion(
+  header: "Scope Warning",
+  question: "This looks like it might affect more than 3 files or 30 lines. Continue as fast, or switch to /dgs:quick for more control?",
+  options: [
+    { label: "Continue as fast", description: "Proceed with direct edits" },
+    { label: "Switch to /dgs:quick", description: "Re-invoke with planner + executor for this description" }
+  ]
+)
+```
+
+If user chooses "Switch to /dgs:quick": re-invoke the quick workflow from Step 1 with `$FAST_MODE = false` and `$DESCRIPTION` preserved. Display:
+```
+Switching to /dgs:quick...
+```
+Then continue from Step 3 as normal quick mode (skip the rest of the fast path).
+
+**F2. Make edits**
+
+Read the relevant file(s) based on `$DESCRIPTION`, make the requested changes directly using Read/Edit/Write tools. No planner, no executor — the orchestrator acts as the implementer.
+
+If `$DRY_RUN`:
+  After making edits but BEFORE committing, show the diff:
+  ```bash
+  git diff
+  ```
+  Then ask:
+  ```
+  AskUserQuestion(
+    header: "Dry Run — Proposed Changes",
+    question: "Apply these changes?",
+    options: [
+      { label: "Yes, apply and commit", description: "Commit these changes" },
+      { label: "No, discard", description: "Revert all changes" }
+    ]
+  )
+  ```
+  If user chooses "No, discard":
+    ```bash
+    git checkout -- .
+    ```
+    Display: "Changes discarded."
+    Skip to completion output with message: "Dry run complete — no changes applied."
+    End workflow.
+
+**F3. Post-edit scope check**
+
+After edits are made, check actual scope:
+```bash
+git diff --stat
+```
+
+Parse the output to count:
+- Number of files changed
+- Total lines added + deleted
+
+If files > 3 OR lines > 30:
+```
+AskUserQuestion(
+  header: "Scope Warning",
+  question: "Changes affect ${N} files and ${M} lines — exceeds fast threshold (3 files / 30 lines). Continue committing, or switch to /dgs:quick?",
+  options: [
+    { label: "Continue and commit", description: "Commit these changes as-is" },
+    { label: "Switch to /dgs:quick", description: "Stage changes and continue with planner review" }
+  ]
+)
+```
+
+If user chooses "Switch to /dgs:quick": Leave changes staged, re-invoke quick workflow from Step 5 (planner) with the edits already in place. The planner should account for changes already made.
+
+**F4. Infer commit message**
+
+Analyze the description and the actual changes (`git diff`) to infer a conventional commit message:
+- Prefix: infer from description keywords and file types:
+  - "fix", "bug", "broken", "wrong" -> `fix:`
+  - "add", "create", "new", "implement" -> `feat:`
+  - "doc", "readme", "comment", "jsdoc" -> `docs:`
+  - "refactor", "clean", "reorganize" -> `refactor:`
+  - "test", "spec", "assert" -> `test:`
+  - "style", "format", "indent", "whitespace" -> `style:`
+  - Default/ambiguous -> `chore:`
+- Scope field (optional): infer from filename or directory if it adds clarity. E.g., `fix(config):` for changes to config files.
+- Message body: concise description of the change (not the user's raw description, but a clean conventional commit message).
+
+Commit message is NOT shown to user before committing — just commit silently.
+
+**F5. Commit**
+
+```bash
+git add -A
+git commit -m "${commit_message}"
+```
+
+Get the short hash:
+```bash
+git rev-parse --short HEAD
+```
+
+Store as `$COMMIT_HASH`.
+
+**F6. Update STATE.md (skip if `$TRACKING_SKIPPED`)**
+
+If `$TRACKING_SKIPPED` is true, skip this step.
+
+Otherwise, update STATE.md with the fast task row. Use the SAME format as regular quick tasks (shared table):
+
+Read STATE.md. Check for `### Quick Tasks Completed` section.
+
+If section doesn't exist, create it after `### Blockers/Concerns`:
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Directory |
+|---|-------------|------|--------|-----------|
+```
+
+Append row:
+```markdown
+| ${quick_id} | ${DESCRIPTION} | ${date} | ${COMMIT_HASH} | fast |
+```
+
+Note: For fast tasks, the Directory column shows `fast` instead of a directory link (since fast tasks don't create planning directories).
+
+Update "Last activity" line:
+```
+Last activity: ${date} - Completed fast task ${quick_id}: ${DESCRIPTION}
+```
+
+Use Edit tool to make these changes atomically.
+
+**F6b. Archive excess rows (skip if `$TRACKING_SKIPPED`)**
+
+After adding the row, trigger archival to keep the table within 20 rows:
+
+```bash
+ARCHIVE_RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" state archive-quick-tasks --raw 2>/dev/null)
+```
+
+If archival occurred (result contains `"archived": true`), `.planning/quick/HISTORY.md` was created or updated. Both STATE.md and HISTORY.md will be committed together in the next step.
+
+**F6c. Commit tracking (fast path only)**
+
+Commit STATE.md and HISTORY.md together so archival data is persisted:
+
+```bash
+git add "${state_path}"
+if [ -f "${project_root}/quick/HISTORY.md" ]; then
+  git add "${project_root}/quick/HISTORY.md"
+fi
+git commit -m "docs(quick-${quick_id}): track fast task" 2>/dev/null || true
+```
+
+The `|| true` handles the case where nothing changed (e.g., STATE.md wasn't modified).
+
+**F7. Output**
+
+Display minimal one-liner:
+```
+Done: ${commit_message} [${COMMIT_HASH}]
+```
+
+If `$TRACKING_SKIPPED`:
+```
+Done: ${commit_message} [${COMMIT_HASH}]
+(tracking skipped — no STATE.md)
+```
+
+End workflow. Do NOT proceed to Steps 3-8 of regular quick path.
+
+---
+
+**Step 3: Create task directory**
+
+If `$FAST_MODE`: skip — already handled by fast path above.
+
+```bash
+mkdir -p "${task_dir}"
+```
+
+---
+
+**Step 4: Create quick task directory**
+
+Create the directory for this quick task:
+
+```bash
+QUICK_DIR="${project_root}/quick/${quick_id}-${slug}"
+mkdir -p "$QUICK_DIR"
+```
+
+Report to user:
+```
+Creating quick task ${quick_id}: ${DESCRIPTION}
+Directory: ${QUICK_DIR}
+```
+
+Store `$QUICK_DIR` for use in orchestration.
+
+---
+
+**Step 4.5: Discussion phase (only when `$DISCUSS_MODE`)**
+
+Skip this step entirely if NOT `$DISCUSS_MODE`.
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► DISCUSSING QUICK TASK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Surfacing gray areas for: ${DESCRIPTION}
+```
+
+**4.5a. Identify gray areas**
+
+Analyze `$DESCRIPTION` to identify 2-4 gray areas — implementation decisions that would change the outcome and that the user should weigh in on.
+
+Use the domain-aware heuristic to generate phase-specific (not generic) gray areas:
+- Something users **SEE** → layout, density, interactions, states
+- Something users **CALL** → responses, errors, auth, versioning
+- Something users **RUN** → output format, flags, modes, error handling
+- Something users **READ** → structure, tone, depth, flow
+- Something being **ORGANIZED** → criteria, grouping, naming, exceptions
+
+Each gray area should be a concrete decision point, not a vague category. Example: "Loading behavior" not "UX".
+
+**4.5b. Present gray areas**
+
+```
+AskUserQuestion(
+  header: "Gray Areas",
+  question: "Which areas need clarification before planning?",
+  options: [
+    { label: "${area_1}", description: "${why_it_matters_1}" },
+    { label: "${area_2}", description: "${why_it_matters_2}" },
+    { label: "${area_3}", description: "${why_it_matters_3}" },
+    { label: "All clear", description: "Skip discussion — I know what I want" }
+  ],
+  multiSelect: true
+)
+```
+
+If user selects "All clear" → skip to Step 5 (no CONTEXT.md written).
+
+**4.5c. Discuss selected areas**
+
+For each selected area, ask 1-2 focused questions via AskUserQuestion:
+
+```
+AskUserQuestion(
+  header: "${area_name}",
+  question: "${specific_question_about_this_area}",
+  options: [
+    { label: "${concrete_choice_1}", description: "${what_this_means}" },
+    { label: "${concrete_choice_2}", description: "${what_this_means}" },
+    { label: "${concrete_choice_3}", description: "${what_this_means}" },
+    { label: "You decide", description: "Claude's discretion" }
+  ],
+  multiSelect: false
+)
+```
+
+Rules:
+- Options must be concrete choices, not abstract categories
+- Highlight recommended choice where you have a clear opinion
+- If user selects "Other" with freeform text, switch to plain text follow-up (per questioning.md freeform rule)
+- If user selects "You decide", capture as Claude's Discretion in CONTEXT.md
+- Max 2 questions per area — this is lightweight, not a deep dive
+
+Collect all decisions into `$DECISIONS`.
+
+**4.5d. Write CONTEXT.md**
+
+Write `${QUICK_DIR}/${quick_id}-CONTEXT.md` using the standard context template structure:
+
+```markdown
+# Quick Task ${quick_id}: ${DESCRIPTION} - Context
+
+**Gathered:** ${date}
+**Status:** Ready for planning
+
+<domain>
+## Task Boundary
+
+${DESCRIPTION}
+
+</domain>
+
+<decisions>
+## Implementation Decisions
+
+### ${area_1_name}
+- ${decision_from_discussion}
+
+### ${area_2_name}
+- ${decision_from_discussion}
+
+### Claude's Discretion
+${areas_where_user_said_you_decide_or_areas_not_discussed}
+
+</decisions>
+
+<specifics>
+## Specific Ideas
+
+${any_specific_references_or_examples_from_discussion}
+
+[If none: "No specific requirements — open to standard approaches"]
+
+</specifics>
+
+<canonical_refs>
+## Canonical References
+
+${any_specs_adrs_or_docs_referenced_during_discussion}
+
+[If none: "No external specs — requirements fully captured in decisions above"]
+
+</canonical_refs>
+```
+
+Note: Quick task CONTEXT.md omits `<code_context>` and `<deferred>` sections (no codebase scouting, no phase scope to defer to). Keep it lean. The `<canonical_refs>` section is included when external docs were referenced — omit it only if no external docs apply.
+
+Report: `Context captured: ${QUICK_DIR}/${quick_id}-CONTEXT.md`
+
+---
+
+**Step 5: Spawn planner (quick mode)**
+
+**If `$FULL_MODE`:** Use `quick-full` mode with stricter constraints.
+
+**If NOT `$FULL_MODE`:** Use standard `quick` mode.
+
+```
+Task(
+  prompt="
+<planning_context>
+
+**Mode:** ${FULL_MODE ? 'quick-full' : 'quick'}
+**Directory:** ${QUICK_DIR}
+**Description:** ${DESCRIPTION}
+
+<files_to_read>
+- ${state_path} (Project State)
+- ./CLAUDE.md (if exists — follow project-specific guidelines)
+${DISCUSS_MODE ? '- ' + QUICK_DIR + '/' + quick_id + '-CONTEXT.md (User decisions — locked, do not revisit)' : ''}
+</files_to_read>
+
+**Project skills:** Check .claude/skills/ or .agents/skills/ directory (if either exists) — read SKILL.md files, plans should account for project skill rules
+
+**Author:** ${author}
+
+</planning_context>
+
+<constraints>
+- Create a SINGLE plan with 1-3 focused tasks
+- Quick tasks should be atomic and self-contained
+- No research phase
+${FULL_MODE ? '- Target ~40% context usage (structured for verification)' : '- Target ~30% context usage (simple, focused)'}
+${FULL_MODE ? '- MUST generate `must_haves` in plan frontmatter (truths, artifacts, key_links)' : ''}
+${FULL_MODE ? '- Each task MUST have `files`, `action`, `verify`, `done` fields' : ''}
+</constraints>
+
+<output>
+Write plan to: ${QUICK_DIR}/${quick_id}-PLAN.md
+Return: ## PLANNING COMPLETE with plan path
+</output>
+",
+  subagent_type="dgs-planner",
+  model="{planner_model}",
+  description="Quick plan: ${DESCRIPTION}"
+)
+```
+
+After planner returns:
+1. Verify plan exists at `${QUICK_DIR}/${quick_id}-PLAN.md`
+2. Extract plan count (typically 1 for quick tasks)
+3. Report: "Plan created: ${QUICK_DIR}/${quick_id}-PLAN.md"
+
+If plan not found, error: "Planner failed to create ${quick_id}-PLAN.md"
+
+---
+
+**Step 5.5: Plan-checker loop (only when `$FULL_MODE`)**
+
+Skip this step entirely if NOT `$FULL_MODE`.
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► CHECKING PLAN
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Spawning plan checker...
+```
+
+Checker prompt:
+
+```markdown
+<verification_context>
+**Mode:** quick-full
+**Task Description:** ${DESCRIPTION}
+
+<files_to_read>
+- ${QUICK_DIR}/${quick_id}-PLAN.md (Plan to verify)
+</files_to_read>
+
+**Scope:** This is a quick task, not a full phase. Skip checks that require a ROADMAP phase goal.
+</verification_context>
+
+<check_dimensions>
+- Requirement coverage: Does the plan address the task description?
+- Task completeness: Do tasks have files, action, verify, done fields?
+- Key links: Are referenced files real?
+- Scope sanity: Is this appropriately sized for a quick task (1-3 tasks)?
+- must_haves derivation: Are must_haves traceable to the task description?
+
+Skip: cross-plan deps (single plan), ROADMAP alignment
+${DISCUSS_MODE ? '- Context compliance: Does the plan honor locked decisions from CONTEXT.md?' : '- Skip: context compliance (no CONTEXT.md)'}
+</check_dimensions>
+
+<expected_output>
+- ## VERIFICATION PASSED — all checks pass
+- ## ISSUES FOUND — structured issue list
+</expected_output>
+```
+
+```
+Task(
+  prompt=checker_prompt,
+  subagent_type="dgs-plan-checker",
+  model="{checker_model}",
+  description="Check quick plan: ${DESCRIPTION}"
+)
+```
+
+**Handle checker return:**
+
+- **`## VERIFICATION PASSED`:** Display confirmation, proceed to step 6.
+- **`## ISSUES FOUND`:** Display issues, check iteration count, enter revision loop.
+
+**Revision loop (max 2 iterations):**
+
+Track `iteration_count` (starts at 1 after initial plan + check).
+
+**If iteration_count < 2:**
+
+Display: `Sending back to planner for revision... (iteration ${N}/2)`
+
+Revision prompt:
+
+```markdown
+<revision_context>
+**Mode:** quick-full (revision)
+
+<files_to_read>
+- ${QUICK_DIR}/${quick_id}-PLAN.md (Existing plan)
+</files_to_read>
+
+**Checker issues:** ${structured_issues_from_checker}
+
+</revision_context>
+
+<instructions>
+Make targeted updates to address checker issues.
+Do NOT replan from scratch unless issues are fundamental.
+Return what changed.
+</instructions>
+```
+
+```
+Task(
+  prompt=revision_prompt,
+  subagent_type="dgs-planner",
+  model="{planner_model}",
+  description="Revise quick plan: ${DESCRIPTION}"
+)
+```
+
+After planner returns → spawn checker again, increment iteration_count.
+
+**If iteration_count >= 2:**
+
+Display: `Max iterations reached. ${N} issues remain:` + issue list
+
+Offer: 1) Force proceed, 2) Abort
+
+---
+
+**Step 6: Spawn executor**
+
+Spawn dgs-executor with plan reference:
+
+```
+Task(
+  prompt="
+Execute quick task ${quick_id}.
+
+<files_to_read>
+- ${QUICK_DIR}/${quick_id}-PLAN.md (Plan)
+- ${state_path} (Project state)
+- ./CLAUDE.md (Project instructions, if exists)
+- .claude/skills/ or .agents/skills/ (Project skills, if either exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
+</files_to_read>
+
+<constraints>
+- Execute all tasks in the plan
+- Commit each task atomically
+- Create summary at: ${QUICK_DIR}/${quick_id}-SUMMARY.md
+- Do NOT update ROADMAP.md (quick tasks are separate from planned phases)
+- Include executed_by: "${author}" in SUMMARY.md frontmatter
+</constraints>
+",
+  subagent_type="dgs-executor",
+  model="{executor_model}",
+  description="Execute: ${DESCRIPTION}"
+)
+```
+
+After executor returns:
+1. Verify summary exists at `${QUICK_DIR}/${quick_id}-SUMMARY.md`
+2. Extract commit hash from executor output
+3. Report completion status
+
+**Known Claude Code bug (classifyHandoffIfNeeded):** If executor reports "failed" with error `classifyHandoffIfNeeded is not defined`, this is a Claude Code runtime bug — not a real failure. Check if summary file exists and git log shows commits. If so, treat as successful.
+
+If summary not found, error: "Executor failed to create ${quick_id}-SUMMARY.md"
+
+Note: For quick tasks producing multiple plans (rare), spawn executors in parallel waves per execute-phase patterns.
+
+---
+
+**Step 6.5: Verification (only when `$FULL_MODE`)**
+
+Skip this step entirely if NOT `$FULL_MODE`.
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► VERIFYING RESULTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Spawning verifier...
+```
+
+```
+Task(
+  prompt="Verify quick task goal achievement.
+Task directory: ${QUICK_DIR}
+Task goal: ${DESCRIPTION}
+
+<files_to_read>
+- ${QUICK_DIR}/${quick_id}-PLAN.md (Plan)
+</files_to_read>
+
+Check must_haves against actual codebase. Create VERIFICATION.md at ${QUICK_DIR}/${quick_id}-VERIFICATION.md.",
+  subagent_type="dgs-verifier",
+  model="{verifier_model}",
+  description="Verify: ${DESCRIPTION}"
+)
+```
+
+Read verification status:
+```bash
+grep "^status:" "${QUICK_DIR}/${quick_id}-VERIFICATION.md" | cut -d: -f2 | tr -d ' '
+```
+
+Store as `$VERIFICATION_STATUS`.
+
+| Status | Action |
+|--------|--------|
+| `passed` | Store `$VERIFICATION_STATUS = "Verified"`, continue to step 7 |
+| `human_needed` | Display items needing manual check, store `$VERIFICATION_STATUS = "Needs Review"`, continue |
+| `gaps_found` | Display gap summary, offer: 1) Re-run executor to fix gaps, 2) Accept as-is. Store `$VERIFICATION_STATUS = "Gaps"` |
+
+---
+
+**Step 7: Update STATE.md**
+
+If `$FAST_MODE`: skip — fast path handles its own STATE.md update in step F6 above.
+
+Update STATE.md with quick task completion record.
+
+**7a. Check if "Quick Tasks Completed" section exists:**
+
+Read STATE.md and check for `### Quick Tasks Completed` section.
+
+**7b. If section doesn't exist, create it:**
+
+Insert after `### Blockers/Concerns` section:
+
+**If `$FULL_MODE`:**
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Status | Directory |
+|---|-------------|------|--------|--------|-----------|
+```
+
+**If NOT `$FULL_MODE`:**
+```markdown
+### Quick Tasks Completed
+
+| # | Description | Date | Commit | Directory |
+|---|-------------|------|--------|-----------|
+```
+
+**Note:** If the table already exists, match its existing column format. If adding `--full` to a project that already has quick tasks without a Status column, add the Status column to the header and separator rows, and leave Status empty for the new row's predecessors.
+
+**7c. Append new row to table:**
+
+Use `date` from init:
+
+**If `$FULL_MODE` (or table has Status column):**
+```markdown
+| ${quick_id} | ${DESCRIPTION} | ${date} | ${commit_hash} | ${VERIFICATION_STATUS} | [${quick_id}-${slug}](./quick/${quick_id}-${slug}/) |
+```
+
+**If NOT `$FULL_MODE` (and table has no Status column):**
+```markdown
+| ${quick_id} | ${DESCRIPTION} | ${date} | ${commit_hash} | [${quick_id}-${slug}](./quick/${quick_id}-${slug}/) |
+```
+
+**7c2. Archive excess rows**
+
+After adding the row, trigger archival to keep the table within 20 rows:
+
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" state archive-quick-tasks 2>/dev/null
+```
+
+If archival occurred, `.planning/quick/HISTORY.md` was created or updated. Include it in Step 8's commit file list.
+
+**7d. Update "Last activity" line:**
+
+Use `date` from init:
+```
+Last activity: ${date} - Completed quick task ${quick_id}: ${DESCRIPTION}
+```
+
+Use Edit tool to make these changes atomically
+
+---
+
+**Step 8: Final commit and completion**
+
+Stage and commit quick task artifacts:
+
+Build file list:
+- `${QUICK_DIR}/${quick_id}-PLAN.md`
+- `${QUICK_DIR}/${quick_id}-SUMMARY.md`
+- `${state_path}`
+- `${project_root}/quick/HISTORY.md` (if it exists — may have been created by archival)
+- If `$DISCUSS_MODE` and context file exists: `${QUICK_DIR}/${quick_id}-CONTEXT.md`
+- If `$FULL_MODE` and verification file exists: `${QUICK_DIR}/${quick_id}-VERIFICATION.md`
+
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(quick-${quick_id}): ${DESCRIPTION}" --files ${file_list}
+```
+
+Get final commit hash:
+```bash
+commit_hash=$(git rev-parse --short HEAD)
+```
+
+Display completion output:
+
+**If `$FULL_MODE`:**
+```
+---
+
+DGS > QUICK TASK COMPLETE (FULL MODE)
+
+Quick Task ${quick_id}: ${DESCRIPTION}
+
+Summary: ${QUICK_DIR}/${quick_id}-SUMMARY.md
+Verification: ${QUICK_DIR}/${quick_id}-VERIFICATION.md (${VERIFICATION_STATUS})
+Commit: ${commit_hash}
+
+---
+
+Ready for next task: /dgs:quick
+```
+
+**If NOT `$FULL_MODE`:**
+```
+---
+
+DGS > QUICK TASK COMPLETE
+
+Quick Task ${quick_id}: ${DESCRIPTION}
+
+Summary: ${QUICK_DIR}/${quick_id}-SUMMARY.md
+Commit: ${commit_hash}
+
+---
+
+Ready for next task: /dgs:quick
+```
+
+</process>
+
+<success_criteria>
+- [ ] ROADMAP.md validation passes
+- [ ] User provides task description
+- [ ] `--full`, `--discuss`, `--fast`, and `--dry-run` flags parsed from arguments when present
+- [ ] Slug generated (lowercase, hyphens, max 40 chars)
+- [ ] Quick ID generated (YYMMDD-xxx format, 2s Base36 precision)
+- [ ] Directory created at `${quick_dir}/YYMMDD-xxx-slug/`
+- [ ] (--discuss) Gray areas identified and presented, decisions captured in `${quick_id}-CONTEXT.md`
+- [ ] `${quick_id}-PLAN.md` created by planner (honors CONTEXT.md decisions when --discuss)
+- [ ] (--full) Plan checker validates plan, revision loop capped at 2
+- [ ] `${quick_id}-SUMMARY.md` created by executor
+- [ ] (--full) `${quick_id}-VERIFICATION.md` created by verifier
+- [ ] STATE.md updated with quick task row (Status column when --full)
+- [ ] Artifacts committed
+- [ ] (--fast) `--fast` and `--dry-run` flags parsed from arguments
+- [ ] (--fast) No subagents spawned — orchestrator makes edits directly
+- [ ] (--fast) Conventional commit message inferred and committed
+- [ ] (--fast) STATE.md updated with fast task row (or skipped if no STATE.md)
+- [ ] (--fast) Scope warning shown when >3 files or >30 lines affected
+- [ ] (--fast) (--dry-run) Changes shown as diff, user asked to apply or discard
+- [ ] (--fast) Minimal output: "Done: {message} [{hash}]"
+</success_criteria>