# Romiluz13 Cc10x Cc10x Router > cc10x Router - Skill: `tomevault-io/romiluz13-cc10x-cc10x-router` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add tomevault-io/romiluz13-cc10x-cc10x-router` - Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/romiluz13-cc10x-cc10x-router/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: tomevault-io (https://skillmd.com/u/tomevault-io) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/tomevault-io/romiluz13-cc10x-cc10x-router --- # cc10x Router **Runtime contract only.** v10 restores trust-first orchestration: route intent, hydrate workflow state, write workflow artifacts, execute the task graph, validate agent output, and fail closed on ambiguity, skipped work, or missing persistence. ## 1. Intent Routing Route using the first matching signal: | Priority | Signal | Keywords | Workflow | Chain | |----------|--------|----------|----------|-------| | 1 | ERROR | error, bug, fix, broken, crash, fail, debug, troubleshoot, issue | DEBUG | bug-investigator -> code-reviewer -> integration-verifier | | 2 | PLAN | plan, design, architect, roadmap, strategy, spec, brainstorm | PLAN | brainstorming -> planner -> bounded fresh review loop | | 3 | REVIEW | review, audit, analyze, assess, "is this good" | REVIEW | code-reviewer | | 4 | DEFAULT | Everything else | BUILD | component-builder -> [code-reviewer || silent-failure-hunter] -> integration-verifier | Rules: - NEVER use Claude Code's native plan mode (EnterPlanMode). CC10x owns planning. All "plan", "design", "architect", "brainstorm" requests route to the CC10x PLAN workflow — not to the built-in plan mode tool. EnterPlanMode bypasses CC10x orchestration, memory, workflow artifacts, and verification entirely. - ERROR always wins over BUILD. - REVIEW is advisory only. Never let REVIEW create code-changing tasks. - BUILD always uses the full chain. The old QUICK path is retired. - Before execution, output one line: `-> {WORKFLOW} workflow (signals: {matched keywords})` ## 2. Memory Load And Template Validation Always run this before routing or resuming: ```text 1. Bash("mkdir -p .claude/cc10x/v10") 2. Read(".claude/cc10x/v10/activeContext.md") 3. Read(".claude/cc10x/v10/patterns.md") 4. Read(".claude/cc10x/v10/progress.md") ``` Do not parallelize step 1 with reads. If a memory file is missing: - Create it using the `cc10x:session-memory` template. - Read it before continuing. Required sections: | File | Required Sections | |------|-------------------| | `activeContext.md` | `## Current Focus`, `## Recent Changes`, `## Next Steps`, `## Decisions`, `## Learnings`, `## References`, `## Blockers`, `## Session Settings`, `## Last Updated` | | `progress.md` | `## Current Workflow`, `## Tasks`, `## Completed`, `## Verification`, `## Last Updated` | | `patterns.md` | `## User Standards`, `## Common Gotchas`, `## Project SKILL_HINTS`, `## Last Updated` | Auto-heal rule: - Insert missing sections before `## Last Updated`. - After every `Edit(...)`, immediately `Read(...)` and verify the new section exists. JUST_GO: - Read `activeContext.md ## Session Settings`. - If `AUTO_PROCEED: true`, set `JUST_GO=true`. - While `JUST_GO=true`, auto-default all non-REVERT AskUserQuestion gates to the recommended option and log the choice in `## Decisions`. v10 trust rule: - `JUST_GO` never overrides explicit user/project standards, open plan decisions, or failure-stop gates. - If a plan still has unresolved `Open Decisions`, BUILD may not start, even in `JUST_GO`. ## 2a. Workflow Artifact And Hook Policy CC10X durable orchestration state lives in: ```text .claude/cc10x/v10/workflows/{workflow_uuid}.json ``` Artifact schema must include: - `workflow_uuid` - `workflow_id` - `workflow_type` - `state_root` - `user_request` - `plan_file` - `design_file` - `research_files` - `approved_decisions` - `intent` - `capabilities` - `phase_cursor` - `normalized_phases` - `research_rounds` - `research_backend_history` - `research_quality` - `task_ids` - `phase_status` - `results` - `evidence` - `telemetry` - `quality` - `planning_review_runs` - `planning_review_findings` - `planning_review_status` - `memory_notes` - `pending_gate` - `status_history` - `remediation_history` - `created_at` - `updated_at` Rules: - Router creates the workflows directory before the first workflow artifact write. - Router writes or updates the artifact after workflow creation, every agent completion, every remediation decision, every clarification answer, every phase completion, every blocking stop, and memory finalization. - Resume uses task metadata first, then workflow artifact, then memory markdown. - Verifier handoff and memory finalization read structured data from the workflow artifact, not transient conversation recovery. - The workflow UUID is generated independently of Claude task ids and is the canonical workflow identifier everywhere in v10. - `workflow_id` remains as a compatibility alias and must equal `workflow_uuid` in new artifacts. - `state_root` must equal `.claude/cc10x/v10`. - `phase_cursor` points at the only BUILD phase that may run next. - `normalized_phases` stores planner-approved executable phases with: - `phase_id` - `title` - `objective` - `files` - `checks` - `exit_criteria` - Bright Data MCP and Octocode MCP are optional accelerators. Base CC10X installs must continue to work with built-in Claude Code tools only. - When optional user-configured Claude Code MCP servers are available, use the server names `brightdata` and `octocode` so the research agents can auto-detect them without prompt edits. - `capabilities` records the session-level research backend availability model: - `brightdata_available` - `octocode_available` - `websearch_available` - `webfetch_available` - `results.research` must be structured as `web`, `github`, and `synthesis`. - `intent` stores the durable spec header for the workflow: - `goal` - `non_goals` - `constraints` - `acceptance_criteria` - `open_decisions` - `approved_decisions` stores decisions explicitly approved by the user or already fixed in the saved plan. - `evidence` stores proof-of-work grouped by agent: - `builder` - `investigator` - `reviewer` - `hunter` - `verifier` - `quality` stores convergence state: - `confidence` - `evidence_complete` - `scenario_coverage` - `research_quality` - `convergence_state` - PLAN-local fresh review tracking stores: - `planning_review_runs` - `planning_review_findings` - `planning_review_status` - `telemetry` is informational only and must never drive routing decisions: - `task_metrics_available` - `workflow_wall_clock_seconds` - `agent_wall_clock_seconds` - `loop_counts` - `verifier` - `telemetry.agent_wall_clock_seconds` stores per-agent wall-clock timings when task metrics or explicit telemetry are available: - `builder` - `investigator` - `reviewer` - `hunter` - `verifier` - `planner` - `telemetry.loop_counts` stores: - `re_review` - `re_hunt` - `re_verify` - `telemetry.verifier` stores: - `phase_exit_proof_runs` - `extended_audit_runs` - `workload_seconds` - `telemetry.verifier.workload_seconds` stores: - `tests` - `build` - `scan` - `reconcile` - `reasoning` - `pending_gate` is required whenever BUILD/PLAN/DEBUG is waiting on user clarification, scope selection, or persistence repair. - `status_history` and `remediation_history` are append-only summaries of major router decisions. v10 router gates: - `plan_trust_gate` - `phase_exit_gate` - `failure_stop_gate` - `memory_sync_gate` - `skill_precedence_gate` These are router-owned checks, not advisory hints. Workflow event log: - For every workflow, keep a lightweight append-only companion file: ```text .claude/cc10x/v10/workflows/{workflow_uuid}.events.jsonl ``` - Append event objects with at least: - `ts` - `wf` - `event` - `phase` - `task_id` - `agent` - `decision` - `reason` - Optionally append: - `duration_seconds` - `work_category` - `details` - Event types: - `workflow_started` - `agent_started` - `agent_completed` - `contract_parsed` - `remediation_created` - `scope_decision_requested` - `scope_decision_resolved` - `memory_finalized` - `workflow_completed` - `workflow_failed` Hook policy: - CC10X plugin hooks live in the plugin bundle under `hooks/hooks.json` and should stay minimal: - `PreToolUse` for protected writes - `SessionStart` for resume context (fires on startup|resume|compact) - `PostToolUse` for workflow artifact integrity audit - `TaskCompleted` for task metadata checks - `PostCompact` for compaction event capture in workflow event log (audit only) - `SubagentStop` for agent contract presence audit (telemetry only) - `PreCompact` for workflow state snapshot before compaction (persistence only) - `Stop` for workflow state snapshot on session stop (persistence only, never blocks) - `StopFailure` for API error logging to workflow event log (async, telemetry only) - `InstructionsLoaded` for instruction file load audit trail (async, telemetry only) - Default mode is audit-only. Do not rely on hooks as the only source of truth; the router still owns orchestration decisions. - Repo-local `.claude/settings.json` is not part of the shipped CC10X product. - Optional accelerator MCPs are user-configured in Claude Code. CC10X assumes the names `brightdata` and `octocode` if they are available, but must degrade to built-in research paths when they are absent. ## 3. Task Metadata Contract Every CC10X task description starts with normalized metadata lines: ```text wf:{workflow_uuid} kind:{workflow|agent|remfix|memory|reverify|research} origin:{router|component-builder|bug-investigator|code-reviewer|silent-failure-hunter|integration-verifier|planner} phase:{build|build-implement|build-review|build-hunt|build-verify|debug|debug-investigate|debug-review|debug-verify|review|review-audit|plan|plan-create|plan-review-gap-1|plan-review-gap-2|memory-finalize|re-review|re-hunt|re-verify|re-plan|research-web|research-github} plan:{path|N/A} scope:{ALL_ISSUES|CRITICAL_ONLY|N/A} reason:{short reason or N/A} ``` Rules: - `wf:` is mandatory on every child task. - Router must generate `workflow_uuid` before `TaskCreate()` and use it from the first write. `wf:PENDING_SELF` is retired in v10. - `kind:` is mandatory and drives resume, routing, and counting logic. - `origin:` is mandatory on every `kind:remfix` task. - `plan:` is required on workflow, agent, reverify, and memory tasks. - `reason:` is required on remediation and research tasks. - The router must never depend on loose prose when metadata can answer the question. ## 4. Resume And Hydration After memory load: ```text TaskList() ``` Hydration rules: - Find active parent workflow tasks by subject prefix `CC10X BUILD:`, `CC10X DEBUG:`, `CC10X REVIEW:`, `CC10X PLAN:`. - If more than one active workflow exists, scope by the current conversation and matching `wf:` markers. Do not resume a workflow you cannot scope confidently. - Reconstruct runnable tasks from `TaskList()` and `TaskGet()` using `wf:` + `kind:` + `phase:`. Do not rely on stored task IDs for correctness. - Read and write only the v10 namespace. Ignore legacy `.claude/cc10x/*.md` and `.claude/cc10x/workflows/*` state during hydration. - `[cc10x-internal] memory_task_id` in `activeContext.md` is only a transient optimization. If it is missing, stale, or points to a different `wf:`, ignore it and reconstruct the memory task from the current workflow scope. [EASY TO MISS: stale memory_task_id is the #1 cause of cross-workflow pollution] - Never use an unscoped fallback like "first pending Memory Update task". [EASY TO MISS: unscoped lookups silently pick up orphan tasks from prior workflows] Resume algorithm: 1. Identify the active parent workflow. 2. Extract `workflow_uuid` from the `wf:` line. 3. Read all CC10X tasks whose descriptions contain that `wf:`. 4. Derive runnable tasks from `status` and `blockedBy`. 5. Reconstruct the memory task as the unique pending/in_progress `kind:memory` task in the same `wf:`. Scope-decision resume: - Before normal routing, check `activeContext.md ## Decisions` for a live marker: - `[SCOPE-DECISION-PENDING: wf:{workflow_uuid} reason:{...}]` - If present, treat the current user reply as the answer to that pending BUILD scope gate: - `critical only` -> create the pending REM-FIX with `scope:CRITICAL_ONLY` - `all issues` -> create the pending REM-FIX with `scope:ALL_ISSUES` - anything else -> ask again with the same two options and stop - After consuming a valid answer: - remove the pending marker from `## Decisions` - create the scoped REM-FIX - block downstream re-review / re-hunt / verifier tasks as normal - stop after task creation so the next turn resumes from task state, not from repeated prose parsing - [EASY TO MISS: When persisting user decisions, use the user's exact words. Paraphrasing introduces drift that compounds across resume cycles.] Safety rules: - If a task list is shared across sessions, always scope by `wf:` before resuming. - If a task has `status=in_progress` and unresolved blockers, treat it as waiting on remediation, not as a free-running orphan. - If a task has `status=in_progress` and no blockers, ask the user whether to resume, delete, or mark complete. - If legacy tasks exist with subjects starting `BUILD:`, `DEBUG:`, `REVIEW:`, or `PLAN:` without the `CC10X` prefix, ask whether to resume the legacy workflow or start a fresh CC10X workflow. ## 5. Workflow Preparation ### Shared preparation Before creating a new workflow: - Read `activeContext.md ## References` to discover `Plan`, `Design`, and prior `Research` files. - Read `activeContext.md ## Decisions` for prior planner/build clarifications. - Read `progress.md ## Current Workflow` and `## Tasks` for pending work that should resume instead of duplicating. - Read the latest `.claude/cc10x/v10/workflows/*.json` artifact if one exists for the current conversation. **Intent Readiness Gate (MANDATORY before PLAN or BUILD):** Before dispatching to planner or builder, verify the intent contract meets three conditions: 1. **Context-bounded:** The full intent (goal + constraints + acceptance criteria) fits within the agent's prompt scaffold without truncation. If the intent requires loading more than 5 source files to be understood, decompose first (switch to PLAN). 2. **Contradiction-free:** No acceptance criterion contradicts a stated constraint or non-goal. If contradictions exist, halt and persist `pending_gate="intent_contradiction"`. 3. **Sufficiently specific:** Every acceptance criterion maps to at least one verifiable scenario. If a criterion is unverifiable ("make it better" without a metric), halt and ask for specificity. Router-owned interface fields: - `plan_mode`: `direct` | `execution_plan` | `decision_rfc` - `verification_rigor`: `standard` | `critical_path` - `checkpoint_type`: `none` | `human_verify` | `decision` | `human_action` - `proof_status`: `passed` | `gaps_found` | `human_needed` ### BUILD preparation 1. Read `- Plan:` from `activeContext.md ## References`. 2. If plan path is not `N/A`, `Read(...)` the plan file before creating tasks. 3. Run `plan_trust_gate` before BUILD: - `Open Decisions` must be empty or explicitly marked approved. - `Differences from agreement` must be present, even if empty. - `plan_mode` must be explicit when a plan artifact exists. - `verification_rigor` must be explicit when a plan artifact exists. - If `plan_mode` is `execution_plan` or `decision_rfc`: every phase in `normalized_phases` must carry non-empty `exit_criteria`, and `intent.acceptance_criteria` must be non-empty. Field presence is not enough — field completeness is required. - Cross-check `intent.constraints` against approved decisions. If any approved decision explicitly contradicts an `intent.constraint`, emit NOGO with the contradiction and ask the user to resolve before BUILD starts. - If any condition fails, ask for clarification and do not start BUILD. 4. If plan path is `N/A`, assess scope before dispatch: - **Trivial** (single concern, one file group, one failure mode) → continue directly to BUILD. Heuristic signals: touches 1-2 files, single logical change, one testable outcome, no cross-module wiring. [EASY TO MISS: When the task is clearly trivial, do not ask clarifying questions or suggest planning. Execute directly. Analysis paralysis on trivial work is a net negative.] - **Non-trivial** (spans multiple independent file groups, has separable concerns, or involves distinct failure modes) → ask: `Plan first (Recommended)` or `Build directly`. Heuristic signals: touches 3+ files across different directories, multiple independent concerns that could fail separately, changes to both interface and implementation, or new cross-module dependencies. - `Plan first` -> switch to PLAN workflow. - `Build directly` -> continue without a plan. 5. If the referenced plan file is missing: - Ask: `Build without plan` or `Re-plan first (Recommended)`. - `Build without plan` -> continue with `plan:N/A` - `Re-plan first` -> switch to PLAN workflow 6. Normalize planner phases into executable `normalized_phases` and initialize `phase_cursor` to the first incomplete phase. 7. Persist the approved `plan_mode` and `verification_rigor` from the planner contract into the workflow artifact. 8. Every normalized phase must carry: - `objective` - `inputs` - `files/surfaces` - `expected_artifacts` - `required_checks` - `checkpoint_type` - `exit_criteria` 9. Initialize workflow `proof_status` to `gaps_found` until the current phase is independently verified. 10. Clarify missing requirements before builder only when the plan and memory do not already answer them. 11. Persist pre-answered clarifications in `activeContext.md ## Decisions` using `Build clarification [{topic}]: {answer}`. 12. Builder may execute only the phase at `phase_cursor`. ### DEBUG preparation 1. If the user explicitly asks for research or the bug clearly depends on external post-2024 behavior, allow a research round before the first investigator run. 2. Immediately write `[DEBUG-RESET: wf:{workflow_uuid}]` once the workflow id exists. 3. Preserve failed attempt counting semantics: the investigator counts `[DEBUG-N]:` entries after the most recent reset marker. ### REVIEW preparation 1. REVIEW is advisory only. 2. Never create REM-FIX or implementation tasks directly from a REVIEW workflow. 3. If the final review verdict is `CHANGES_REQUESTED`, the router may offer `Start BUILD to fix (Recommended)` as a follow-up user choice. ### PLAN preparation 1. Restore design enrichment: - Read `- Design:` from `activeContext.md ## References`. - If a design path exists, verify it with `Glob(...)` and pass it under `## Design File`. 2. Mandatory brainstorming (ALWAYS runs for PLAN workflows): - ALWAYS run `Skill(skill="cc10x:brainstorming")` in the main context before planner. Brainstorming is how the user explores and clarifies intent — skipping it means the planner works from assumptions instead of understanding. - If a valid design file exists from step 1: brainstorming uses it as a foundation (the skill's Spec File Workflow reads and expands the existing design rather than starting from scratch). - If no design file exists: brainstorming starts from the user's request and explores the idea space. - Brainstorming may ask the user questions and may save a `*-design.md` file. After it completes, re-read `activeContext.md ## References` and refresh the design path. - Brainstorming should ask only unresolved, high-impact questions and stop as soon as the intent contract is complete. 3. Optional research before planning: - Ask whether to run web + GitHub research for external/unfamiliar technology when it would materially improve the plan. 4. Planner receives `## Research Files` only when research files actually exist. 5. Planner is agreement-first: - If a requirement is materially ambiguous, planner returns `STATUS=NEEDS_CLARIFICATION`. - Planner never treats its own defaults as approved implementation. 6. Planner must choose one `plan_mode`: - `direct` for trivial low-risk work - `execution_plan` for standard implementation work - `decision_rfc` for architecture or multi-option work 7. Planner must choose one `verification_rigor`: - `standard` by default (covers most work; keeps verification proportional to risk) - `critical_path` for security, money, state-machine, concurrency, or irreversible-migration work (failure in these domains is irreversible or high-blast-radius; justifies extended scenario coverage) 8. PLAN fresh-review loop: - Every PLAN workflow pre-creates a bounded review DAG: `plan-create -> plan-review-gap-1 -> re-plan -> plan-review-gap-2 -> memory-finalize`. - Every saved plan artifact enters that DAG, including `direct`, `execution_plan`, and `decision_rfc`. - If pass 1 succeeds, the router prunes the unused `re-plan` and pass 2 branch explicitly. - If pass 1 finds blocking issues, the router keeps the pre-created `re-plan` and pass 2 branch alive. - Maximum fresh-review passes: 2. - Planner remains the only plan writer. - The existing inline `plan-review-gate` inside planner remains the final fail-closed boundary on each planner pass. ## 6. Workflow Task Graphs ### Parent workflow creation Use this pattern for every new workflow: 1. Generate a stable workflow UUID before `TaskCreate()`: ```text workflow_uuid = "wf-" + UTC timestamp + "-" + 8 hex chars ``` 2. Create the parent workflow task with that UUID from the first write: ```text TaskCreate({ subject: "CC10X {WORKFLOW}: {summary}", description: "wf:{workflow_uuid}\nkind:workflow\norigin:router\nphase:{build|debug|review|plan}\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:User request\n\nUser request: {request}\nChain: {chain description}", activeForm: "{workflow active form}" }) ``` 3. Immediately write the v10 artifact and event log: ```text Write( file_path=".claude/cc10x/v10/workflows/{workflow_uuid}.json", content="{\"workflow_uuid\":\"{workflow_uuid}\",\"workflow_id\":\"{workflow_uuid}\",\"workflow_type\":\"{WORKFLOW}\",\"state_root\":\".claude/cc10x/v10\",\"user_request\":\"{request}\",\"plan_file\":null,\"design_file\":null,\"research_files\":[],\"approved_decisions\":[],\"plan_mode\":null,\"verification_rigor\":\"standard\",\"proof_status\":\"gaps_found\",\"traceability\":{\"requirements\":[],\"phases\":[],\"verification\":[],\"remediation\":[]},\"intent\":{\"goal\":null,\"non_goals\":[],\"constraints\":[],\"acceptance_criteria\":[],\"open_decisions\":[]},\"normalized_phases\":[],\"phase_cursor\":null,\"capabilities\":{\"brightdata_available\":\"unknown\",\"octocode_available\":\"unknown\",\"websearch_available\":\"unknown\",\"webfetch_available\":\"unknown\"},\"research_rounds\":[],\"research_backend_history\":[],\"research_quality\":{\"web\":\"none\",\"github\":\"none\",\"overall\":\"none\"},\"task_ids\":{\"planner_create\":null,\"planning_review_pass1\":null,\"planner_replan\":null,\"planning_review_pass2\":null,\"memory_finalize\":null},\"phase_status\":{},\"results\":{\"builder\":null,\"investigator\":null,\"reviewer\":null,\"hunter\":null,\"verifier\":null,\"planner\":null,\"planning_reviewer\":null,\"research\":{\"web\":null,\"github\":null,\"synthesis\":null}},\"evidence\":{\"builder\":[],\"investigator\":[],\"reviewer\":[],\"hunter\":[],\"verifier\":[],\"planning_reviewer\":[]},\"telemetry\":{\"task_metrics_available\":\"unknown\",\"workflow_wall_clock_seconds\":0,\"agent_wall_clock_seconds\":{\"builder\":0,\"investigator\":0,\"reviewer\":0,\"hunter\":0,\"verifier\":0,\"planner\":0},\"loop_counts\":{\"re_review\":0,\"re_hunt\":0,\"re_verify\":0},\"verifier\":{\"phase_exit_proof_runs\":0,\"extended_audit_runs\":0,\"workload_seconds\":{\"tests\":0,\"build\":0,\"scan\":0,\"reconcile\":0,\"reasoning\":0}}},\"quality\":{\"confidence\":null,\"evidence_complete\":false,\"scenario_coverage\":0,\"research_quality\":\"none\",\"convergence_state\":\"pending\"},\"planning_review_runs\":0,\"planning_review_findings\":[],\"planning_review_status\":\"not_started\",\"memory_notes\":[],\"pending_gate\":null,\"status_history\":[{\"event\":\"workflow_started\",\"ts\":\"{iso_timestamp}\",\"phase\":\"{build|debug|review|plan}\"}],\"remediation_history\":[],\"created_at\":\"{iso_timestamp}\",\"updated_at\":\"{iso_timestamp}\"}" ) Write( file_path=".claude/cc10x/v10/workflows/{workflow_uuid}.events.jsonl", content="{\"ts\":\"{iso_timestamp}\",\"wf\":\"{workflow_uuid}\",\"event\":\"workflow_started\",\"phase\":\"{build|debug|review|plan}\",\"task_id\":\"{parent_task_id}\",\"agent\":\"router\",\"decision\":\"start\",\"reason\":\"User request\"}\n" ) ``` Only create child tasks after the v10 artifact exists. ### BUILD task graph BUILD is sequential in v10: - one approved executable phase at a time - one builder run for the current phase only - review, hunt, and verify validate that phase before `phase_cursor` advances - if phase exit evidence is incomplete, record `partial` or `blocked`, persist state, and stop ```text TaskCreate({ subject: "CC10X component-builder: Execute phase {phase_id}", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:build-implement\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:Execute approved phase\n\nExecute ONLY the phase at phase_cursor. Recover objective, inputs, expected artifacts, required checks, checkpoint type, and exit criteria from the approved phase. Stop if blocked, partial, or proof remains incomplete.", activeForm: "Building components" }) -> builder_task_id TaskCreate({ subject: "CC10X code-reviewer: Review implementation", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:build-review\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:Review current phase quality\n\nReview only the files and scope of the current phase.", activeForm: "Reviewing code" }) -> reviewer_task_id TaskUpdate({ taskId: reviewer_task_id, addBlockedBy: [builder_task_id] }) TaskCreate({ subject: "CC10X silent-failure-hunter: Hunt edge cases", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:build-hunt\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:Audit current phase blast radius\n\nFind silent failures and edge cases adjacent to the current phase.", activeForm: "Hunting failures" }) -> hunter_task_id TaskUpdate({ taskId: hunter_task_id, addBlockedBy: [builder_task_id] }) TaskCreate({ subject: "CC10X integration-verifier: Verify integration", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:build-verify\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:Phase exit verification\n\nRun required checks for the current phase and report whether truths, artifacts, wiring, and phase exit criteria are all satisfied.", activeForm: "Verifying integration" }) -> verifier_task_id TaskUpdate({ taskId: verifier_task_id, addBlockedBy: [reviewer_task_id, hunter_task_id] }) TaskCreate({ subject: "CC10X Memory Update: Persist workflow learnings", description: "wf:{workflow_uuid}\nkind:memory\norigin:router\nphase:memory-finalize\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:Persist captured Memory Notes\n\nROUTER ONLY: execute inline. Read the workflow artifact and THIS task description payload, persist to .claude/cc10x/v10/*.md, then remove the matching [cc10x-internal] memory_task_id line from activeContext.md ## References. Never spawn Task() for this task.", activeForm: "Persisting workflow learnings" }) -> memory_task_id TaskUpdate({ taskId: memory_task_id, addBlockedBy: [verifier_task_id] }) ``` ### DEBUG task graph ```text TaskCreate({ subject: "CC10X bug-investigator: Investigate {error}", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:debug-investigate\nplan:N/A\nscope:N/A\nreason:Find root cause\n\nFind the root cause and apply the fix.", activeForm: "Investigating bug" }) -> investigator_task_id TaskCreate({ subject: "CC10X code-reviewer: Review fix", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:debug-review\nplan:N/A\nscope:N/A\nreason:Review the fix\n\nReview the debug fix quality.", activeForm: "Reviewing fix" }) -> reviewer_task_id TaskUpdate({ taskId: reviewer_task_id, addBlockedBy: [investigator_task_id] }) TaskCreate({ subject: "CC10X integration-verifier: Verify fix", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:debug-verify\nplan:N/A\nscope:N/A\nreason:Verify the fix\n\nVerify the fix works end-to-end.", activeForm: "Verifying fix" }) -> verifier_task_id TaskUpdate({ taskId: verifier_task_id, addBlockedBy: [reviewer_task_id] }) TaskCreate({ subject: "CC10X Memory Update: Persist debug learnings", description: "wf:{workflow_uuid}\nkind:memory\norigin:router\nphase:memory-finalize\nplan:N/A\nscope:N/A\nreason:Persist captured Memory Notes\n\nROUTER ONLY: execute inline. Read the workflow artifact and THIS task description payload, persist to .claude/cc10x/v10/*.md, then remove the matching [cc10x-internal] memory_task_id line from activeContext.md ## References. Never spawn Task() for this task.", activeForm: "Persisting debug learnings" }) -> memory_task_id TaskUpdate({ taskId: memory_task_id, addBlockedBy: [verifier_task_id] }) ``` ### REVIEW task graph ```text TaskCreate({ subject: "CC10X code-reviewer: Review {target}", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:review-audit\nplan:N/A\nscope:N/A\nreason:Advisory review\n\nRun a scoped code review.", activeForm: "Reviewing code" }) -> reviewer_task_id TaskCreate({ subject: "CC10X Memory Update: Persist review learnings", description: "wf:{workflow_uuid}\nkind:memory\norigin:router\nphase:memory-finalize\nplan:N/A\nscope:N/A\nreason:Persist captured Memory Notes\n\nROUTER ONLY: execute inline. Read the workflow artifact and THIS task description payload, persist to .claude/cc10x/v10/*.md, then remove the matching [cc10x-internal] memory_task_id line from activeContext.md ## References. Never spawn Task() for this task.", activeForm: "Persisting review learnings" }) -> memory_task_id TaskUpdate({ taskId: memory_task_id, addBlockedBy: [reviewer_task_id] }) ``` ### PLAN task graph ```text TaskCreate({ subject: "CC10X planner: Create plan for {feature}", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:plan-create\nplan:N/A\nscope:N/A\nreason:Create implementation plan\n\nChoose the correct plan mode (`direct`, `execution_plan`, or `decision_rfc`) and verification rigor (`standard` or `critical_path`). Create the corresponding planning artifact.", activeForm: "Creating plan" }) -> planner_task_id TaskCreate({ subject: "CC10X plan-gap-reviewer: Fresh review pass 1", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:plan-review-gap-1\nplan:N/A\nscope:N/A\nreason:Fresh anti-anchoring review of saved plan (pass 1)\n\nWait for the planner to save a plan artifact, then review it against the original user request and any approved design/research files.", activeForm: "Fresh-reviewing plan" }) -> planning_review_pass1_task_id TaskUpdate({ taskId: planning_review_pass1_task_id, addBlockedBy: [planner_task_id] }) TaskCreate({ subject: "CC10X planner: Revise plan after fresh review", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:re-plan\nplan:N/A\nscope:N/A\nreason:Revise plan if fresh review finds blocking issues\n\nOnly run if pass 1 finds blocking issues. Revise the existing saved plan using structured planning review findings.", activeForm: "Revising plan" }) -> planner_replan_task_id TaskUpdate({ taskId: planner_replan_task_id, addBlockedBy: [planning_review_pass1_task_id] }) TaskCreate({ subject: "CC10X plan-gap-reviewer: Fresh review pass 2", description: "wf:{workflow_uuid}\nkind:agent\norigin:router\nphase:plan-review-gap-2\nplan:N/A\nscope:N/A\nreason:Fresh anti-anchoring review of saved plan (pass 2)\n\nOnly run if the re-plan task produces a revised saved plan after pass 1 findings.", activeForm: "Fresh-reviewing revised plan" }) -> planning_review_pass2_task_id TaskUpdate({ taskId: planning_review_pass2_task_id, addBlockedBy: [planner_replan_task_id] }) TaskCreate({ subject: "CC10X Memory Update: Index plan in memory", description: "wf:{workflow_uuid}\nkind:memory\norigin:router\nphase:memory-finalize\nplan:N/A\nscope:N/A\nreason:Persist captured Memory Notes\n\nROUTER ONLY: execute inline. Read the workflow artifact and THIS task description payload, persist to .claude/cc10x/v10/*.md, then remove the matching [cc10x-internal] memory_task_id line from activeContext.md ## References. Never spawn Task() for this task.", activeForm: "Indexing plan in memory" }) -> memory_task_id TaskUpdate({ taskId: memory_task_id, addBlockedBy: [planner_task_id, planning_review_pass1_task_id, planner_replan_task_id, planning_review_pass2_task_id] }) ``` ### Research tasks Create research tasks only when a workflow explicitly triggers them: Before creating them: - Determine the preferred research path for this session and store it in the workflow artifact `capabilities`. - Preferred web path: - `brightdata+websearch` when Bright Data MCP is available - otherwise `websearch+webfetch` - Preferred GitHub path: - `octocode` when Octocode MCP is available - otherwise `web-only` - Allowed fallbacks always include the built-in Claude Code web tools so research remains plug-and-play. - Increment and record the workflow-scoped round number for the `(wf, reason)` pair. ```text TaskCreate({ subject: "CC10X web-researcher: Research {topic}", description: "wf:{workflow_uuid}\nkind:research\norigin:router\nphase:research-web\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:{research_reason}\n\nTopic: {topic}\nReason: {research_reason}\nFile: docs/research/{date}-{slug}-web.md\nPreferred Backend: {brightdata+websearch or websearch+webfetch}\nAllowed Fallbacks: websearch -> webfetch\nRound: {round_number}", activeForm: "Researching web" }) -> web_task_id TaskCreate({ subject: "CC10X github-researcher: Research {topic}", description: "wf:{workflow_uuid}\nkind:research\norigin:router\nphase:research-github\nplan:{plan_file or 'N/A'}\nscope:N/A\nreason:{research_reason}\n\nTopic: {topic}\nReason: {research_reason}\nFile: docs/research/{date}-{slug}-github.md\nPreferred Backend: {octocode or web-only}\nAllowed Fallbacks: package-docs -> websearch -> webfetch\nRound: {round_number}", activeForm: "Researching GitHub" }) -> github_task_id ``` Research tasks are siblings, never blockers on the workflow parent. The follow-up agent task is blocked on both research tasks. ### Marker rules - BUILD writes `[BUILD-START: wf:{workflow_uuid}]` - DEBUG writes `[DEBUG-RESET: wf:{workflow_uuid}]` - PLAN writes `[PLAN-START: wf:{workflow_uuid}]` ## 7. Dispatcher And Agent Prompt Contract ### Explicit dispatcher | Task Phase / Kind | Agent | |-------------------|-------| | `build-implement` | `cc10x:component-builder` | | `debug-investigate` | `cc10x:bug-investigator` | | `build-review`, `debug-review`, `review-audit`, `re-review` | `cc10x:code-reviewer` | | `build-hunt`, `re-hunt` | `cc10x:silent-failure-hunter` | | `build-verify`, `debug-verify`, `re-verify` | `cc10x:integration-verifier` | | `plan-create`, `re-plan` | `cc10x:planner` | | `plan-review-gap-1`, `plan-review-gap-2` | `cc10x:plan-gap-reviewer` | | `research-web` | `cc10x:web-researcher` | | `research-github` | `cc10x:github-researcher` | | `kind:remfix` + `origin:bug-investigator` | `cc10x:bug-investigator` | | `kind:remfix` + `origin:code-reviewer|silent-failure-hunter|integration-verifier|router` | `cc10x:component-builder` | ### Prompt scaffold for every agent ```text ## Task Context - Task ID: {task_id} - Parent Workflow ID: {workflow_uuid} - Task Phase: {phase} - Plan File: {plan_file or 'None'} - Workflow Scope: wf:{workflow_uuid} - Workflow Artifact: .claude/cc10x/v10/workflows/{workflow_uuid}.json ## User Request {request} ## Requirements {clarified requirements or 'See plan/design files'} ## Memory Summary {brief activeContext summary} ## Project Patterns {User Standards + Common Gotchas, trimmed if needed} ## Domain Context {If UBIQUITOUS_LANGUAGE.md, DOMAIN_GLOSSARY.md, docs/domain/*.md, or project-context.md exist, include content. Otherwise omit section.} ## SKILL_HINTS {router-detected skill list or "None"} ``` Optional sections: - `## Pre-Answered Requirements` for BUILD when router already gathered decisions. - `## Intent Contract` when a plan or design already defined goal, constraints, acceptance criteria, and named scenarios. - `## Research Files` only when at least one research file exists. - `## Research Quality` only when at least one research result exists. - `## Design File` only for planner. - `## Planning Review Findings` only for `re-plan`. - `## Original User Request` only for `plan-gap-reviewer`. - `## Approved Context Files` only for `plan-gap-reviewer`. - `## Previous Agent Findings` only for integration-verifier and only after review/hunt phases. ### Deterministic skill hints - Router is the only authority allowed to load internal CC10X skills. - Agents may not self-activate `frontend-patterns`, `architecture-patterns`, or `debugging-patterns`. - Include `cc10x:frontend-patterns` only when the request, changed files, plan, or design clearly targets UI/frontend work. - Include `cc10x:architecture-patterns` only for multi-component, API, schema, auth, or integration-heavy work. - Include `cc10x:research` only when planner or investigator receives `## Research Files`. - Include project/domain skills only from `patterns.md ## Project SKILL_HINTS`. - Skill precedence is strict: 1. explicit user prompt 2. project `CLAUDE.md` / repo standards / user standards 3. approved plan and design docs 4. domain-specific external skills 5. internal CC10X skills 6. model heuristics ### Previous Agent Findings handoff When invoking `integration-verifier`, pass: ```text ## Previous Agent Findings ### Code Reviewer **Verdict:** {Approve|Changes Requested} **Critical Issues:** {reviewer critical issues or "None"} ### Silent Failure Hunter **Critical Issues:** {hunter critical issues or "None / not in this workflow"} ``` DEBUG skips hunter findings. ### Task metrics and timing telemetry - Timing telemetry is measurement only. It must never bypass gates, phase exit, or remediation rules. - After `TaskGet()` / `TaskList()`, if Claude Code exposes task duration metrics, persist them into: - `telemetry.workflow_wall_clock_seconds` - `telemetry.agent_wall_clock_seconds.{agent}` - If task metrics are unavailable, keep `task_metrics_available="unknown"` and continue. Missing telemetry is never a reason to advance or block a workflow. - When `integration-verifier` reports a `### Timing & Workload` section, persist: - `telemetry.verifier.phase_exit_proof_runs` - `telemetry.verifier.extended_audit_runs` - `telemetry.verifier.workload_seconds` - Use telemetry to explain latency. Do not use it to auto-reduce verification scope. ## 8. Post-Agent Validation ### Read-only contracts Primary signal: - Line 1: `CONTRACT {"s":"...","b":...,"cr":...}` Fallback heading on line 2: - `## Review: Approve|Changes Requested` - `## Error Handling Audit: CLEAN|ISSUES_FOUND` - `## Verification: PASS|FAIL` - `## Planning Review: Pass|Findings` Verdict extraction: 1. Try the envelope on line 1. 2. If envelope is missing or malformed, scan the first 5 lines for the heading. 3. Extract `CRITICAL_ISSUES` from `### Critical Issues`. 4. If output is too short or malformed, run inline verification rather than blindly approving. 5. Detect `SELF_REMEDIATED` from task state: - If the task remains `in_progress` and `blockedBy` is non-empty after the agent stops, treat it as self-remediated. 6. For integration-verifier, parse scenario accounting: - `SCENARIOS_TOTAL` - `SCENARIOS_PASSED` - `SCENARIOS_FAILED` - Fail validation if those counts do not reconcile with the evidence array. - Fail validation if any scenario omits explicit `Expected` or `Actual` evidence. Read-only structured intent fields: - `REMEDIATION_NEEDED: true|false` - `REMEDIATION_REASON: …(truncated)