elaborate: define intent and units for methodology-evolution

HAIKU (Human AI Knowledge Unification) — evolving AI-DLC from a
software development methodology into a universal human-AI collaboration
framework for running any business initiative.

8 units:
- HAIKU Foundation (brand, manifesto)
- HAIKU Core Plugin (storage abstraction, 4-phase lifecycle)
- Operation Phase (/operate skill)
- Reflection Phase (/reflect skill)
- HAIKU Paper (methodology articulation)
- AI-DLC Integration (software profile of HAIKU)
- HAIKU Website (haikumethod.ai)
- AI-DLC Updates (website + changelog)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jwaldrip

.ai-dlc/methodology-evolution/discovery.md

@@ -0,0 +1,156 @@
+---
+intent: methodology-evolution
+created: 2026-03-05
+status: active
+---
+
+# Discovery Log: Methodology Evolution
+
+Elaboration findings persisted during Phase 2.5 domain discovery.
+Builders: read section headers for an overview, then dive into specific sections as needed.
+
+
+## Paper Analysis: ai-dlc-2026.md
+
+**Discovered:** 2026-03-05
+
+### Current Phase Structure
+1. **Inception** (Mob Elaboration) — Intent → Units → Completion Criteria → Bolt planning
+2. **Construction** (Bolts) — Execute Units via HITL/OHOTL/AHOTL modes, iterate until criteria met
+3. **Operations** — Deploy, monitor, autonomous response within runbook boundaries
+
+### Terminology That Must Evolve
+| Current (Software) | Needed (Domain-Agnostic) |
+|---|---|
+| Builder (hat) | Executor / Implementer |
+| Construction (phase) | Execution |
+| Code, codebase | Artifacts, Deliverables |
+| Tests, lint, typecheck | Verification gates, Quality checks |
+| Deployment | Release, Operationalization |
+| Backpressure | Quality enforcement |
+| Commit, branch, PR | Checkpoint, version, review |
+
+### What's Missing
+- NO Reflection phase — no structured learning loop
+- NO post-deployment review ritual
+- NO outcome assessment ("did the Intent achieve its goal?")
+- NO organizational learning capture
+- Operations outputs are undefined (Inception and Construction have clear artifacts)
+- Operations section ends at paper line 1052 with no closure ritual
+
+### What's Already Domain-Agnostic
+- The core flow (Intent → Units → Bolts → Checkpoints) is conceptually universal
+- Operating modes (HITL/OHOTL/AHOTL) apply to any human-AI collaboration
+- The "collapse" of traditional phases is a universal principle
+- Completion criteria as a concept work for any domain
+
+### Key Paper Sections for Evolution
+- Phase definitions: lines 824-1000
+- Operating modes: lines 156-246
+- Lifecycle flow/diagram: lines 1056-1088
+- Glossary: lines 1390-1410
+- Operations: lines 1002-1052
+
+
+## Plugin Architecture: Core Structure
+
+**Discovered:** 2026-03-05
+
+### Stats
+- 14 hats, 17 skills, 4 workflows
+- Plugin version: 1.20.6
+- Architecture: Hook-based events + han keep state + git worktrees
+
+### Git Dependency Map (PERVASIVE)
+- **Worktree isolation**: Intent and unit worktrees for parallel work
+- **Branch state**: `han keep` stores iteration.json, scratchpad, blockers on git branches
+- **Branch discovery**: `dag.sh` scans `ai-dlc/*` branches for intents
+- **Remote sync**: Push/pull/upstream tracking in construct skill
+- **Merge strategies**: Unit branches merge to default or intent branch
+- **PR creation**: `gh pr create` in advance skill
+- **VCS abstraction exists** in config.sh (detects jj vs git) but ONLY git is implemented
+
+### Lifecycle (Currently)
+1. `/elaborate` → Write intent.md + unit-*.md to intent worktree
+2. `/construct` → DAG-driven loop: planner → builder → reviewer per unit
+3. Integrator validates all units → mark intent complete → PR/MR
+4. **STOP** — no operation, monitoring, or reflection
+
+### State Storage
+- `iteration.json` (han keep on intent branch): hat, status, workflow, unitStates
+- `scratchpad.md` (han keep on unit branch): progress notes
+- `blockers.md` (han keep on unit branch): blocker context
+- `current-plan.md` (han keep on unit branch): planner output
+- Filesystem: intent.md + unit-*.md frontmatter (committed to git)
+
+### Quality Gates (Backpressure)
+- Autonomous: tests, typecheck, lint, build, security scan
+- Enforced via han-plugin.yml Stop hooks
+- Builder hat must run checks after every change
+- Reviewer validates criteria, not code quality (gates already passed)
+
+### Hats: Domain Analysis
+- **Domain-agnostic (11/14)**: planner, builder, reviewer, integrator, red-team, blue-team, observer, hypothesizer, experimenter, analyst, test-writer
+- **Software-specific (3/14)**: designer (UI/UX), implementer, refactorer
+- Builder hat has discipline-awareness (frontend/backend/docs → different agent types)
+
+### Workflows
+- `default`: planner → builder → reviewer
+- `adversarial`: planner → builder → red-team → blue-team → reviewer
+- `design`: planner → designer → reviewer
+- `hypothesis`: observer → hypothesizer → experimenter → analyst
+
+
+## Config & Settings: Infrastructure Analysis
+
+**Discovered:** 2026-03-05
+
+### Settings Schema
+- Location: `plugin/schemas/settings.schema.json`
+- Sections: VCS strategy (git/jj), Providers, Mockup format
+- Config precedence: intent frontmatter > repo settings > built-in defaults
+
+### Provider System (4 categories)
+- **Ticketing**: Jira, Linear, GitHub Issues, GitLab Issues
+- **Spec**: Notion, Confluence, Google Docs
+- **Design**: Figma
+- **Comms**: Slack, Teams, Discord
+- Each has a JSON schema, instruction file, and 3-tier loading (built-in → inline → project override)
+
+### State Persistence (han keep)
+- Branch-scoped: intent state on intent branch, unit state on unit branch
+- Keys: iteration.json, scratchpad.md, blockers.md, current-plan.md, next-prompt.md
+- Cross-branch access via --branch flag
+- **Entirely git-dependent** — no fallback for non-git environments
+
+### DAG System (dag.sh, 704 lines)
+- Declarative dependencies in unit frontmatter `depends_on:`
+- Functions: find_ready_units, find_blocked_units, are_deps_completed
+- Fast YAML extraction (no subprocess overhead)
+- Status flow: pending → in_progress → completed (or blocked)
+
+### Hook System (4 hooks)
+- SessionStart: inject-context.sh (652 lines) — loads state, displays context
+- SubagentPrompt: subagent-context.sh (300 lines) — scopes context for subagents
+- PreToolUse: redirect-plan-mode.sh — intercepts /plan → /elaborate
+- Stop: enforce-iteration.sh — checks if work remains, prompts /construct
+
+### Key Infrastructure Files
+| File | Lines | Purpose |
+|---|---|---|
+| plugin/lib/config.sh | 559 | Config loading, VCS detection, provider system |
+| plugin/lib/dag.sh | 704 | DAG resolution, unit status tracking |
+| plugin/hooks/inject-context.sh | 652 | SessionStart context injection |
+| plugin/hooks/subagent-context.sh | 300 | Subagent context scoping |
+| plugin/skills/construct/SKILL.md | 1117 | Core construction loop |
+| plugin/skills/elaborate/SKILL.md | ~900 | Mob elaboration workflow |
+| plugin/skills/advance/SKILL.md | ~150 | Hat progression + merge |
+
+### What Must Change for Git-Optional
+1. han keep needs a file-based fallback (folder mode)
+2. Worktree isolation needs folder-based alternative (subdirectories?)
+3. Branch discovery (dag.sh) needs filesystem-only mode
+4. Remote sync (push/pull) must be optional
+5. PR/MR creation must be optional
+6. Config detection must work without .git directory
+

