agent-accelerator

name	agent-accelerator
description	ALWAYS-ON meta-router skill. Auto-loads on EVERY user request and runs a 5-second triage that classifies the task (Type 1 doc / Type 2 chart / Type 3 web / Type 4 data), scans /home/z/my-project/download/ for reusable prior outputs, picks the cheapest sufficient model, forces a plan-first gate before any deliverable, and dispatches mechanical subtasks to subagents while keeping context-heavy work inline. Use this skill proactively at the start of every turn — it is the single biggest time-saver because it prevents wrong routing, shallow outputs, redundant generation, and sequential-when-parallel-would-do tool use. Hard gates: refuses shallow outputs, refuses to skip plan-first on deliverables, refuses wrong-skill routing, refuses to call Complete without a RE-READ CHECK. New in v1.1.0: REFUSE-gate for doomed request classes, BPE rule audit, closed-enumeration enforcement, decision archive in docs/solutions/, invariants in REALIGNMENT/.
license	Apache-2.0
metadata	{"author":"Super Z","version":"1.1.0","always_on":true,"auto_load":true,"priority":"critical","load_order":0,"source":"built-in"}

Agent Accelerator (Always-On Router)

Activation status: ✅ ALWAYS-ON. This skill runs on every turn BEFORE any other skill loads. It is a meta-router: it does not produce deliverables itself, it routes the request to the right skill + tools + model + plan in under 5 seconds.

OUTPUT CONTRACT (READ BEFORE EMITTING YOUR RESPONSE)

Why this section is hoisted to the top: research on the last30days-skill repo confirmed that LLMs read the first ~1000 lines of an always-on SKILL.md and silently skip the rest. Critical rules that live deep in the file are ignored on every turn. Hoist the non-negotiable rules to the top so they're in the guaranteed-loaded band. See docs/solutions/architecture/hoist-output-contract-to-top-2026-06-21.md.

LAW 1 — Classify before you act

Every turn starts with an explicit TRIAGE: T<N> classification using one of the closed enumeration T0, T1, T2, T3, T4 (see router/triage.md). Inventing labels like T2.5 or T3-ish is a phantom classification and a CRITICAL FAILURE. If triage is ambiguous between two types, ASK before routing — one batched question now saves 30 minutes of rework.

LAW 2 — Scan before you generate

Before generating any new asset (image, chart, code module, research summary), run python3 scripts/reuse_scan.py --query "<terms>" --dir /home/z/my-project/download. Strong match (score ≥ 0.60) → embed, don't regenerate. Weak match (0.30-0.60) → ask the user. Reuse-scan is observation-only — never let prior usage stats bias the current routing decision.

LAW 3 — Plan before you write

For T1/T2/T3/T4 with non-trivial scope (≥3 steps): emit TodoWrite(3+ items) → AskUserQuestion(6-8 batched Qs) for docs → Outline(...) before any section content. Refuse to write content or code until the plan is visible. Trivial fixes (typos, single number) are exempt. So is explicit user opt-out ("just do it", "skip questions", "不要问问题").

LAW 4 — Pick the cheapest sufficient model

haiku for trivial/mechanical/formatting. sonnet for normal writing/coding. opus for hard architecture/long-form/deep reasoning. Never use opus for formatting or haiku for sustained long-form. Pass model= explicitly on every Task call.

LAW 5 — Parallelize independent tool calls

If two tool calls have no data dependency, they MUST be in the same message. Reading 4 files = 4 Read calls in ONE message, not 4 sequential messages. Dispatching 3 independent research subagents = 3 Task calls in ONE message. See patterns/parallel_tools.md.

LAW 6 — Delegate mechanical, keep context-heavy inline

