next-move

license	Apache-2.0
name	next-move
description	Predicts the highest-impact next action for your project by running a 5-agent meta-DAG pipeline. Gathers project signals automatically (git, recent files, port-daddy, CLAUDE.md), then runs sensemaker → decomposer → skill-selector + premortem → synthesizer. When execution is approved, convert each predicted node into a skillful node prompt using skillful-node-prompt + skillful-subagent-creator, prefer live WinDAGs visualization backed by POST /api/execute and /ws/execution/:id, and fall back to ASCII only when live visualization is unavailable. Activate on: "what should I do", "what's next", "next move", "/next-move", "where should I focus", "what's the highest impact thing right now". NOT for: creating skills, debugging one specific bug, or promising topology-specific runtime behavior the current server cannot execute.
allowed-tools	["Read","Grep","Glob","Agent","Bash(git:*)","Bash(pd:*)","Bash(find:*)","Bash(ls:*)","Bash(head:*)","Bash(cat:*)","Bash(wg:*)","Bash(node:*)","Bash(pnpm:*)","Bash(open:*)","Bash(curl:*)","mcp__windags__windags_skill_search","mcp__windags__windags_skill_graft","mcp__windags__windags_skill_reference","mcp__windags__windags_history"]
metadata	{"category":"Agent & Orchestration","tags":["planning","decision-making","meta-dag","skill-selection","context-analysis","sub-agents","live-execution"],"pairs-with":[{"skill":"windags-sensemaker","reason":"Problem classification and halt gate"},{"skill":"windags-decomposer","reason":"Three-pass decomposition protocol"},{"skill":"windags-premortem","reason":"Failure pattern scanning"},{"skill":"task-decomposer","reason":"Breaks recommended moves into executable subtasks"},{"skill":"skillful-node-prompt","reason":"Defines the 4-branch execution prompt structure for every node"},{"skill":"skillful-subagent-creator","reason":"Defines role boundaries, equipped skills, and node input/output contracts"},{"skill":"output-contract-enforcer","reason":"Downstream nodes need explicit structured outputs, not vibes"},{"skill":"human-gate-designer","reason":"Approval nodes should become actual gates, not free-text TODOs"},{"skill":"reactflow-expert","reason":"Live DAG visualization should match execution state, not a separate mock"}],"argument-hint":"[--fresh] [focus hint]","user-invocable":true}

/next-move

Predict the best next move, present it clearly, and — on approval — hand it to the real WinDAGs execution path.

Two operating rules are mandatory:

1. Separate planning topology from runtime topology. Server execution is real for dag and workflow. team-loop, swarm, blackboard, team-builder, and recurring fall back to generic DAG execution. See references/runtime-honesty.md.

2. Prefer live WinDAGs visualization over ASCII when execution is going to happen. ASCII is fallback only. See references/live-execution-visualization.md.

Arguments: $ARGUMENTS

If the user passed --fresh, ignore conversation history and predict from project signals only.

Skill Layout

This skill is structured for on-demand loading. Don't bulk-load — pull only what the current stage needs.

Need	Load
Decision tree, file map, top-level guidance	INDEX.md
Per-agent prompts (Sensemaker, Decomposer, etc.)	prompts/<agent>.md
Operational rules and judgment-call guidance	references/<topic>.md (see references/INDEX.md)
Worked end-to-end walkthroughs	examples/<NN>-<scenario>.md (only when shape recognition is needed)
Output schemas for validation	schemas/<output>.schema.json
Empty starting structures	templates/<output>.template.<ext>
Replay / validate / inspect-attribution utilities	scripts/<utility>.{sh,ts}
Direct invocation of a single meta-DAG stage	agents/<stage>.md (subagent for Task tool)

Project Signals

These are preprocessed at skill-load time via !... shell calls. Treat them as ground truth.

Git State

!`git status --short 2>/dev/null || echo "Not a git repo"`

Branch: !git branch --show-current 2>/dev/null || echo "unknown"

Recent Commits

!`git log --oneline -8 2>/dev/null || echo "No commits"`

What Changed

!`git diff --stat 2>/dev/null || echo "No unstaged changes"`

Staged Changes

!`git diff --cached --stat 2>/dev/null || echo "Nothing staged"`

Recently Modified Files

!`git diff --name-only HEAD~3 2>/dev/null || echo "No recent file changes"`

CLAUDE.md

