Obedience-Corp/festival

# Camp Navigation

Use `cgo` for interactive directory changes and `camp go --print` for scripts.

## Primary Commands

```bash
cgo                  # toggle camp root <-> last location
cgo p                # projects/
cgo f                # festivals/
cgo i                # .campaign/intents/ (intents)
cgo cr               # workflow/code_reviews/
cgo p camp           # projects/camp/
```

# Camp Projects

A camp was previously called a campaign; project commands work the same either way.

## Commit in Submodules

```bash
camp p commit -m "fix: message"
```

Pointer sync is intentional and root-level:

```bash
camp refs-sync

# Camp Workitems

Use `camp workitem` to find current camp work across intents, workflow
design/explore docs, festivals, and tracked workflow directories.

`camp workitem` is canonical. `camp wi` and `camp workitems` are aliases.

## Discover

Agents and scripts should prefer JSON:

```bash
camp workitem --json
camp workitem --json --type design --query auth

# Camp Commit Decision

A camp was previously called a campaign; this skill applies whichever word the user uses.

## Decision

- Project change (submodule, linked project, or worktree): `camp p commit -m "msg"`
- Festival task execution: `fest commit -m "msg"`
- Camp root files: `camp commit -m "msg"` (stages all root-level changes; submodule refs excluded by default)
- Camp root, scoped to specific paths: `git add <paths>` then `camp commit --all=false -m "msg"` (commits only what is staged)
- Intentional root pointer sync: `camp refs-sync [submodule...]`

## Festival Commits Cover the Linked Project

# Camp Structure

A camp was previously called a campaign; the layout below is the same either way.

## Placement Rules

- Raw idea / bug / future work / quick capture: `.campaign/intents/inbox/` (use `camp intent add`)
- Enriching or preparing for execution: `.campaign/intents/active/`
- Ready for structured work: `.campaign/intents/ready/` → promote to festival
- Structured multi-phase execution: `festivals/`
- Internal design, architecture, or deep exploration: `workflow/design/`
- User-facing documentation: `docs/`
- Research, analysis, and exploration notes: `workflow/explore/`
- Archive / defer / killed: `.campaign/intents/dungeon/` or top-level `dungeon/`

# Camp Workflows

A camp was previously called a campaign; these commands work the same either way.

All workflow commands here are `camp`, not `fest`.

Use `camp` for intents, dungeons, and workflow collections. `fest` is for
festival planning and execution.

## Intents

```bash
camp intent add "idea"
camp intent list

# Cross-Camp Operations

A camp was previously called a campaign; treat the two words as the same thing
whenever the user says either one.

When the user references another camp or a project that isn't in the current
camp, use these commands to locate and access it.

## Discovery

```bash
camp list                    # Show all registered camps with paths
camp list --format json      # JSON output for scripting
camp list --format simple    # Names only

# Festival Execution

## Core Loop

```text
fest next → do work → fest task completed|blocked → fest commit → fest validate → repeat
```

## Link + Navigation

Festival commands from a project directory depend on an active festival-project link.

```bash
# In festival directory: link the execution project path

# Festival Methodology

Festival Methodology is a goal-oriented project management system for human-AI development workflows. It replaces sprints, story points, and time estimates with **steps to goals**.

## Core Concepts

- **Festivals**: Top-level project containers with a specific goal
- **Phases**: Major stages (planning, implementation, review), prefixed `NNN_` (e.g., `001_PLAN/`)
- **Sequences**: Ordered groups of related tasks within a phase, prefixed `NN_` (e.g., `01_setup/`)
- **Tasks**: Atomic work units as markdown files, prefixed `NN_` (e.g., `01_create_schema.md`)

## Hierarchy

```

# Festival Planning

## Start Here

```bash
fest understand methodology
fest understand structure
fest understand tasks
fest understand rules
fest types festival
```

## Naming Rules (Automation-Critical)

# Fest Standalone Workflows

Use a standalone `WORKFLOW.md` when work needs a guided step loop in an ordinary
directory, without setting up a full festival (phases/sequences/tasks).

Thin-start loop:

```text
WORKFLOW.md -> fest next -> do step -> fest workflow advance -> repeat
```

## When to Use This vs. a Full Festival

- **Standalone workflow**: a short, repeatable checklist that can live in any

# Festival Intake

This is the front door. Every other camp skill assumes the user already
knows what a festival is. This one does not, and it must fire before they do.

When it fires, you owe the user the six steps below, in order. Do not skip
straight to creating things.

## Step 1: Size it out loud

Say which gear this is and why, in one line, before doing anything else. The
user learns the system has three gears by watching you pick one.