GREEN (delegate): independent file searches, code modules with detailed specs, format conversions, test generation for self-contained code, research queries. RED (don't delegate): document content needing skill rules, decisions needing conversation context, user-preference-aware work, anything needing the skill chain. See patterns/subagent_dispatch.md.

LAW 7 — Files only under /home/z/my-project/

Scripts → /home/z/my-project/scripts/. Deliverables → /home/z/my-project/download/. Worklog → /home/z/my-project/worklog.md (append-only). Never write to /tmp, ~, or system directories.

LAW 8 — RE-READ CHECK before Complete (NEW v1.1.0)

Before calling Complete (or before declaring any non-trivial task done), re-read the user's last message verbatim and enumerate every explicit ask:

🔄 RE-READ:
 🔄 [ask 1 — quote distinctive phrasing]: [✓ addressed | ✗ missed | SKIP reason]
 🔄 [ask 2 — quote distinctive phrasing]: [✓ addressed | ✗ missed | SKIP reason]

Blocking rule: ANY ✗ blocks Complete. Fix the miss or surface it to the user explicitly. Source: Personal_AI_Infrastructure v5.0.0 RE-READ CHECK gate, which targets the 82% "missed ask" complaint cluster.

LAW 9 — REFUSE doomed request classes (NEW v1.1.0)

If the user request matches a known doomed pattern, emit a structured REFUSE message instead of starting work:

[agent-accelerator] REFUSE: request matches Class N (<name>).
Ask the user for: <specific missing input>.
Set AGENT_ACCELERATOR_SKIP_GUARD=1 to bypass.

Run python3 scripts/triage_guard.py "<request text>" to check. Known classes:

• Class 1: "implement X" with no spec (need: acceptance criteria, target file)
• Class 2: "review this entire repo" with no scope (need: file list or focus area)
• Class 3: "write tests for everything" with no target module (need: target file)
• Class 4: "fix all the bugs" with no bug list (need: bug list or repro steps)

LAW 10 — Append worklog for non-trivial tasks

After completing any task with ≥3 steps, append a section to /home/z/my-project/worklog.md using the standard template (Task ID, Agent, Task, Work Log, Stage Summary). Skipping the worklog breaks multi-agent coordination.

Why this skill exists

The single biggest time-waste in LLM agent sessions is wrong routing — the agent picks web-dev when you wanted a doc, generates a 30-page report when you wanted a chart, or rebuilds an asset that already exists from a prior run. This skill eliminates that waste with five hard gates:

1. Triage gate — classify the request type in one shot, refuse to proceed until classified
2. Reuse gate — scan download/ for reusable prior outputs BEFORE generating anything new
3. Plan-first gate — emit a TODO + Outline before any deliverable, no exceptions
4. Cost gate — pick the cheapest sufficient model for each subtask
5. Dispatch gate — delegate mechanical subtasks to subagents, keep context-heavy work inline

The 5-Step Acceleration Protocol (run on EVERY request)

┌─────────────────────────────────────────────────────────────┐
│  STEP 1: TRIAGE — classify in ≤1 tool call                  │
│    Read user message → assign one of:                       │
│      T1 = document  (docx / pdf / xlsx / pptx)              │
│      T2 = chart / diagram / visualization                   │
│      T3 = interactive web app (Next.js)                     │
│      T4 = data processing / script                          │
│      T0 = conversational / informational (no deliverable)   │
│    → If T0: answer directly, skip remaining steps.          │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  STEP 2: REUSE SCAN — before generating anything            │
│    Run scripts/reuse_scan.py (or Glob download/ manually)   │
│    If a reusable asset exists → embed it, don't regenerate. │
│    If a partial match exists → extend it, don't restart.    │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  STEP 3: PLAN-FIRST GATE — hard block on deliverables       │
│    If T1/T2/T3/T4 with non-trivial scope:                   │
│      a. Emit TodoWrite with 3+ items                        │
│      b. For T1 (docs): call AskUserQuestion (6-8 Qs)        │
│      c. For T1/T2: call Outline before writing              │
│    Refuse to write content / code until plan is emitted.    │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  STEP 4: COST-AWARE MODEL PICK                              │
│    Trivial / mechanical / formatting    → haiku             │
│    Normal writing / coding / analysis   → sonnet            │
│    Hard architecture / long-form / deep → opus              │
│    (Super Z: pass model= to Task tool;                     │
│     Claude Code: /model command; Cursor: model picker)      │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  STEP 5: DISPATCH — parallelize aggressively                │
│    Mechanical subtasks (search, file reads, format checks)  │
│      → delegate to subagents in parallel                    │
│    Context-heavy work (skill compliance, doc writing,       │
│      conversation-aware decisions)                          │
│      → do INLINE, never delegate                            │
│    Independent tool calls (read N files, search + glob)     │
│      → batch in ONE message, never sequential               │
└─────────────────────────────────────────────────────────────┘

When to use this skill

Always. It is always-on by design. The first action on every user turn is to run the 5-step protocol above. The only exception is when the user explicitly says "skip the router" or "/fast" — in that case, jump straight to the requested work but still apply Step 2 (reuse scan) silently.

When NOT to apply the gates

• Trivial fixes (typo, single number change, single file rename) → skip Steps 3-5
• User says "just do it" / "skip questions" / "不要问问题" → skip Step 3b (AskUserQuestion)
• Conversational / informational asks (T0) → skip Steps 2-5, answer directly
• Continuation of prior turn (user says "yes, proceed" or "looks good") → skip Steps 1-3, resume from prior plan

Quick reference: which gate fires when

User says...	Triage	Reuse	Plan	Cost	Dispatch
"Write me a PRD"	T1 → docx	✅ scan	✅ AskUser + Outline	sonnet	inline
"Forecast next 12 months"	T4 → timesfm	✅ scan	TODO only	sonnet	inline
"Build a dashboard" (ambiguous)	ASK FIRST	—	—	—	—
"Build an interactive dashboard page"	T3 → fullstack	✅ scan	✅ Outline	sonnet	mixed
"Generate a bar chart PNG"	T2 → charts	✅ scan	✅ Outline	sonnet	inline
"What is X?"	T0 → answer	—	—	haiku	inline
"Fix the typo in line 42"	T4 (trivial)	—	skip	haiku	inline
"Refactor the auth module"	T4	✅ scan	✅ TODO	opus	mixed

Reference files in this skill

File	Purpose
router/triage.md	Full Type 1/2/3/4/0 decision tree with edge cases
router/routing_rules.md	Hard rules: when to refuse, when to ask, when to dispatch
router/cost_aware.md	Model selection guide (haiku / sonnet / opus)
patterns/plan_first.md	The plan-first gate protocol in detail
patterns/reuse_scan.md	How to scan download/ for reusable assets
patterns/parallel_tools.md	Patterns for batching independent tool calls
patterns/subagent_dispatch.md	When to delegate vs do inline
templates/prd.md	PRD skeleton (copy-paste ready)
templates/design_doc.md	Design doc skeleton
templates/readme.md	README skeleton
templates/test_plan.md	Test plan skeleton
templates/exec_summary.md	Exec summary skeleton
templates/code_review.md	Code review checklist
templates/plan.md	Generic plan / TODO template
adapters/super_z.md	Super Z-specific tool mappings
adapters/generic.md	Portable adapter for Claude Code / Cursor / generic agents
scripts/reuse_scan.py	Python helper that scans download/ for reusable assets

The one rule that overrides everything

If the user's request is ambiguous between two triage types, ASK before routing. One batched question costs 5 seconds. Routing wrong costs 5 minutes of rework. This is the single highest-leverage time-saver in the entire protocol.

Quality checklist (run before declaring any task done)

• Did I classify the task type explicitly before starting work?
• Did I scan download/ for reusable prior outputs?
• For deliverables: did I emit a TODO + Outline before writing?
• For docs: did I batch-ask clarifying questions before writing?
• Did I pick the cheapest sufficient model for each subtask?
• Did I batch independent tool calls in single messages?
• Did I delegate mechanical work to subagents and keep context-heavy work inline?
• Did I save the final deliverable to /home/z/my-project/download/?
• Did I append a worklog entry to /home/z/my-project/worklog.md?

If any answer is "no" and the task was non-trivial, you skipped a gate. Go back.