Adhoc Flow

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.

• large (smart, slow): claude-opus-5, gpt-5.6-terra-high, gpt-5.6-sol-high, gemini-3.7-flash-high, kimi-k3, glm-5.2
• medium (workhorse): claude-sonnet-5, gpt-5.6-terra-medium, glm-5, kimi-k2.5, minimax-m2.5, grok-4.6
• small (fast): claude-haiku-4-5, gpt-5.6-luna, gpt-5.6-luna-medium, gemini-3.7-flash-low

Match to cognitive demand. Match to current tool.

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.

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.6-terra, 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".

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.
4. MUST use available MCPs, tools, skills and agents.
5. You will FOR SURE run out of LLM context, leading to loss of information, delegate to subagents!
6. If /goal is set repeat phases 4-5 until goal is met.

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

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.

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

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

• 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

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