| Signal | Route |

# Camp Navigation

Use `cgo` for interactive directory changes and `camp go --print` for scripts.

## Primary Commands

```bash
cgo                  # toggle camp root <-> last location
cgo p                # projects/
cgo f                # festivals/
cgo i                # .campaign/intents/ (intents)
cgo cr               # workflow/code_reviews/
cgo p camp           # projects/camp/
```

# Camp Projects

A camp was previously called a campaign; project commands work the same either way.

## Commit in Submodules

```bash
camp p commit -m "fix: message"
```

Pointer sync is intentional and root-level:

```bash
camp refs-sync

# Camp Workitems

Use `camp workitem` to find current camp work across intents, workflow
design/explore docs, festivals, and tracked workflow directories.

`camp workitem` is canonical. `camp wi` and `camp workitems` are aliases.

## Discover

Agents and scripts should prefer JSON:

```bash
camp workitem --json
camp workitem --json --type design --query auth

# Camp Commit Decision

A camp was previously called a campaign; this skill applies whichever word the user uses.

## Decision

- Project change (submodule, linked project, or worktree): `camp p commit -m "msg"`
- Festival task execution: `fest commit -m "msg"`
- Camp root files: `camp commit -m "msg"` (stages all root-level changes; submodule refs excluded by default)
- Camp root, scoped to specific paths: `git add <paths>` then `camp commit --all=false -m "msg"` (commits only what is staged)
- Intentional root pointer sync: `camp refs-sync [submodule...]`

## Festival Commits Cover the Linked Project

# Camp Structure

A camp was previously called a campaign; the layout below is the same either way.

## Placement Rules

- Raw idea / bug / future work / quick capture: `.campaign/intents/inbox/` (use `camp intent add`)
- Enriching or preparing for execution: `.campaign/intents/active/`
- Ready for structured work: `.campaign/intents/ready/` → promote to festival
- Structured multi-phase execution: `festivals/`
- Internal design, architecture, or deep exploration: `workflow/design/`
- User-facing documentation: `docs/`
- Research, analysis, and exploration notes: `workflow/explore/`
- Archive / defer / killed: `.campaign/intents/dungeon/` or top-level `dungeon/`

# Camp Workflows

A camp was previously called a campaign; these commands work the same either way.

All workflow commands here are `camp`, not `fest`.

Use `camp` for intents, dungeons, and workflow collections. `fest` is for
festival planning and execution.

## Intents

```bash
camp intent add "idea"
camp intent list

# Cross-Camp Operations

A camp was previously called a campaign; treat the two words as the same thing
whenever the user says either one.

When the user references another camp or a project that isn't in the current
camp, use these commands to locate and access it.

## Discovery

```bash
camp list                    # Show all registered camps with paths
camp list --format json      # JSON output for scripting
camp list --format simple    # Names only

# Festival Execution

## Core Loop

```text
fest next → do work → fest task completed|blocked → fest commit → fest validate → repeat
```

## Link + Navigation

Festival commands from a project directory depend on an active festival-project link.

```bash
# In festival directory: link the execution project path

# Festival Methodology

Festival Methodology is a goal-oriented project management system for human-AI development workflows. It replaces sprints, story points, and time estimates with **steps to goals**.

## Core Concepts

- **Festivals**: Top-level project containers with a specific goal
- **Phases**: Major stages (planning, implementation, review), prefixed `NNN_` (e.g., `001_PLAN/`)
- **Sequences**: Ordered groups of related tasks within a phase, prefixed `NN_` (e.g., `01_setup/`)
- **Tasks**: Atomic work units as markdown files, prefixed `NN_` (e.g., `01_create_schema.md`)

## Hierarchy

```

# Festival Planning

## Start Here

```bash
fest understand methodology
fest understand structure
fest understand tasks
fest understand rules
fest types festival
```

## Naming Rules (Automation-Critical)

# Fest Standalone Workflows

Use a standalone `WORKFLOW.md` when work needs a guided step loop in an ordinary
directory, without setting up a full festival (phases/sequences/tasks).

Thin-start loop:

```text
WORKFLOW.md -> fest next -> do step -> fest workflow advance -> repeat
```

## When to Use This vs. a Full Festival

- **Standalone workflow**: a short, repeatable checklist that can live in any

# Festival Intake

This is the front door. Every other camp skill assumes the user already
knows what a festival is. This one does not, and it must fire before they do.

When it fires, you owe the user the six steps below, in order. Do not skip
straight to creating things.

## Step 1: Size it out loud

Say which gear this is and why, in one line, before doing anything else. The
user learns the system has three gears by watching you pick one.