.ai-dlc/methodology-evolution/intent.md

@@ -0,0 +1,93 @@
+---
+workflow: default
+git:
+  change_strategy: intent
+  auto_merge: true
+  auto_squash: false
+announcements: [changelog, release-notes, social-posts, blog-draft]
+created: 2026-03-06
+status: active
+epic: ""
+---
+
+# HAIKU: Evolve AI-DLC into a Universal Human-AI Collaboration Framework
+
+## Problem
+
+AI-DLC is a powerful methodology for AI-driven software development, but its concepts (elaboration, construction, quality gates, iterative execution) are fundamentally domain-agnostic. The methodology is artificially limited by software-specific language, git-dependent infrastructure, and the absence of two critical lifecycle phases: Operation (automated management of what was built) and Reflection (learning from outcomes to improve future cycles).
+
+Businesses need a universal framework for running any initiative — software, marketing, strategy, operations — through disciplined human-AI collaboration. The current AI-DLC plugin cannot serve this need because it assumes git, hardcodes tests/lint/types as quality gates, and stops at code delivery with no operational or learning phases.
+
+## Solution
+
+Create **HAIKU** (Human AI Knowledge Unification) — a universal human-AI collaboration framework with a 4-phase lifecycle: Elaboration, Execution, Operation, Reflection. HAIKU is the domain-agnostic core; AI-DLC becomes the software development implementation of HAIKU.
+
+Architecture:
+- **HAIKU core plugin** — universal, works in repos (git) and folders (cowork), domain-agnostic hats/gates/workflows
+- **AI-DLC plugin** — extends HAIKU with software-specific features (git worktrees, tests/lint/types, PRs, deployment)
+- **SWARM** — referenced as the marketing/sales validation of HAIKU's universality
+- **haikumethod.ai** — website for the universal framework
+
+## Domain Model
+
+### Entities
+- **HAIKU** — The universal framework. Human AI Knowledge Unification. Domain-agnostic methodology for any structured work.
+- **Phase** — One of four lifecycle stages: Elaboration, Execution, Operation, Reflection. Each has distinct mechanics, artifacts, and quality gates.
+- **Intent** — The thing being accomplished. Domain-agnostic: feature, campaign, strategy, process, research.
+- **Unit** — A discrete piece of work within an intent. Has discipline, dependencies, workflow.
+- **Bolt** — The iteration cycle an agent runs within a unit.
+- **Hat** — A behavioral role (planner, executor, reviewer, etc.). Domain-agnostic.
+- **Workflow** — Ordered sequence of hats defining how a unit progresses.
+- **Quality Gate** — Configurable verification mechanism. Software: tests/lint/types. Marketing: stakeholder sign-off. Domain-specific.
+- **Storage Backend** — How state persists. Git mode (branches/worktrees) or folder mode (subdirectories/files). Auto-detected.
+- **Profile** — A domain-specific implementation of HAIKU. AI-DLC (software), SWARM (marketing/sales), future profiles.
+- **Operational Plan** — Defines what needs to happen to run/manage what was built. Created during Execution, automated during Operation.
+- **Reflection Artifact** — Learnings from a completed cycle. Feeds forward into next iteration and organizational memory.
+
+### Relationships
+- HAIKU defines 4 Phases (Elaboration -> Execution -> Operation -> Reflection -> loop)
+- Profiles implement HAIKU for specific domains (AI-DLC for software, SWARM for marketing)
+- Intent contains Units (DAG-ordered by dependencies)
+- Unit is executed through Bolts, each wearing a Hat from its Workflow
+- Quality Gates validate during Execution (domain-configurable)
+- Execution produces an Operational Plan alongside the deliverable
+- Operation follows the Operational Plan automatically
+- Reflection produces Reflection Artifacts that feed into: (a) next version of same Intent, (b) organizational memory
+- Storage Backend auto-detects: git repo -> git mode, plain folder -> folder mode
+
+### Data Sources
+- **AI-DLC Plugin** (`plugin/`) — 14 hats, 17 skills, 4 hooks, 2 core libs (~2500 lines), 4 workflows
+- **Paper** (`website/content/papers/ai-dlc-2026.md`) — Current methodology (~1400 lines)
+- **Website** (`website/`) — Next.js 15 App Router, static export
+- **Settings/Schemas** (`plugin/schemas/`) — Configuration validation, 8 provider schemas
+- **Discovery log** (`.ai-dlc/methodology-evolution/discovery.md`) — Detailed technical findings from elaboration
+
+### Data Gaps
+- No HAIKU core plugin exists — must be built from scratch (informed by AI-DLC patterns)
+- No Operation phase implementation — conceptual in paper, zero code
+- No Reflection phase — not in paper, not in plugin
+- No folder-based storage — han keep is entirely git-dependent
+- No domain-agnostic quality gate configuration
+
+## Success Criteria
+- [ ] HAIKU framework is defined: Human AI Knowledge Unification, with 4-phase lifecycle
+- [ ] HAIKU methodology paper articulates Elaboration, Execution, Operation, Reflection with domain-agnostic language
+- [ ] HAIKU core plugin works in both git repos and plain folders (auto-detect)
+- [ ] Quality gates are configurable per domain, not hardcoded to tests/lint/typecheck
+- [ ] `/reflect` skill produces reflection artifacts that feed forward into next iteration and org memory
+- [ ] `/operate` skill reads operational plans and automates tasks
+- [ ] AI-DLC plugin extends or depends on HAIKU core for software-specific features
+- [ ] Existing AI-DLC git-based workflows function identically (backward compatibility)
+- [ ] Reflection and Operation phases are opt-in (teams can use Elaboration + Execution only)
+- [ ] Custom quality gates and hats definable per-project without modifying plugin core
+- [ ] Website at haikumethod.ai reflects the universal methodology
+- [ ] Paper includes non-software domain examples (marketing/SWARM validation)
+- [ ] All existing tests pass
+- [ ] Announcements generated: changelog, release notes, social posts, blog draft
+
+## Context
+- HAIKU name: Human AI Knowledge Unification. Domain: haikumethod.ai
+- Japanese-inspired, bushido-adjacent: disciplined structure, intentional form (like haiku poetry)
+- SWARM (Scope Workstreams Accountability Results Memory) — a friend's marketing framework that independently validated the same 4-phase pattern
+- AI-DLC terminology preserved: Intent (epic), Unit (ticket/story), Bolt (sprint iteration)
+- Discovery log contains detailed technical analysis of current plugin architecture, paper content, and config system