!`head -60 CLAUDE.md 2>/dev/null || echo "No CLAUDE.md found"`

Package / Project Info

!`cat package.json 2>/dev/null | head -40 || echo "No package.json"`

Port Daddy

!`pd find 2>/dev/null || echo "Port Daddy not installed. portdaddy.dev"`

!`pd notes 2>/dev/null || echo ""`

!`pd salvage 2>/dev/null || echo ""`

!`pd whoami 2>/dev/null || echo ""`

Prior WinDAGs Predictions

!`ls -1t .windags/triples/ 2>/dev/null | head -5 || echo "No prior predictions"`

Decision Flow

flowchart TD
  A[Gather signals + conversation context] --> B[Sensemaker]
  B --> C{Halt gate?}
  C -->|trip| D[Halt: name the contradiction\nload templates/halt-gate-response.template.md]
  C -->|pass| E[Decomposer]
  E --> F[Skill narrowing via SkillSearchService]
  F --> G[Skill Selector + PreMortem in parallel]
  G --> H[Synthesizer: planning + runtime topology]
  H --> I{Execution likely?}
  I -->|yes| J[Open live WinDAGs surface]
  I -->|no| K[Plan-only preview]
  J --> L[Accept / Modify / Change topology / Reject]
  K --> L
  L -->|Accept| M[Build skillful nodes\nload references/skillful-node-execution.md]
  L -->|Modify| N[Mutate vs restart\nload references/modify-vs-restart.md]
  L -->|Change topology| O[Re-evaluate runtime honesty\nload references/runtime-honesty.md]
  L -->|Reject| P[Record rejection in triple]
  M --> Q[Execute through real runtime]

For depth on any decision point, load the matching reference. Don't try to derive judgment-call rules from the diagram alone.

Core Workflow (Compact)

The full workflow is in the references; this is the lookup version.

1. Sensemaker → Load prompts/sensemaker.md. Validate output against schemas/sensemaker-output.schema.json.
2. Halt gate → Apply references/halt-gate-discipline.md. If trips: render templates/halt-gate-response.template.md, store no triple, stop.
3. Decomposer → Load prompts/decomposer.md. 3-7 subtasks. Validate against schemas/decomposer-output.schema.json.
4. Skill narrowing → Use mcp__windags__windags_skill_search (routes through SkillSearchService). See references/skill-narrowing-cascade.md for internals.
5. Skill Selector + PreMortem → Load prompts/skill-selector.md and prompts/premortem.md. Run in parallel.
6. Synthesize → Apply references/topology-selection.md and references/runtime-honesty.md. Validate against schemas/predicted-dag.schema.json.
7. Present → Live WinDAGs UI preferred. See references/live-execution-visualization.md.
8. Execute on accept → Build skillful nodes. See references/skillful-node-execution.md and prompts/execution-node.md.
9. Modify / restart → See references/modify-vs-restart.md.
10. Store triple → Write to .windags/triples/. See references/triple-feedback-loop.md.

When to Refuse

/next-move halts on ambiguity. Halts are first-class output, not failure. See references/halt-gate-discipline.md. Worked example: examples/03-halt-gate-tripped.md.

When Things Look Wrong

Catalog of failure modes with detection signals and fixes: references/failure-modes.md.

Worked Examples

Load only when you need shape recognition end-to-end:

• examples/01-feature-delivery-happy-path.md — clean signals, native DAG
• examples/02-debugging-blackboard-shape.md — runtime honesty in practice
• examples/03-halt-gate-tripped.md — pipeline correctly refuses

Quality Gates

Before sending the prediction:

• Sensemaker, Decomposer, Skill Selector, PreMortem all returned valid structured output
• Halt gate enforced when ambiguity remained
• Planning topology and runtime topology both present and honest
• Every node has a primary skill, input contract, output contract, and commitment_level
• Approval steps modeled as real gates (human-gate-designer), not prose
• Live visualization attempted before falling back to ASCII
• Triple stored only on completion or user feedback (never on halt)

NOT-FOR Boundaries

• Creating skills → use skill-creator or skill-architect
• One-off bug debugging → use fullstack-debugger
• Promising native execution of unsupported topologies → see references/runtime-honesty.md
• ASCII theater when live UI is available → open the real surface
• Ad hoc subagent prompts → use prompts/execution-node.md and references/skillful-node-execution.md