| Signal | Route |

# Camp Navigation

Use `cgo` for interactive directory changes and `camp go --print` for scripts.

## Primary Commands

```bash
cgo                  # toggle camp root <-> last location
cgo p                # projects/
cgo f                # festivals/
cgo i                # .campaign/intents/ (intents)
cgo cr               # workflow/code_reviews/
cgo p camp           # projects/camp/
```

# Camp Projects

A camp was previously called a campaign; project commands work the same either way.

## Commit in Submodules

```bash
camp p commit -m "fix: message"
```

Pointer sync is intentional and root-level:

```bash
camp refs-sync

# Camp Workitems

Use `camp workitem` to find current camp work across intents, workflow
design/explore docs, festivals, and tracked workflow directories.

`camp workitem` is canonical. `camp wi` and `camp workitems` are aliases.

## Discover

Agents and scripts should prefer JSON:

```bash
camp workitem --json
camp workitem --json --type design --query auth

# Camp Commit Decision

A camp was previously called a campaign; this skill applies whichever word the user uses.

## Decision

- Project change (submodule, linked project, or worktree): `camp p commit -m "msg"`
- Festival task execution: `fest commit -m "msg"`
- Camp root files: `camp commit -m "msg"` (stages all root-level changes; submodule refs excluded by default)
- Camp root, scoped to specific paths: `git add <paths>` then `camp commit --all=false -m "msg"` (commits only what is staged)
- Intentional root pointer sync: `camp refs-sync [submodule...]`

## Festival Commits Cover the Linked Project

# Camp Structure

A camp was previously called a campaign; the layout below is the same either way.

## Placement Rules

- Raw idea / bug / future work / quick capture: `.campaign/intents/inbox/` (use `camp intent add`)
- Enriching or preparing for execution: `.campaign/intents/active/`
- Ready for structured work: `.campaign/intents/ready/` → promote to festival
- Structured multi-phase execution: `festivals/`
- Internal design, architecture, or deep exploration: `workflow/design/`
- User-facing documentation: `docs/`
- Research, analysis, and exploration notes: `workflow/explore/`
- Archive / defer / killed: `.campaign/intents/dungeon/` or top-level `dungeon/`

# Camp Workflows

A camp was previously called a campaign; these commands work the same either way.

All workflow commands here are `camp`, not `fest`.

Use `camp` for intents, dungeons, and workflow collections. `fest` is for
festival planning and execution.

## Intents

```bash
camp intent add "idea"
camp intent list

# Cross-Camp Operations

A camp was previously called a campaign; treat the two words as the same thing
whenever the user says either one.

When the user references another camp or a project that isn't in the current
camp, use these commands to locate and access it.

## Discovery

```bash
camp list                    # Show all registered camps with paths
camp list --format json      # JSON output for scripting
camp list --format simple    # Names only

# Festival Execution

## Core Loop

```text
fest next → do work → fest task completed|blocked → fest commit → fest validate → repeat
```

## Link + Navigation

Festival commands from a project directory depend on an active festival-project link.

```bash
# In festival directory: link the execution project path

# Festival Methodology

Festival Methodology is a goal-oriented project management system for human-AI development workflows. It replaces sprints, story points, and time estimates with **steps to goals**.

## Core Concepts

- **Festivals**: Top-level project containers with a specific goal
- **Phases**: Major stages (planning, implementation, review), prefixed `NNN_` (e.g., `001_PLAN/`)
- **Sequences**: Ordered groups of related tasks within a phase, prefixed `NN_` (e.g., `01_setup/`)
- **Tasks**: Atomic work units as markdown files, prefixed `NN_` (e.g., `01_create_schema.md`)

## Hierarchy

```

# Festival Planning

## Start Here

```bash
fest understand methodology
fest understand structure
fest understand tasks
fest understand rules
fest types festival
```

## Naming Rules (Automation-Critical)

# Fest Standalone Workflows

Use a standalone `WORKFLOW.md` when work needs a guided step loop in an ordinary
directory, without setting up a full festival (phases/sequences/tasks).

Thin-start loop:

```text
WORKFLOW.md -> fest next -> do step -> fest workflow advance -> repeat
```

## When to Use This vs. a Full Festival

- **Standalone workflow**: a short, repeatable checklist that can live in any

# Festival Intake

This is the front door. Every other camp skill assumes the user already
knows what a festival is. This one does not, and it must fire before they do.

When it fires, you owe the user the six steps below, in order. Do not skip
straight to creating things.

## Step 1: Size it out loud

Say which gear this is and why, in one line, before doing anything else. The
user learns the system has three gears by watching you pick one.

