Given a goal (e.g., "Launch a beta version of the app in 4 weeks"), immediately produce:

1. Goal Tree — the goal broken into sub-goals
2. Task Tree — each sub-goal broken into concrete tasks
3. Execution Order — sequence in which tasks should run
4. Dependency Map — what blocks what
5. Completion Strategy — how to verify the goal is done

No preamble, no clarifying questions unless the goal is truly unparseable — infer reasonable assumptions and state them briefly instead.

Progress:

• Parse the goal statement; extract explicit constraints (deadline, resources, scope)
• Decompose goal into 2-5 sub-goals (Goal Tree)
• Decompose each sub-goal into concrete, atomic tasks (Task Tree)
• Identify dependencies between tasks (Dependency Map)
• Topologically sort tasks into an Execution Order, grouping parallelizable tasks
• Define a Completion Strategy (success criteria + verification method)
• Flag risks, ambiguities, or missing information as assumptions

Step details

1. Goal Tree Root = the stated goal. Children = sub-goals that are necessary and sufficient to achieve it. Keep depth shallow (2-3 levels max) — sub-goals, not tasks, live here.

2. Task Tree Each sub-goal expands into 3-8 atomic tasks. A task is atomic if it can be assigned to a single execution unit (person/agent/script) without further splitting for planning purposes.

3. Dependency Map Express as Task A → Task B (A must complete before B). Distinguish:

• Hard dependency: B cannot start without A's output
• Soft dependency: B is easier/better after A but not blocked

4. Execution Order Group into phases (parallel batches), not just a flat list. Phase N contains all tasks whose dependencies are satisfied by end of Phase N-1.

5. Completion Strategy For each sub-goal: a measurable success criterion + a verification action (test, review, metric check).

Example 1: Input: "Launch a beta version of the app in 4 weeks"

Output:

GOAL TREE
Root: Launch beta in 4 weeks
├── 1. Core feature complete
├── 2. Quality assured
├── 3. Infrastructure ready
└── 4. Beta users onboarded

TASK TREE
1. Core feature complete
   1.1 Finalize feature scope
   1.2 Implement backend endpoints
   1.3 Implement frontend UI
   1.4 Integrate backend + frontend
2. Quality assured
   2.1 Write test cases
   2.2 Run QA pass
   2.3 Fix critical bugs
3. Infrastructure ready
   3.1 Set up staging environment
   3.2 Set up monitoring/logging
   3.3 Prepare deployment pipeline
4. Beta users onboarded
   4.1 Recruit beta testers
   4.2 Write onboarding docs
   4.3 Send invites

DEPENDENCY MAP
1.1 → 1.2, 1.3
1.2, 1.3 → 1.4
1.4 → 2.1
2.1 → 2.2 → 2.3
3.1, 3.2 → 3.3
2.3, 3.3 → 4.3
4.1, 4.2 → 4.3 (soft)

EXECUTION ORDER (phases)
Phase 1 (Week 1): 1.1, 3.1, 3.2, 4.1, 4.2
Phase 2 (Week 2): 1.2, 1.3
Phase 3 (Week 3): 1.4, 3.3
Phase 4 (Week 3-4): 2.1, 2.2, 2.3
Phase 5 (Week 4): 4.3 → Launch

COMPLETION STRATEGY
- Core feature: PR merged + demo passes acceptance checklist
- Quality: 0 critical/high bugs open, test suite passing
- Infra: staging deploy succeeds, monitoring dashboard live
- Onboarding: ≥80% of invited testers activate within 48h

ASSUMPTIONS
- "App" assumed to be web app with existing codebase
- Team size assumed sufficient for parallel phases