st-generate-tasks

Drive the end-to-end decomposition of an existing Strikethroo plan into atomic Markdown task files.

Inputs

The user supplies the numeric plan ID conversationally.

Operating Procedure

1. Locate the strikethroo root

Run scripts/find-strikethroo-root.cjs from the user's working directory.

If the script exits non-zero, the working directory is not inside an initialized strikethroo workspace. Stop and ask the user to run the project initializer (e.g. npx strikethroo init) before continuing. Do not attempt to generate tasks outside of a valid root.

For every subsequent step, treat the path printed by this script as <root>.

2. Resolve the plan

Run scripts/validate-plan-blueprint.cjs <plan-id> planFile to obtain the absolute path of the plan file. Passing a different field name prints that field alone.

If the script exits non-zero, stop and ask the user to confirm the plan ID. Do not guess a different ID.

3. Load project context

Read these files, in order:

• <root>/config/STRIKETHROO.md — directory conventions for plans, tasks,

and the archive layout.

• The plan body at the path returned by step 2 — this is the contract for

what tasks must exist.

• <root>/config/templates/TASK_TEMPLATE.md — every task file you emit must

conform to this template's frontmatter schema and section structure.

• <root>/config/shared/anti-rationalization.md — apply in step 4.

4. Analyze and decompose the plan

Read the entire plan. Identify all concrete deliverables explicitly stated. Decompose each deliverable into atomic tasks only when genuinely needed.

Task minimization (mandatory):

• Create only the minimum number of tasks necessary. Target a 20–30%

reduction from comprehensive lists by questioning the necessity of each candidate.

• Direct Implementation Only: a task corresponds to an explicit

requirement, not a "nice-to-have".

• DRY Task Principle: each task has a unique, non-overlapping purpose.
• Question Everything: for each task, ask "Is this absolutely necessary

to meet the plan objectives?"

• Avoid Gold-plating: resist comprehensive features the plan does not

require.

Antipatterns to avoid:

• Separating "error handling" from the main implementation when it can be

inline.