| Signal | Route |

# Camp Navigation

Use `cgo` for interactive directory changes and `camp go --print` for scripts.

## Primary Commands

```bash
cgo                  # toggle camp root <-> last location
cgo p                # projects/
cgo f                # festivals/
cgo i                # .campaign/intents/ (intents)
cgo cr               # workflow/code_reviews/
cgo p camp           # projects/camp/
```

# Camp Projects

A camp was previously called a campaign; project commands work the same either way.

## Commit in Submodules

```bash
camp p commit -m "fix: message"
```

Pointer sync is intentional and root-level:

```bash
camp refs-sync

# Camp Workitems

Use `camp workitem` to find current camp work across intents, workflow
design/explore docs, festivals, and tracked workflow directories.

`camp workitem` is canonical. `camp wi` and `camp workitems` are aliases.

## Discover

Agents and scripts should prefer JSON:

```bash
camp workitem --json
camp workitem --json --type design --query auth

# Camp Commit Decision

A camp was previously called a campaign; this skill applies whichever word the user uses.

## Decision

- Project change (submodule, linked project, or worktree): `camp p commit -m "msg"`
- Festival task execution: `fest commit -m "msg"`
- Camp root files: `camp commit -m "msg"` (stages all root-level changes; submodule refs excluded by default)
- Camp root, scoped to specific paths: `git add <paths>` then `camp commit --all=false -m "msg"` (commits only what is staged)
- Intentional root pointer sync: `camp refs-sync [submodule...]`

## Festival Commits Cover the Linked Project

# Camp Structure

A camp was previously called a campaign; the layout below is the same either way.

## Placement Rules

- Raw idea / bug / future work / quick capture: `.campaign/intents/inbox/` (use `camp intent add`)
- Enriching or preparing for execution: `.campaign/intents/active/`
- Ready for structured work: `.campaign/intents/ready/` → promote to festival
- Structured multi-phase execution: `festivals/`
- Internal design, architecture, or deep exploration: `workflow/design/`
- User-facing documentation: `docs/`
- Research, analysis, and exploration notes: `workflow/explore/`
- Archive / defer / killed: `.campaign/intents/dungeon/` or top-level `dungeon/`

# Camp Workflows

A camp was previously called a campaign; these commands work the same either way.

All workflow commands here are `camp`, not `fest`.

Use `camp` for intents, dungeons, and workflow collections. `fest` is for
festival planning and execution.

## Intents

```bash
camp intent add "idea"
camp intent list

# Cross-Camp Operations

A camp was previously called a campaign; treat the two words as the same thing
whenever the user says either one.

When the user references another camp or a project that isn't in the current
camp, use these commands to locate and access it.

## Discovery

```bash
camp list                    # Show all registered camps with paths
camp list --format json      # JSON output for scripting
camp list --format simple    # Names only

# Festival Execution

## Core Loop

```text
fest next → do work → fest task completed|blocked → fest commit → fest validate → repeat
```

## Link + Navigation

Festival commands from a project directory depend on an active festival-project link.

```bash
# In festival directory: link the execution project path

# Festival Methodology

Festival Methodology is a goal-oriented project management system for human-AI development workflows. It replaces sprints, story points, and time estimates with **steps to goals**.

## Core Concepts

- **Festivals**: Top-level project containers with a specific goal
- **Phases**: Major stages (planning, implementation, review), prefixed `NNN_` (e.g., `001_PLAN/`)
- **Sequences**: Ordered groups of related tasks within a phase, prefixed `NN_` (e.g., `01_setup/`)
- **Tasks**: Atomic work units as markdown files, prefixed `NN_` (e.g., `01_create_schema.md`)

## Hierarchy

```

# Festival Planning

## Start Here

```bash
fest understand methodology
fest understand structure
fest understand tasks
fest understand rules
fest types festival
```

## Naming Rules (Automation-Critical)

# Fest Standalone Workflows

Use a standalone `WORKFLOW.md` when work needs a guided step loop in an ordinary
directory, without setting up a full festival (phases/sequences/tasks).

Thin-start loop:

```text
WORKFLOW.md -> fest next -> do step -> fest workflow advance -> repeat
```

## When to Use This vs. a Full Festival

- **Standalone workflow**: a short, repeatable checklist that can live in any

# Festival Intake

This is the front door. Every other camp skill assumes the user already
knows what a festival is. This one does not, and it must fire before they do.

When it fires, you owe the user the six steps below, in order. Do not skip
straight to creating things.

## Step 1: Size it out loud

Say which gear this is and why, in one line, before doing anything else. The
user learns the system has three gears by watching you pick one.

| Signal | Route |

