/adhoc-flow

name: adhoc-flow
description: "Workflow for the rest of tasks: lightweight documentation, build, track, synchronize, etc."

<adhoc_flow>

<description_and_purpose>

Problem: Fixed workflows cannot cover the combinatorial space of real requests; orchestrators lock into rigid classification. Solution: Meta-workflow — construct a bespoke plan from building blocks, review, execute with tracking. Each user turn can extend, adapt, or restart.

If request is trivial / one-liner AND you confirmed it is true (by checking code / instructions fallback to ask user) only then you are allowed to just directly execute it without extra complications of this skill => otherwise you must fully follow this and orchestration skills.

</description_and_purpose>

<models>

• large (smart, slow): claude-opus-4-8, gpt-5.3-codex-high, gpt-5.5-high, gpt-5.6-sol-high, gemini-3.1-pro-preview, kimi-k3, glm-5.2
• medium (workhorse): claude-sonnet-5, gpt-5.3-codex-medium, gpt-5.4-medium, gpt-5.6-terra-medium, glm-5, kimi-k2.5, minimax-m2.5, grok-4.5
• small (fast): claude-haiku-4-5, gpt-5.4-mini, gpt-5.6-luna-medium, gemini-3.5-flash

Match to cognitive demand. Match to current tool.

</models>

<orchestration severity="CRITICAL">

1. MUST USE SKILL `orchestration` with team management, which is the core mechanism of this workflow. 2. Workflow state MUST be saved to `agents/TEMP/<FEATURE>/adhoc-flow-state.md` file.

</orchestration>

<building_blocks>

Compose any of these (not limited) into plan phases/steps to build any execution workflow:

• **discover-research**: scan project context and KB; research external knowledge if needed; deliver summarized references
• **requirements-capture**: reverse-engineer or interrogate requirements; persist intent as source of truth
• **reasoning-decomposition**: USE SKILL `reasoning` (8D) to decompose into sub-problems with decisions and trade-offs
• **plan-wbs**: USE SKILL `planning` to build sequenced WBS
• **tech-specs**: USE SKILL `tech-specs` to generate target technical implementation specs; makes AI to figure out entire solution, instead of discovering something as a surprise
• **subagent-delegation**: provide role + context/refs; route parallel/sequential; enforce focus — report back if off-plan
• **delegate-but-verify**: use subagent delegation, but verify both reasoning and results
• **critically-review**: critically review inputs, outputs, reasoning, completeness, ambiguity, results of user, subagents, tools, scripts, etc.
• **execute-track**: EXECUTION_CONTROLLER `next` → execute → `update_status`; `upsert` to adapt mid-execution; loop
• **modify-review**: modify then review with different agent/model
• **review-validate**: review (static inspection against intent) + validate (run locally, call/use local, runtime evidence on real tasks)
• **memory-learn**: root-cause failures → reusable preventive rules → update AGENT MEMORY.md
• **hitl-gate**: present summary to user; block until explicit approval
• **simulate**: walk through plan with use cases; verify cognitive load and phase boundaries
• **draft-improve**: short core draft → improve one non-conflicting aspect at a time
• **ralph-loop**: execute → review → update task memory with root causes → loop
• **use**: use existing skills, agents, workflows
• **plan-sessions**: create plan (one file, with refs to per-session files) and implementation specs for each session for workhorse model (sonnet 5, gpt-5.4, so you need to provide more details) in multiple files in order of execution, so that it can be given one-by-one in different sessions of subagents.
• **Do not duplicate**: existing files, instructions, protocols => instead use references "file-name:line-ranges".

</building_blocks>

<workflow_phases>

<prerequisites phase="1" applies="ALL">

1. All Rosetta prep steps MUST be FULLY completed 2. MUST USE SKILL `load-project-context`, `orchestration` (with team manager, execution controller is size dependent), `hitl` 3. MUST ALWAYS use todo tasks ledger, ASAP. Phases are sequential. Independent tasks can run in parallel. 3. MUST use available MCPs, tools, skills and agents. 4. You will FOR SURE run out of LLM context, leading to loss of information, delegate to subagents! 5. If `/goal` is set repeat phases 4-5 until goal is met.

</prerequisites>

<build_plan phase="2">

1. USE SKILL `reasoning` if needed or LARGE. 2. Use building block, sequence a plan. 3. Upsert.

</build_plan>

<review_plan phase="3" if="MEDIUM, LARGE" subagent="reviewer" role="Plan reviewer of AI automated tasks" subagent_required_model="inherit" must-be-subagent>

1. Review: completeness, sequencing, dependency correctness, prompt clarity, etc. 2. Subagent to query by full path to plan.json. Orchestrator to upsert fixes. 3. hitl-gate — present summary, block until approved.

</review_plan>

<execute_plan phase="4" loop="true">

1. Get next steps. 2. Per step: delegate to subagent or execute directly. 3. Adapt plan changes. 4. Loop until all completed.

</execute_plan>

<review_and_summarize phase="5">

1. Final review - validate against original intent. 2. Repeat execution if not met original intent. 3. Summarize to user if completed.

</review_and_summarize>

</workflow_phases>

<best_practices>

• Short and clear
• Use git worktrees for parallel work
• Use self-learning
• Validate incrementally
• Do not accumulate unverified work
• Prevent scope creep, always pass original intent to subagents
• Keep context lean — delegate to subagents
• Plan is a living artifact
• Provide references, not dumps
• Use subagent to build_plan for MEDIUM/LARGE requests

</best_practices>

<pitfalls>

• Over-planning SMALL requests
• Context overload: delegate instead
• Parallel work collisions

</pitfalls>

</adhoc_flow>