• Splitting trivially small operations into multiple tasks (e.g. "validate

input" + "process input" as separate units).

• Adding tasks for "future extensibility" or "best practices" the plan does

not mention.

• Comprehensive test suites for trivial functionality.

Apply <root>/config/shared/anti-rationalization.md to this rationalization table:

5. Apply granularity and skill rules

Each task must be:

• Single-purpose — one clear deliverable.
• Atomic — cannot be meaningfully split further.
• Skill-specific — executable by an agent with 1–2 technical skills.
• Verifiable — has explicit acceptance criteria that include at least one

concrete, runnable verification step (a command plus its expected output, or another observable signal). Never settle for a vague "works correctly".

Skill assignment (kebab-case, automatically inferred from the task's technical requirements):

• 1 skill — single-domain task (e.g. ["css"], ["vitest"]).
• 2 skills — complementary domains (e.g. ["api-endpoints", "database"],

["react-components", "vitest"]).

• 3+ skills indicates the task should be broken down further.

6. Test philosophy: "write a few tests, mostly integration"

When generating test tasks, keep this constraint:

Definition. Meaningful tests verify custom business logic, critical paths, and edge cases specific to this application. Test your code, not the framework or library.

Before writing any test task, read references/test-philosophy.md; it lists what deserves a test and what does not.

Test task creation rules:

• Combine related test scenarios into a single task (e.g. "Test user

authentication flow" not separate tasks for login, logout, validation).

• Favor integration and critical-path coverage over per-method unit tests.
• Avoid one test task per CRUD operation.
• Question whether simple functions need a dedicated test task.

If any test task is generated, restate this section and the reference file verbatim or near-verbatim in that task's "Implementation Notes" so the executing agent applies them.

7. Dependency analysis

For each task, identify:

• Hard dependencies: tasks that MUST complete before this one can start.
• Soft dependencies: tasks that SHOULD complete for optimal execution.

A task B depends on A if B requires A's output or artifacts, modifies code created by A, or tests functionality implemented by A. Validate that the final dependency graph is acyclic.

8. Complexity analysis

For every candidate task, assign a complexity_score (integer 1–10) before writing any file. Read references/complexity-rubric.md before scoring; it defines the four dimensions each band is judged on.

Pre-emission sanity rules — apply these before any task is written:

• 3+ skills assigned → split the task into smaller tasks, each with 1–2 skills.
• Vague acceptance criteria → sharpen them until they include at least one

concrete, runnable verification step.

• Trivially small adjacent tasks → merge them into a single task.
• Score ≥ 8 → decompose further; do not emit as-is.
• Score 6–7 → either sharpen criteria or split; do not emit without an

explicit reason.

Loop-back rule:

After applying split, sharpen, or merge, re-run dependency analysis and re-score the adjusted tasks. Repeat this loop no more than three times. If complexity is still unresolved after three passes, stop and surface the blocker to the user.

9. Allocate task IDs

Run scripts/get-next-task-id.cjs <plan-id> to obtain the first available task ID. Allocate subsequent IDs by incrementing in-process; do not invoke the script repeatedly. Use the unpadded integer in the task frontmatter id field and the zero-padded form ({padded-id}--{slug}) for the filename.

The slug derives from a short task title: lowercase, alphanumeric and hyphens only, collapsed, trimmed.

10. Emit the task files

Write each task to:

<root>/plans/<plan-dir-name>/tasks/{padded-id}--{slug}.md

Each file must conform to <root>/config/templates/TASK_TEMPLATE.md. Read references/task-frontmatter.md when filling the frontmatter; it lists every field, its type, and when the optional ones apply.

The body sections (Objective, Skills Required, Acceptance Criteria, Technical Requirements, Input Dependencies, Output Artifacts, Implementation Notes) must be filled with task-specific content. Place detailed implementation guidance inside a <details> block under "Implementation Notes" — write it so a non-thinking LLM could execute the task from that section alone.

11. Validation checklist

Before declaring task generation complete, verify:

• Each task has 1–2 appropriate technical skills assigned and inferred from

its objectives.

• Dependencies form an acyclic graph; no orphan or circular references.
• Task IDs are unique, sequential, and start from the value returned by

get-next-task-id.cjs.

• Groups are consistent and meaningful.
• Every task's Acceptance Criteria includes at least one concrete, runnable

verification step (command + expected output / observable signal), not a vague "works correctly".

• Every explicitly stated deliverable in the plan is covered.
• No redundant or overlapping tasks.
• Minimization applied (20–30% reduction target).
• Test tasks focus on business logic, not framework functionality.
• No gold-plating: only plan requirements are addressed.
• After writing the task files, run

scripts/validate-plan-blueprint.cjs <plan-id> complexityScoresValid. Stop unless it prints yes; if it prints no, run scripts/validate-plan-blueprint.cjs <plan-id> invalidComplexityTasks to see which files are missing, non-integer, or out-of-range, fix them, and re-run.

12. Route task execution

Read <root>/config/hooks/TASKEXECUTIONROUTING.md and follow its instructions together with this procedure:

1. Run scripts/route-task-execution.cjs profiles <plan-id> and interpret

its JSON result. On no-config or disabled, routing is off: skip the remaining routing steps and continue. On invalid-config, stop and surface the errors to the user — do not generate the blueprint.

1. Classify every task in the plan's tasks/ directory against the

configured profile descriptions. For tasks generated in this run, use the task content already in your context — objective, acceptance criteria, technical requirements, skills, and complexity_score; do not reread the emitted task files to reconstruct information you already hold. If the plan carried task files from an earlier generation run, read those files (and only those) to classify them — the mapping must cover every task in the plan. Assign each task ID exactly one configured profile name. Never invent a profile name, model, or harness.

1. Write the complete task-ID-to-profile mapping as a JSON object to a

temporary file, for example {"1": "routine", "2": "demanding"}.

1. Run

scripts/route-task-execution.cjs apply <plan-id> <mapping-file>. The helper validates the mapping (every task exactly once, only configured profiles), writes one execution_profile frontmatter field per task, and verifies the written files. Target selection and resolver execution happen later at task dispatch, never during generation.

1. On routed, delete the temporary mapping file and continue. On any

failure result (invalid-assignments, invalid-tasks, routing-failure, infrastructure-failure), stop and surface the JSON errors to the user. Never proceed to blueprint generation with partially routed tasks.

Profile names are durable routing labels. Persist them only through the helper's execution_profile field; never hand-write a concrete execution target into task frontmatter or task bodies.

13. Run the POSTTASKGENERATION_ALL hook

Read <root>/config/hooks/POSTTASKGENERATION_ALL.md and follow its instructions. Run it only after routing succeeded or reported routing off. This typically requires:

• Appending an Execution Blueprint section to the plan document, including a

Mermaid dependency diagram and explicit phase groupings (Phase 1 contains zero-dependency tasks; each subsequent phase contains tasks whose dependencies all live in earlier phases). Use <root>/config/templates/BLUEPRINT_TEMPLATE.md for structure.

14. Emit the structured summary

Conclude with exactly this block as the final output:

---
Task Generation Summary:
- Plan ID: [numeric-id]
- Tasks: [count]
- Status: Ready for execution

The summary is consumed by downstream automation; keep the format exact.

Failure Modes

• User declines to clarify a blocking ambiguity. Mark the affected tasks

with status: "needs-clarification" and document the open question in the task's "Implementation Notes". Do not invent answers.

• A helper script fails unexpectedly. Surface stderr to the user and

stop — do not fall back to manual ID allocation or path discovery.