# Camp Navigation

Use `cgo` for interactive directory changes and `camp go --print` for scripts.

## Primary Commands

```bash
cgo                  # toggle camp root <-> last location
cgo p                # projects/
cgo f                # festivals/
cgo i                # .campaign/intents/ (intents)
cgo cr               # workflow/code_reviews/
cgo p camp           # projects/camp/
```

# Camp Projects

A camp was previously called a campaign; project commands work the same either way.

## Commit in Submodules

```bash
camp p commit -m "fix: message"
```

Pointer sync is intentional and root-level:

```bash
camp refs-sync

# Camp Workitems

Use `camp workitem` to find current camp work across intents, workflow
design/explore docs, festivals, and tracked workflow directories.

`camp workitem` is canonical. `camp wi` and `camp workitems` are aliases.

## Discover

Agents and scripts should prefer JSON:

```bash
camp workitem --json
camp workitem --json --type design --query auth

# Camp Commit Decision

A camp was previously called a campaign; this skill applies whichever word the user uses.

## Decision

- Project change (submodule, linked project, or worktree): `camp p commit -m "msg"`
- Festival task execution: `fest commit -m "msg"`
- Camp root files: `camp commit -m "msg"` (stages all root-level changes; submodule refs excluded by default)
- Camp root, scoped to specific paths: `git add <paths>` then `camp commit --all=false -m "msg"` (commits only what is staged)
- Intentional root pointer sync: `camp refs-sync [submodule...]`

## Festival Commits Cover the Linked Project

# Camp Structure

A camp was previously called a campaign; the layout below is the same either way.

## Placement Rules

- Raw idea / bug / future work / quick capture: `.campaign/intents/inbox/` (use `camp intent add`)
- Enriching or preparing for execution: `.campaign/intents/active/`
- Ready for structured work: `.campaign/intents/ready/` → promote to festival
- Structured multi-phase execution: `festivals/`
- Internal design, architecture, or deep exploration: `workflow/design/`
- User-facing documentation: `docs/`
- Research, analysis, and exploration notes: `workflow/explore/`
- Archive / defer / killed: `.campaign/intents/dungeon/` or top-level `dungeon/`

# Camp Workflows

A camp was previously called a campaign; these commands work the same either way.

All workflow commands here are `camp`, not `fest`.

Use `camp` for intents, dungeons, and workflow collections. `fest` is for
festival planning and execution.

## Intents

```bash
camp intent add "idea"
camp intent list

# Cross-Camp Operations

A camp was previously called a campaign; treat the two words as the same thing
whenever the user says either one.

When the user references another camp or a project that isn't in the current
camp, use these commands to locate and access it.

## Discovery

```bash
camp list                    # Show all registered camps with paths
camp list --format json      # JSON output for scripting
camp list --format simple    # Names only

# Festival Execution

## Core Loop

```text
fest next → do work → fest task completed|blocked → fest commit → fest validate → repeat
```

## Link + Navigation

Festival commands from a project directory depend on an active festival-project link.

```bash
# In festival directory: link the execution project path

# Festival Methodology

Festival Methodology is a goal-oriented project management system for human-AI development workflows. It replaces sprints, story points, and time estimates with **steps to goals**.

## Core Concepts

- **Festivals**: Top-level project containers with a specific goal
- **Phases**: Major stages (planning, implementation, review), prefixed `NNN_` (e.g., `001_PLAN/`)
- **Sequences**: Ordered groups of related tasks within a phase, prefixed `NN_` (e.g., `01_setup/`)
- **Tasks**: Atomic work units as markdown files, prefixed `NN_` (e.g., `01_create_schema.md`)

## Hierarchy

```

# Festival Planning

## Start Here

```bash
fest understand methodology
fest understand structure
fest understand tasks
fest understand rules
fest types festival
```

## Naming Rules (Automation-Critical)

# Fest Standalone Workflows

Use a standalone `WORKFLOW.md` when work needs a guided step loop in an ordinary
directory, without setting up a full festival (phases/sequences/tasks).

Thin-start loop:

```text
WORKFLOW.md -> fest next -> do step -> fest workflow advance -> repeat
```

## When to Use This vs. a Full Festival

- **Standalone workflow**: a short, repeatable checklist that can live in any

# Festival Intake

This is the front door. Every other camp skill assumes the user already
knows what a festival is. This one does not, and it must fire before they do.

When it fires, you owe the user the six steps below, in order. Do not skip
straight to creating things.

## Step 1: Size it out loud

Say which gear this is and why, in one line, before doing anything else. The
user learns the system has three gears by watching you pick one.

| Signal | Route |