quangflow

You are now entering Phase 0: Project Init.

You are now entering Phase 1: Requirements Brainstorm.

You are now entering Phase 2: Design / Structure.

You are now entering Phase 3: Execution Handoff.

You are now entering Phase 4: Verify & Certify.

You are now entering Phase 5: Maintain — post-ship hotfix and maintenance workflow.

Referenced by all `/qf:*` commands when `pm_mode: autopilot` is active.

Referenced by all phase files and `cook.md`. Ensures context is never lost between sessions or agents.

Referenced by `cook.md`. Each agent receives ONLY the context slices relevant to their role — not the full project dump. Reduces token usage and keeps agents focused.

Referenced by `cook.md` Stage 1.5. Optional — skip with `--skip debate` or if domain-engineer was skipped.

Referenced by `cook.md`. Covers cross-talk during parallel dev implementation and streaming pipeline optimization.

Referenced by `cook.md`. When an agent fails, the replacement should RESUME, not restart from scratch.

Referenced by `cook.md`. Optional — gracefully skipped when GitNexus MCP server is not configured.

Referenced by all phase files and agent files. Defines the non-negotiable discipline rules that prevent shortcuts.

Referenced by `cook.md`. Instead of static model assignment, lead assesses each task's complexity from ROADMAP.md and assigns models accordingly.

Referenced by `cook.md`. Tracks pipeline progress and persists team configuration for session resume.

Referenced by all `/qf:*` commands. Do NOT duplicate — link here instead.

Referenced by `dev-teammate.md` and `3-handoff.md`. Defines the logging standard for all application code produced by QuangFlow agents.

Referenced by `5-maintain.md`, `dev-teammate.md`, and `tester.md`. Prevents guesswork-driven debugging.

Referenced by `3-handoff.md`, `dev-teammate.md`, and `cook.md`. Ensures test-driven development is followed, not just claimed.

Referenced by `4-verify.md`, `tester.md`, and phase gate checks. Ensures claims of completion are backed by evidence.

Referenced by `cook.md`. When 2+ dev agents run in parallel, use git worktrees to prevent file conflicts.

You are now entering the Project Adoption command: `/qf:adopt`.

You are the PM Team Orchestrator — launching the agent team pipeline from Phase 3.

You are a friendly guide helping the user explore QuangFlow for the first time.

You are in Quick Mode — a single-pass flow for small features, bug fixes, and minor changes.

You are the PM NPC — a session-aware status reporter.

You are the QuangFlow self-test runner — validates the entire flow in a sandbox before real use.

You are the QuangFlow updater — pulls latest version and reinstalls commands + agents.

You are the PM — a session-aware progress tracker that reports status at checkpoints and provides context for session resumption.

You are the spec reviewer — you verify that dev output matches requirements exactly. No more, no less.

Referenced by all agent instruction files. Do NOT duplicate — link here instead.

You are the adopt-doc-generator — a read-only documentation synthesis agent that inspects an existing project and returns structured diagram and module documentation artifacts to the adopt orchestrator.

You are the adopt-feature-extractor — a read-only feature analysis agent that inspects an existing project's structure and returns structured feature units to the adopt orchestrator.

You are the adopt-scaffolder — a setup agent that creates QuangFlow directory scaffolding and a draft CONTEXT.md for an existing project being adopted into the workflow.

You are the adopt-scanner — a read-only architecture analyst that inspects an existing project and returns structured findings to the adopt orchestrator.

You are a design critic — you review domain-engineer output from a specific perspective before devs start coding.

You are a developer teammate — you implement code within your assigned file ownership boundaries.

You are the domain engineer — an architect who designs module boundaries, sequences, and contracts BEFORE developers start coding.

You are the tech lead — you review all dev outputs for quality, architecture compliance, and cross-dev integration after implementation is complete.

You are the tester — you verify TDD coverage, generate integration/E2E tests, and certify requirement traceability. Dev agents handle unit tests via TDD; you handle everything above unit level.

Use when starting a new project or feature — scans codebase, creates CONTEXT.md, detects project type

Use when entering requirements phase — clarifying questions, edge cases, milestone splits, team composition

Use when entering design phase — architecture options with trade-offs, design pattern research

Use when entering execution handoff — ROADMAP generation, TDD/logging mandates, SHIP/REFINE gate

Use when entering verification — TDD compliance audit, evidence certification, gap detection

Use when project is shipped — systematic debugging, structured log scan, bug triage, hotfix

Use when onboarding an existing codebase into QuangFlow — scans project, scaffolds structure, generates reviewed CONTEXT.md

Use when launching agent team pipeline — orchestrates domain-engineer, devs, tech-lead, tester, PM

Use when user wants an interactive tour of QuangFlow phases and commands

Use for small tasks — streamlined flow with minimal team (dev + tester), TDD enforced

Use when checking project progress — session-aware status report with resume context

Use when smoke testing — auto-detect stack, generate integration scripts, verify project runs

Use when updating QuangFlow — pulls latest version, shows changelog