A future-driven meta-prompting engine for agentic development.
Forked from GSD (Get Shit Done) — replaces linear phase-based planning with a three-layer DAG rooted in declared futures.
npx declare-cc@latestDeclare what's true when this succeeds. The system derives the rest backward.
Most planning tools start from the present and work forward — "what should we do first?" Declare starts from the future and works backward — "what must be true for this to succeed?"
You declare present-tense statements of fact about your project's future. The system derives milestones ("what must be true?") and actions ("what must be done?") through causal structure, then executes them in topological order with wave-based parallelism.
Built on the Erhard/Jensen/Zaffron ontological model:
- Integrity as wholeness and completeness (not morality)
- Alignment as shared future (not agreement)
- Performance as the product of both
This is a fork of GSD. It carries forward GSD's agent orchestration, slash command patterns, esbuild bundling, markdown artifacts, and atomic git commits — but replaces the linear phase model with a declarative graph structure. See Fork Boundary for details.
/declare:init
Scaffolds the project structure: FUTURE.md, MILESTONES.md, .planning/ directory, and the graph config. Installs slash commands if needed.
/declare:future
A guided conversation captures 3-5 declarations about your project's future. Each declaration is a present-tense statement of fact — not a goal, not a wish.
The system detects past-derived language ("I want to avoid...", "We need to fix...") and uses Socratic reframing to help you declare from the future rather than react to the past.
Creates: FUTURE.md with declarations (D-01, D-02, ...)
/declare:milestones
Works backward from declarations: "What must be true for D-01 to hold?" Each milestone maps to one or more declarations through causal edges in the DAG.
Creates: MILESTONES.md with milestones (M-01, M-02, ...)
/declare:plan M-01 # Research → plan → verify loop (planner + checker agents)
/declare:execute M-01 # Wave-based execution with parallel agents
The planner agent derives concrete actions, the checker agent validates them, and the executor runs them in topological waves. Each action gets its own atomic commit.
Creates: .planning/milestones/M-XX-*/PLAN.md and EXEC-PLAN-*.md files
/declare:verify M-01 # Conversational UAT — validates deliverables
/declare:audit M-01 # Cross-reference actions against declarations
node dist/declare-tools.cjs sync-status # Propagate DONE bottom-up through the graph
sync-status walks the DAG bottom-up: marks actions DONE (by file existence or milestone status), then milestones (all actions DONE), then declarations (all milestones DONE). Run it after any verification pass.
Understand your graph at any point:
/declare:trace A-03 # Why does this action exist? Walk the why-chain up to its declaration
/declare:visualize # ASCII tree of the full DAG with status markers
/declare:prioritize M-01 # Rank actions by unblocking power (dependency weight)
/declare:status # Layer counts, health indicators, integrity/alignment metrics
/declare:dashboard # Live interactive DAG in the browser
Declarations (D-XX) "What is true when this succeeds"
│
▼
Milestones (M-XX) "What must be true" (derived backward)
│
▼
Actions (A-XX) "What must be done" (derived backward)
Each layer connects to the one above through causal edges. Every action traces back to a declaration. Orphan nodes (actions without a milestone, milestones without a declaration) are detected and flagged.
The graph engine (DeclareDag) uses dual adjacency lists for O(1) bidirectional lookups — trace upward (why-chains) or traverse downward (what depends on this) with equal efficiency.
/declare:dashboard
Starts a local server and opens an interactive browser view of your full graph. Nodes are rendered in three layers (Declarations → Milestones → Actions) with live status colors.
Focus mode: Click any node to filter the graph to its causal chain. The surrounding nodes slide out, the relevant subtree centers itself with smooth FLIP animations. Click again or press Esc to exit.
Sidebar: Click any node to see its full causal chain — declaration → milestone → action — with context and status. Chain nodes are clickable.
Status colors: DONE nodes retain their type hue (dimmed blue for declarations, dimmed purple for milestones, dimmed green for actions) so the graph stays readable as a living document rather than collapsing to grey.
Declare doesn't just track what's done — it tracks whether commitments are being honored.
Every node in the graph has an integrity status:
| Status | Meaning |
|---|---|
KEPT |
Commitment fulfilled as declared |
HONORED |
Commitment couldn't be kept, but the honor protocol was followed |
BROKEN |
Commitment not fulfilled, no acknowledgment |
RENEGOTIATED |
Commitment explicitly changed through renegotiation flow |
The honor protocol for a commitment you can't keep: acknowledge the break, inform affected parties, clean up the mess, renegotiate a new commitment. This matches the Erhard/Jensen model — integrity isn't about being perfect, it's about restoring wholeness when things break.
- Drift detection — Are current actions still aligned with declared futures?
- Occurrence checks — AI verifies declarations still hold at milestone completion
- Performance scoring — Alignment × Integrity as qualitative HIGH/MEDIUM/LOW (never numeric scores)
- Renegotiation flow — When a declaration no longer fits, renegotiate it into
FUTURE-ARCHIVE.md
| Command | What it does |
|---|---|
/declare:init |
Scaffold project structure and install commands |
/declare:future |
Guided conversation to capture declared futures |
/declare:milestones |
Derive milestones backward from declarations |
/declare:actions [M-XX] |
Derive actions for a milestone |
/declare:plan [M-XX] |
Research → plan → verify loop (planner + checker agents) |
/declare:execute [M-XX] |
Wave-based execution with parallel agents |
| Command | What it does |
|---|---|
/declare:discuss [M-XX] |
Gather milestone context through adaptive questioning |
/declare:research [M-XX] |
Spawn 4 parallel researchers, synthesize into RESEARCH.md |
/declare:map-codebase |
Parallel codebase analysis → .planning/codebase/ docs |
| Command | What it does |
|---|---|
/declare:verify [M-XX] |
Conversational UAT — validates deliverables, spawns debuggers on failure |
/declare:audit [M-XX] |
Cross-reference actions against declarations, identify gaps |
/declare:debug |
Systematic debugging with scientific method and checkpoint persistence |
| Command | What it does |
|---|---|
/declare:trace <node> |
Walk the why-chain from any node up to its declaration |
/declare:visualize |
ASCII tree of the full DAG with status markers |
/declare:prioritize [M-XX] |
Rank actions by dependency weight (unblocking power) |
/declare:status |
Graph health, layer counts, integrity and alignment metrics |
/declare:dashboard |
Live interactive DAG in the browser |
| Command | What it does |
|---|---|
/declare:quick |
Ad-hoc task with atomic commit, outside milestone structure |
/declare:add-todo |
Capture an idea or task for later |
/declare:check-todos |
List pending todos, route to milestone or quick task |
| Command | What it does |
|---|---|
/declare:progress |
Current position, recent work summary, route to next action |
/declare:pause |
Snapshot work state to .continue-here.md for safe handoff |
/declare:resume |
Restore full context from previous session |
| Command | What it does |
|---|---|
/declare:new-project |
Deep context gathering, PROJECT.md + STATE.md creation |
/declare:new-milestone |
Archive declarations, reset for next milestone cycle |
/declare:complete-milestone |
Snapshot graph, tag release, prepare next cycle |
| Command | What it does |
|---|---|
/declare:health |
Diagnose .planning/ directory health, repair issues |
/declare:settings |
Configure workflow toggles interactively |
/declare:set-profile |
Switch model profile (quality / balanced / budget) |
/declare:update |
Update to latest npm version with local-patch preservation |
/declare:reapply-patches |
Reapply local modifications after an update |
/declare:help |
Show all commands |
FUTURE.md # Declared futures (D-01, D-02, ...)
MILESTONES.md # Derived milestones (M-01, M-02, ...)
.planning/
├── PROJECT.md # Project context and goals
├── STATE.md # Current work state
├── config.json # Project settings
├── milestones/
│ └── M-XX-slug/
│ ├── PLAN.md # Actions for this milestone
│ ├── EXEC-PLAN-*.md # Per-action execution plans
│ └── VERIFICATION.md # Integrity proof after execution
└── codebase/ # Codebase analysis artifacts
agents/ # Declare-specific agent definitions
├── declare-planner.md
├── declare-plan-checker.md
├── declare-researcher.md
├── declare-research-synthesizer.md
├── declare-codebase-mapper.md
└── declare-debugger.md
workflows/
├── discuss.md # Context capture workflow
└── verify.md # UAT workflow
dist/declare-tools.cjs # Bundled CLI (zero runtime deps)
src/ # Source (Node.js, CJS)
├── graph/engine.js # DeclareDag — dual adjacency lists, Kahn's sort
├── artifacts/ # Markdown parsers/writers
├── commands/ # CLI command implementations
└── server/ # DAG web server + dashboard frontend
npx declare-cc@latestOr clone and install locally:
git clone https://github.com/decocms/declare-cc.git
cd declare-cc
node bin/install.js --claude --localRequires Node.js 18+.
/declare:init # Scaffold the project
/declare:future # Declare 3-5 futures
/declare:milestones # Derive milestones backward
/declare:plan M-01 # Research + plan first milestone
/declare:execute M-01 # Execute with wave scheduling
/declare:dashboard # View the live DAG
Declare spawns agents and runs CLI tools frequently. For frictionless operation:
claude --dangerously-skip-permissionsAlternative: Granular Permissions
Add to .claude/settings.json:
{
"permissions": {
"allow": [
"Bash(node:*)",
"Bash(git add:*)",
"Bash(git commit:*)",
"Bash(git status:*)",
"Bash(git log:*)",
"Bash(git diff:*)"
]
}
}Actions are grouped into waves based on their dependencies in the DAG. Within each wave, independent actions run in parallel via spawned agents. Waves run sequentially.
WAVE 1 (parallel) WAVE 2 (parallel) WAVE 3
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ A-01 │ │ A-02 │ │ A-03 │ │ A-04 │ │ A-05 │
│ Schema │ │ Auth │→ │ API │ │ Storage │→ │ UI │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
│ │ ↑ ↑ ↑
└───────────┴──────────────┴───────────┘ │
A-03 needs A-01, A-04 needs A-02 │
A-05 needs A-03 + A-04 │
Each agent gets a fresh context window. Your main session stays light.
The DAG maintains status consistency bottom-up. Run sync-status after any verification pass:
Actions → check produced files exist → mark DONE
↓
Milestones → all actions DONE → mark DONE
↓
Declarations → all milestones DONE → mark DONE
Every action gets its own commit:
feat(M-01): create database schema
feat(M-01): implement auth service
feat(M-01): build API endpoints
Git bisect finds the exact failing action. Each action is independently revertable.
The entire CLI bundles to a single dist/declare-tools.cjs via esbuild. No node_modules at runtime.
Declare is forked from GSD (Get Shit Done), a meta-prompting and context engineering system for Claude Code.
- Agent orchestration — Planner, executor, researcher, verifier agent patterns
- Slash command interface —
.claude/commands/directory, markdown meta-prompts - esbuild bundling — Single-file CJS distribution, zero runtime deps
- Markdown artifacts —
.planning/directory as source of truth - Atomic git commits — Every state change produces a traceable commit
- Context engineering — Fresh context per agent, structured XML plans
| GSD | Declare | Why |
|---|---|---|
| Linear phases (1, 2, 3...) | Three-layer DAG (D → M → A) | Phases are past-derived sequencing; DAGs represent causal structure |
ROADMAP.md |
FUTURE.md + MILESTONES.md |
The present is given by the future you're living into |
STATE.md tracking |
Graph node statuses | Status lives in the graph, not a separate file |
| Sequential execution | Topology-aware wave scheduling | Actions execute in causal order, not linear sequence |
| Phase numbers | Milestone IDs (M-XX) | Milestones derive from declarations, not arbitrary ordering |
MIT License. See LICENSE for details.
Declare the future. Derive backward. Execute with integrity.