.ai-dlc/methodology-evolution/unit-01-haiku-foundation.md

@@ -0,0 +1,67 @@
+---
+status: pending
+depends_on: []
+branch: ai-dlc/methodology-evolution/01-haiku-foundation
+discipline: documentation
+workflow: ""
+ticket: ""
+---
+
+# unit-01: HAIKU Foundation
+
+## Description
+Establish the HAIKU brand identity and create the foundational manifesto that all other units reference. HAIKU = Human AI Knowledge Unification. This unit produces the core document that defines what HAIKU is, why it exists, and how it relates to domain-specific implementations like AI-DLC (software) and SWARM (marketing/sales).
+
+## Discipline
+documentation
+
+## Domain Entities
+- HAIKU (the universal framework)
+- Profile (domain-specific implementations)
+- Phase (the 4-phase lifecycle)
+
+## Data Sources
+- Discovery log at `.ai-dlc/methodology-evolution/discovery.md` — contains detailed analysis of current AI-DLC methodology, paper, and plugin architecture
+- SWARM brief from the user's friend — marketing/sales framework that independently validated the 4-phase pattern
+
+## Technical Specification
+
+### New Repository
+Create a new repository for HAIKU (e.g., `thebushidocollective/haiku-method` or similar). All HAIKU work happens here, NOT in the AI-DLC repo.
+
+### HAIKU Manifesto (`HAIKU.md` at repo root)
+Write the foundational document covering:
+- **What is HAIKU**: Human AI Knowledge Unification — a universal framework for human-AI collaboration
+- **The 4-phase lifecycle**: Elaboration (define intent) -> Execution (do the work) -> Operation (manage what was built) -> Reflection (learn and evolve)
+- **Core principles**: Disciplined structure, iterative refinement, domain-agnostic, learning loops
+- **The profile model**: HAIKU is the universal core. Domain-specific profiles implement it:
+  - AI-DLC = software development profile (git, tests, PRs, deployment)
+  - SWARM = marketing/sales profile (briefs, campaigns, close-outs)
+  - Custom profiles for any domain
+- **Why "HAIKU"**: Japanese-inspired disciplined structure. Like haiku poetry — constrained form that produces clarity. The unification of human creativity and AI capability.
+- **Key terminology**: Intent, Unit, Bolt, Hat, Workflow, Quality Gate, Phase
+- **Domain**: haikumethod.ai
+
+### Naming Constants
+Create a reference file (`brand/naming.md` or similar) with:
+- Full name: HAIKU
+- Expanded: Human AI Knowledge Unification
+- Tagline (suggest options, user confirms)
+- Domain: haikumethod.ai
+- Relationship to AI-DLC and SWARM
+
+## Success Criteria
+- [ ] New HAIKU repository exists with initial structure
+- [ ] HAIKU.md manifesto defines the framework, 4-phase lifecycle, profile model, and terminology
+- [ ] Naming constants document exists with brand identity
+- [ ] The relationship between HAIKU, AI-DLC, and SWARM is clearly articulated
+
+## Risks
+- **Name collision**: Other projects may use "HAIKU" (Haiku OS exists). Mitigation: "HAIKU Method" or "HAIKU Framework" as the full name, "haikumethod.ai" as the domain.
+
+## Boundaries
+This unit does NOT build the plugin, write the paper, or create the website. It establishes the identity that all other units build upon.
+
+## Notes
+- The HAIKU repo should be initialized with a basic structure: `README.md`, `HAIKU.md`, `brand/`, `plugin/`, `paper/`, `website/`
+- Keep the manifesto concise — it's a reference document, not the full paper (that's unit-05)