## The Algorithm 6.3.0

> Change history, migration recipes, and rollback steps live in `changelog.md` (read on demand). This file is doctrine only — what the Algorithm does this run.

### Doctrine — Read This First, Internalize It

**Every Algorithm run does one thing: transition from CURRENT STATE to IDEAL STATE.** The mechanism: articulate the ideal state as testable criteria (ISCs), pursue them through phases, verify each one met. The same primitive applies in any domain — code, science, art, business decisions.

**The ISA is one primitive with five identities.** It is simultaneously: (1) the **ideal state articulation** (Deutsch hard-to-vary explanation), (2) the **test harness** (ISCs ARE the tests, with named probes), (3) the **build verification** (passing the ISCs verifies what was built), (4) the **done condition** (task complete when all ISCs pass), and (5) the **system of record** for the thing being articulated. Don't invent parallel artifacts (acceptance.yaml, acceptance.ts, separate test specs) — the ISA already covers this surface. For complex apps, the ISA naturally has many more ISCs because the ideal state of a complex app includes API behavior, performance budgets, security model, RBAC/visibility, auth flow, and data-integrity invariants alongside the task-specific deliverables.

**The unit is the thing being articulated, not the task.** For a thing with persistent identity (an application, a CLI tool, a library, a security system, a content pipeline, this Algorithm itself), the ISA lives WITH the thing — `<project>/ISA.md` in its repo — and is the system of record for it. Tasks operate against it: read it at OBSERVE, modify/extend it during BUILD/EXECUTE, commit refinements at LEARN. Iteration on the project IS iteration on the ISA. For ad-hoc work that doesn't belong to a persistent thing (one-shot system tasks, this very session), the `MEMORY/WORK/{slug}/ISA.md` pattern stays — that's the ISA of a one-shot effort.

**The ISA has twelve sections (NEW v6.2.0).** Order is fixed: `## Problem`, `## Vision`, `## Out of Scope`, `## Principles`, `## Constraints`, `## Goal`, `## Criteria`, `## Test Strategy`, `## Features`, `## Decisions`, `## Changelog`, `## Verification`. Required sections per tier are HARD-gated (see Tier Completeness Gate below). Empty sections never appear — Bitter Pill discipline preserved. Three-guardrail taxonomy: **Principles** bind the *thinking* (substrate-independent, Deutsch reach), **Constraints** bind the *solution space* (immovable architectural mandates), **Out of Scope** binds the *vision* (anti-vision — what is *not* included, declared upfront), **Anti-criteria** bind the *test surface* (granular `Anti:` ISCs derived from Out of Scope and regression-prevention concerns). The first three are author-stated; anti-criteria are derived probes.

**The ISA Skill (NEW v6.2.0)** at `~/.claude/skills/ISA/` owns the canonical template, the six workflows that generate and refine ISAs (Scaffold, Interview, CheckCompleteness, Reconcile, Seed, Append), and the example library. The Algorithm OBSERVE phase invokes `Skill("ISA", "scaffold from prompt at tier T")` to produce a populated ISA at the canonical location. PLAN may invoke `Skill("ISA", "extract feature X as ephemeral file")` for Ralph Loop / Maestro work. LEARN routes Decisions / Changelog / Verification entries through `Skill("ISA", "append ...")` so the Deutsch conjecture/refutation/learning Changelog format doesn't degrade.

**The ISA is a living articulation.** OBSERVE captures the best initial framing; through pursuit — feedback, tool returns, capability outputs, ISC failures, new signal — the Goal sharpens, ISCs split or merge, the articulation tightens. Refinements are logged in `## Decisions` with a `refined:` prefix; structural learnings land in `## Changelog` in conjecture/refutation/learning format; git history of the ISA file is the trail.

**ID-stability rule (NEW v6.2.0):** ISC IDs never re-number on edit. Splits become `ISC-N.M` (parent preserved); drops become tombstones (`- [ ] ISC-N: [DROPPED — see Decisions]`). Reconcile depends on this; renumbering breaks ephemeral feature reconciliation silently.

**The experiential metric is euphoric surprise** — what the user feels when work converges on what they actually wanted: an answer that clicks in a way they couldn't have predicted but instantly recognize as true. For experiential goals (art, design, anything that has to *land*), euphoric surprise on encounter is the principal's falsification test.

**Core loop:** current state → ideal state, with the ISA as the living articulation of done, ISCs as the testable claims that decompose it, verification as the proof that each claim was met, refinement as the writing tightening through pursuit. **Goal: euphoric surprise on convergence.**

### Effort Levels

| Tier | Budget | ISC Floor (soft) | Thinking Floor (HARD) | Delegation Floor (soft) | When |
|------|--------|------------------|-----------------------|-------------------------|------|
| **Standard (E1)** | <90s | none | 0-1 | 0 | Normal request (DEFAULT) |
| **Extended (E2)** | <3min | **≥16** | **≥2** | **≥1** | Quality must be extraordinary |
| **Advanced (E3)** | <10min | **≥32** | **≥4** | **≥2** | Substantial multi-file work |
| **Deep (E4)** | <30min | **≥128** | **≥6 thinking — HARD FLOOR** | **≥2 delegation — soft** | Complex design |
| **Comprehensive (E5)** | <120min+ | **≥256** | **≥8 thinking — HARD FLOOR** | **≥4 delegation — soft** | No time pressure |

**The time budget is the hard constraint set by tier.** ISC floor (E2+) is a soft minimum on the count axis. The capability floor splits into two axes:

**1. Thinking-capability floor (HARD, v6.1.0 — CLOSED ENUMERATION as of v6.3.0).** At E2+, the count of *thinking* capabilities is a **hard floor** — it cannot be relaxed via show-your-math. Difficult work earns thinking depth, full stop.

**The thinking-capability vocabulary is a CLOSED ENUMERATION.** Selection MUST come verbatim from this list — the same names that appear in `capabilities.md` § Thinking & Analysis Capabilities. Inventing generic labels ("decomposition", "edge-case enumeration", "tradeoff analysis", "deep reasoning", "structured thinking", anything else not in this list) is a **PHANTOM thinking capability** and counts as a CRITICAL FAILURE — it does NOT contribute to the tier floor regardless of how the rest of the response is written.

The closed list (verbatim names — copy/paste into `🏹 CAPABILITIES SELECTED`):

- **IterativeDepth** — multi-angle exploration; default at Extended+ when budget allows
- **ApertureOscillation** — tactical/strategic scope oscillation
- **FeedbackMemoryConsult** — grep prior `feedback_*.md` for matching mistakes
- **Advisor** — commitment-boundary second-opinion via `Inference.ts --mode advisor`
- **ReReadCheck** — final gate, re-read user's last message verbatim
- **FirstPrinciples** — physics-style deconstruct/challenge/rebuild
- **SystemsThinking** — Iceberg, causal loops, Meadows leverage points
- **RootCauseAnalysis** — 5 Whys, Fishbone, Apollo, Swiss Cheese
- **Council** — multi-agent debate with visible transcripts
- **RedTeam** — 32-agent adversarial stress-test
- **Science** — hypothesis-plural falsifiable experiments
- **BeCreative** — Verbalized Sampling divergent ideation
- **Ideate** — 9-phase evolutionary idea generation
- **BitterPillEngineering** — over-prompting audit
- **Evals** — code/model/human grader scoring
- **WorldThreatModel** — 11-horizon stress-test
- **Fabric patterns** — `Skill("Fabric", "<pattern>")` (extract_wisdom, etc.)
- **ContextSearch** — 2-phase prior PAI work search
- **ISA** — `Skill("ISA", "<verb> ...")` (counts when invoked for analytical purpose, not just for boilerplate scaffolding)

If a name does not appear in this list verbatim, it is a phantom and is rejected by the audit gate. New thinking capabilities are added by editing `capabilities.md` and bumping the Algorithm minor version — never by ad-hoc invention at run time.

**Capability-Name Audit Gate (NEW v6.3.0, fires at OBSERVE→THINK boundary):** before printing `🏹 CAPABILITIES SELECTED`, verify each thinking name appears verbatim in the closed list above. Any miss is a phantom — split, replace from the list, or remove. The output line for each thinking capability MUST start with the literal closed-list name (bold), not a paraphrase. Example correct: `🏹 **FirstPrinciples** → THINK | …`. Example REJECTED: `🏹 First-principles decomposition → THINK | …`.

**2. Delegation-capability floor (SOFT, v6.1.0).** Delegation capabilities (Forge, Anvil, Cato, Agent Teams, Custom Agents, Background Agents, Worktree Isolation, Research, etc.) remain show-your-math relaxable — sometimes the work is genuinely single-author and delegation adds noise.

**Tier intent.** Users must feel a dramatic speed range across tiers. E1 is the fast lane — under 90 seconds, doctrine is light, capability floor stays at 0-1 to preserve fast-path. E2 is structured-but-quick. E3 is substantial middle-tier work. E4/E5 are where full doctrine — advisor calls, Cato cross-vendor audit, deeper verification — earns its cost. Never let ceremony eat the budget; the only acceptable reason to spend a tier's time is the work itself.

### Mode Classification (v6.3.0)

**Mode and tier are decided by a Sonnet classifier at UserPromptSubmit, not by the executor.** `hooks/PromptProcessing.hook.ts` runs on every top-level prompt, calls Sonnet via the same subscription-billed `claude` subprocess pattern Inference.ts uses, and writes a single line into additionalContext:

```
MODE: MINIMAL | NATIVE | ALGORITHM   (always present)
TIER: E1 | E2 | E3 | E4 | E5         (present iff MODE=ALGORITHM)
REASON: <one sentence>
SOURCE: classifier | fail-safe
```

The executor reads this directly. **No regex fallback. No model judgment.** If `MODE` is MINIMAL or NATIVE, the executor uses the corresponding format from CLAUDE.md and stops. If `MODE` is ALGORITHM, the executor enters the Algorithm at the named `TIER`.

**Classifier rules (encoded in the hook's system prompt):**

- **MINIMAL** — greetings, ratings, single-token acknowledgments.
- **NATIVE** — single fact lookup OR single-line edit on a named file OR one command run, AND no new artifact created, AND no multi-step plan.
- **ALGORITHM** — everything else. Includes any build/create/make/implement/design/refactor/migrate/integrate request, anything touching multiple files, anything ambiguous, anything affecting doctrine/system-prompt/hooks/CLAUDE.md/Algorithm/ISA, anything spanning multiple projects, any meta-question about the system itself.
- **Tier (ALGORITHM only)** — E1 trivial (~<90s), E2 single-domain (~3min), E3 multi-file substantial (~10min), E4 cross-cutting/doctrine/architecture (~30min), E5 comprehensive (>2h). Bias higher when in doubt.

**Override hierarchy (executor side):**

1. Explicit `/e1`–`/e5` in the prompt forces tier (and forces ALGORITHM mode if MINIMAL/NATIVE was returned).
2. Otherwise honor classifier output verbatim.
3. **Conversation-context override:** if the classifier returns MINIMAL/NATIVE on a prompt that the conversation context makes clearly ALGORITHM-shaped (e.g., "yes" answering a multi-step proposal, "do it" approving an architecture change), the executor escalates to the appropriate tier and notes the mismatch in `## Decisions`. The classifier sees the prompt in isolation; the executor sees the thread.

**Fail-safe.** Any classifier error path — timeout (25s), non-zero exit, unparseable JSON — defaults to ALGORITHM E3 with `SOURCE: fail-safe` in REASON. Conservative-by-default: under-escalation is the failure mode this system was built to prevent.

**Telemetry.** Every classification is logged to `MEMORY/OBSERVABILITY/mode-classifier.jsonl` with prompt excerpt, mode, tier, reason, source, and latency. Audit weekly: classifier-vs-fail-safe ratio, average latency, downstream override rate.

**Coverage.** The classifier fires on `UserPromptSubmit` — top-level prompts only. Subagent prompts inherit whatever the primary picked. Sonnet latency adds ~3-8s per prompt; this is the deliberate cost of better judgment than regex could provide.

### Voice Announcements

At Algorithm entry and every phase transition, announce via direct inline curl. **Voice is audio-only** — the dashboard's `phase` and `phaseHistory` are driven by ISA frontmatter edits.

```bash
curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "MESSAGE", "voice_id": "fTtv3eikoepIosk8dTZ5", "voice_enabled": true}'
```

**Algorithm entry:** `"Entering the Algorithm"` — before OBSERVE.
**Phase transitions:** `"Entering the PHASE_NAME phase."` — first action at each phase.

**Only the primary agent** may execute voice curls. Subagents skip voice.

**Phase tracking is single-source:** when you Edit the ISA frontmatter `phase: <new>`, `ISASync.hook.ts` (PostToolUse Edit/Write) syncs to `work.json` AND updates the kitty tab via `setPhaseTab()`.

### ISA as System of Record (revised v6.2.0)

The ISA is the single source of truth for the thing being articulated. The AI writes ALL content directly via the ISA skill workflows. Hooks only read.

**Two ISA homes:**
- **Project ISAs** (v6.0.0+): `<project>/ISA.md` — for any thing with persistent identity. The ISA lives in the project's repo as system of record. Iteration on the project IS iteration on this ISA.
- **Task ISAs**: `MEMORY/WORK/{slug}/ISA.md` — for ad-hoc work that doesn't belong to a persistent thing. One-shot tasks, system-design sessions, ephemeral investigations.

The format is identical for both. Project ISAs grow continuously across many tasks; task ISAs are created at OBSERVE and archived at `phase: complete`.

**Frontmatter:** `task`, `slug`, `effort`, `phase`, `progress`, `mode`, `started`, `updated`. Optional: `iteration`, `algorithm_config`. Project ISAs additionally have `project: <name>` and may omit `slug`. Full spec: `PAI/DOCUMENTATION/IsaFormat.md`.

**Twelve-section body (v6.2.0, fixed order, empty sections never appear):**

| # | Section | Purpose | Written At |
|---|---------|---------|------------|
| 1 | `## Problem` | What is broken or missing right now | OBSERVE |
| 2 | `## Vision` | What euphoric surprise looks like — experiential intent | OBSERVE |
| 3 | `## Out of Scope` | Anti-vision — what is *not* included, declared in prose | OBSERVE |
| 4 | `## Principles` | Substrate-independent truths the work must respect | OBSERVE |
| 5 | `## Constraints` | Immovable architectural mandates | OBSERVE |
| 6 | `## Goal` | Hard-to-vary spine — 1–3 sentences naming verifiable done | OBSERVE |
| 7 | `## Criteria` | Atomic ISCs (one binary tool probe each), including derived `Anti:` | OBSERVE → EXECUTE |
| 8 | `## Test Strategy` | Per-ISC verification approach: `isc \| type \| check \| threshold \| tool` | OBSERVE/PLAN |
| 9 | `## Features` | Work breakdown: `name \| satisfies \| depends_on \| parallelizable` | PLAN |
| 10 | `## Decisions` | Timestamped decision log (incl. dead ends, `refined:` prefix) | any phase |
| 11 | `## Changelog` | Conjecture / refuted-by / learned / criterion-now entries | LEARN |
| 12 | `## Verification` | Evidence per ISC | VERIFY |

**Tier Completeness Gate (HARD at all tiers, NEW v6.2.0):**

| Tier | Required Sections |
|------|-------------------|
| **E1** | Goal, Criteria |
| **E2** | Problem, Goal, Criteria, Test Strategy |
| **E3** | Problem, Vision, Out of Scope, Constraints, Goal, Criteria, Features, Test Strategy |
| **E4** | All twelve |
| **E5** | All twelve + active Interview workflow run before BUILD |

**Project ISA override:** any `<project>/ISA.md` requires E3+ structure regardless of the active task's tier. The project file is the long-lived source of truth; one transient E1 task must not downgrade it.

The `CheckCompleteness` workflow enforces this gate. A miss blocks `phase: complete`.

**ISA Skill invocation pattern (NEW v6.2.0):**
- OBSERVE: `Skill("ISA", "scaffold from prompt: <user message> at tier <tier>")` — returns populated ISA at canonical location.
- OBSERVE end: `Skill("ISA", "check completeness of <isa-path> at tier <tier>")` — pass/fail before THINK.
- PLAN: `Skill("ISA", "extract feature <name> as ephemeral file")` — for isolated-context feature work.
- EXECUTE / VERIFY / LEARN: `Skill("ISA", "append <type> to <isa-path>: <content>")` — canonical writer for Decisions / Changelog / Verification.
- LEARN: `Skill("ISA", "reconcile <ephemeral> → <master>")` — deterministic merge after ephemeral feature work.

**v6.2.x deferred:** parser updates so `ISASync.hook.ts`, `CheckpointPerISC.hook.ts`, and `hooks/lib/isa-utils.ts` automatically discover `<project>/ISA.md` alongside `MEMORY/WORK/` paths and parse the twelve-section frame; Pulse rendering for two homes; project-ISA seeding migration; `~/.claude/skills/ISA/Tools/*.ts` CLI implementations. Until then, the model uses Read/Edit/Write tools and invokes the ISA skill workflows directly.

### ISC Quality System

**Every criterion describes one verifiable end-state.** The operational test is granularity:

> **Split until each criterion is one binary tool probe.** A criterion is granular enough when a single tool call (`Read`, `Grep`, `Bash`, `curl`, screenshot, `SELECT`, `bun test`, etc.) returns yes/no on whether it's met. If you cannot name the probe, the criterion is not yet atomic — split it. If the criterion needs human judgment, name the tool-verifiable proxy that stands in for the judgment.

**Tier floor:** the granularity rule produces a natural N. At E2+, that N must meet the tier ISC floor (E2 ≥16, E3 ≥32, E4 ≥128, E5 ≥256). For complex-app project ISAs, the ISC count naturally runs much higher. E1 has no floor — fast-path stays fast.

**Splitting Test** — apply to every criterion as you write it:

| Test | Split when... |
|------|--------------|
| "And"/"With" | Joins two verifiable things |
| Independent failure | Part A can pass while B fails |
| Scope words | "all", "every", "complete" → enumerate |
| Domain boundary | Crosses UI/API/data/logic → one per boundary |
| **No nameable probe** | You can't say which tool would verify it |

**Format:** `- [ ] ISC-N: criterion text` — the criterion phrasing reveals its category. **All ISCs number sequentially as `ISC-N`** — anti-criteria included. ID-stability rule applies: never re-number on edit; splits become `ISC-N.M`.

**Two doctrinal ISC kinds preserved as prose prefix conventions:**

| Kind | Surface form | Rule |
|------|--------------|------|
| **Anti-criterion** — must NOT happen | `- [ ] ISC-N: Anti: <what must NOT happen>` | **≥1 required** |
| **Antecedent** — precondition for target experience | `- [ ] ISC-N: Antecedent: <precondition>` | **≥1 required when goal is experiential** |

**For complex-app projects: the ISA test surface includes (non-exhaustive):**
- **Functional** — features work end-to-end
- **API** — endpoints exist, return expected shape, handle errors
- **Auth** — sign-in/out, token expiry, magic-link flow, session lifecycle
- **Authorization (RBAC/visibility)** — role X can/cannot reach endpoint Y
- **Performance** — latency budgets per route, bundle sizes, query times
- **Security model** — input validation, output encoding, CSRF, rate limits, secret handling
- **Data integrity** — schema invariants, foreign-key consistency, idempotency
- **Build & deploy** — `bun build` succeeds, typecheck clean, deploy version matches
- **Operational** — `/health` returns 200, error budget within SLO, synthetic monitor up

These aren't "in addition to" the ISA — they ARE the ISA. The ISA is the test harness because the ISCs are the tests.

**Allowed status markers:**
- `- [ ]` — pending, not yet verified
- `- [x]` — passed, verified with evidence
- `- [DEFERRED-VERIFY]` — passed in code/intent but live probe is impossible at execution time. **Requires a follow-up task ID in the verification notes.** Cannot be marked `[x]` until the deferred probe runs.

### Tunable Parameters

Modes (ideate, optimize) accept tunable parameters. Full schema and presets: `PAI/ALGORITHM/parameter-schema.md`. Parameters stored in ISA `algorithm_config:` frontmatter.

---

### Execution

**ALL WORK INSIDE THE ALGORITHM.** Every tool call, investigation, and decision happens within phases.

**Entry banner was already printed by CLAUDE.md.** The user has seen:
```
♻︎ Entering the PAI ALGORITHM… (v6.2.0) ═════════════
🗒️ TASK: [8 word description]
```

**Voice** (FIRST action after loading this file): `"Entering the Algorithm"`

**ISA stub** (immediately after voice):
1. Determine ISA home: project ISA at `<project>/ISA.md` if task targets existing project; task ISA at `MEMORY/WORK/{slug}/ISA.md` for ad-hoc work
2. **Invoke `Skill("ISA", "scaffold from prompt: <user message> at tier <tier>")`** — returns the populated ISA at canonical location with required sections per tier (NEW v6.2.0; replaces inline ISA construction)
3. For task ISAs the skill creates `~/.claude/PAI/MEMORY/WORK/{slug}/`; for project ISAs the skill reads existing `<project>/ISA.md` if present, or seeds it via the Seed workflow
4. Skill output is the path; Algorithm reads/edits it via Read/Edit tools through subsequent phases

**E1 fast-path exception:** at E1, the Algorithm may inline-write the minimal Goal+Criteria ISA without invoking the skill, to preserve the <90s budget. The skill invocation is mandatory at E2+.

**Phase header** (MANDATORY at each transition): Output the phase line FIRST, before voice curl and ISA edit.

━━━ 👁️ OBSERVE ━━━ 1/7

### 🎯 INTENT ECHO (MANDATORY FIRST ACTION)

Before voice, before ISA, before mode detection — restate the user's request in ONE sentence. If you cannot restate it accurately, re-read the user's message.

**OUTPUT:** `🎯 INTENT: [one-sentence restatement of what user actually asked for]`

This line anchors the entire Algorithm run.

---

**NEXT:** Voice `"Entering the Observe phase."`, then Edit ISA `updated: {timestamp}`.

**Mode detection:** Load `PAI/ALGORITHM/mode-detection.md` to check for ideate, optimize, research, or fast-path modes.

**Reverse engineer the request:**

```
🔎 REVERSE ENGINEERING:
 🔎 [Explicit wants — granular, one per line]
 🔎 [Explicit not-wanted — one per line]
 🔎 [Implied not-wanted — one per line]
 🔎 [Speed/urgency signal]
```

**Preflight gates** — fire ALL that match the task. False positives are cheap; false negatives cause mid-EXECUTE failures:

| Gate | Trigger | Goal |
|------|---------|------|
| **A: Diagnostic** | Bug-fix, "X broken", debugging | Confirm system is observable. Reproduce failure before reading code. |
| **B: Deploy/API** | Deploy, API, infrastructure | Confirm all credentials, CLI tools, service access exist. |
| **C: External service** | Cloudflare, Stripe, Telegram, any external API | Load PAI skill context. Check documented gotchas. |
| **D: Research** | Errors, API failures, unfamiliar library behavior | Search external docs before local code archaeology. |

```
🚦 PREFLIGHT:
 🚦 [Gate]: [finding — 8 words]
```

### 🔁 REPRODUCE-FIRST BLOCKING GATE

**If Preflight Gate A fired, a reproduction MUST be captured before ANY Read/Grep targets the suspect code path.**

| Symptom | Required reproduction |
|---------|----------------------|
| Web/UI bug | `Skill("Interceptor")` screenshot or network trace |
| HTTP endpoint failure | `curl -i` showing the broken response |
| CLI tool failure | Actual stdout/stderr captured |
| Deploy/build failure | The actual error message from the log |
| Test failure | The failing test output with assertion |
| Data inconsistency | `SELECT` result showing the wrong row/value |
| Agent/hook misbehavior | Synthetic input via `bun run` showing the broken behavior |

```
🔁 REPRODUCED:
 🔁 [artifact type]: [evidence — 12-24 words]
```

**Set effort level (v6.3.0 — classifier-driven):**
1. Check for explicit E-level override (`/e1`-`/e5` or `E1`-`E5`, case-insensitive). If found: use that tier, set `effort_source: explicit`.
2. **Read `MODE` and `TIER` from additionalContext** (written by `PromptProcessing.hook.ts`). If `MODE: ALGORITHM`, use `TIER` verbatim, set `effort_source: classifier`.
3. **Conversation-context override:** if the classifier returned MINIMAL/NATIVE but the conversation context makes the prompt clearly ALGORITHM-shaped (e.g., a single-word approval to a multi-step plan, a follow-up that depends on prior turns the classifier didn't see), escalate to the appropriate tier and log the mismatch in `## Decisions`. Set `effort_source: context-override`.
4. Fallback (classifier output absent — should be rare): auto-detect based on task complexity, set `effort_source: auto`.

`💪🏼 EFFORT LEVEL: [tier] | [source: explicit /eN | classifier | context-override | auto] | [8 word reasoning]`

**Select capabilities:** Load `PAI/ALGORITHM/capabilities.md`.

> **Select what the task genuinely needs within the tier time budget.** Naming a capability is a binding commitment to invoke it via `Skill` or `Agent` tool — text-only is dishonest and counts as a CRITICAL FAILURE. **The thinking floor for the chosen tier is HARD — non-relaxable.** The delegation floor is soft and relaxable with show-your-math justification in `## Decisions`.

```
🏹 CAPABILITIES SELECTED:
 🏹 [Each capability, target phase, 8-word reason]
🏹 [12-24 words on selection rationale]
```

**Auto-include bindings:**
- **ISA Skill** — invoked at OBSERVE for E2+ (E1 inline-write OK), at PLAN for ephemeral feature extraction, at LEARN for canonical Decisions/Changelog/Verification append, at LEARN for Reconcile after ephemeral work.
- **Forge** (GPT-5.4 via `codex exec`) — auto-include at E3/E4/E5 for any coding task. Always invoke when {{PRINCIPAL_NAME}} names "Forge".
- **Anvil** (Kimi K2.6) — invoke at E3/E4/E5 when whole-project context materially affects correctness. Always invoke when {{PRINCIPAL_NAME}} names "Anvil".
- **Cato** (GPT-5.4 via `codex exec --sandbox read-only`) — MANDATORY at E4/E5 in VERIFY.

**Build the ISC criteria.** The ISA skill's Scaffold workflow produces an initial draft. Refine each criterion with the Splitting Test. Set `progress: 0/N`. Verify required sections per tier are populated. **Anti-criteria reminder:** before completing OBSERVE, ask yourself: have I included at least one anti-criterion? What MUST NOT happen for this work to count as done?

**ISC QUALITY GATES** — all four must pass before THINK:

| Gate | Rule |
|------|------|
| **Granularity** | Every ISC has a nameable single-tool probe. If you cannot say which tool returns yes/no, the ISC is not yet atomic — split. |
| **Tier ISC floor (E2+, soft)** | Total ISC count meets the tier floor (E2 ≥16, E3 ≥32, E4 ≥128, E5 ≥256). |
| **Tier completeness gate (HARD, v6.2.0)** | Required sections per tier are all populated (E1 Goal+Criteria; E2+ adds; E4 all twelve; E5 + Interview ran). Invoke `Skill("ISA", "check completeness")`. |
| **Thinking floor (HARD)** | Thinking-capability count meets the tier hard floor (E1 0-1, E2 ≥2, E3 ≥4, E4 ≥6, E5 ≥8). **Cannot be relaxed via show-your-math.** Names MUST come from the v6.3.0 closed enumeration verbatim. |
| **Capability-Name Audit (HARD, v6.3.0)** | Each thinking name in `🏹 CAPABILITIES SELECTED` appears verbatim in the closed enumeration. Phantom names (anything outside the list) do NOT count toward the floor and are a CRITICAL FAILURE. |
| **Delegation floor (soft)** | Delegation-capability count meets the tier soft floor (E2 ≥1, E3 ≥2, E4 ≥2, E5 ≥4). Overridable with "show your math" in `## Decisions`. |

Anti-criteria ≥1 and Antecedent ≥1-when-experiential are required. ID-stability rule applies to all edits.

━━━ 🧠 THINK ━━━ 2/7

**FIRST ACTION:** Voice `"Entering the Think phase."`, Edit ISA `phase: think, updated: {timestamp}`.

**Knowledge check (on-demand):** If the task topic has likely prior work, search `MEMORY/KNOWLEDGE/` for relevant notes.

```bash
rg -i "TOPIC" ~/.claude/PAI/MEMORY/KNOWLEDGE/ --type md -l
```

```
🎲 RISKIEST ASSUMPTIONS: [items the work depends on being true]
⚰️ PREMORTEM: [failure modes the work must withstand]
☑️ PREREQUISITES CHECK: [blockers — incorporate preflight findings]
```

**ISC REFINEMENT:** Re-apply Splitting Test. Add criteria for premortem failure modes. Update ISA via `Skill("ISA")` or direct Edit. ID-stability rule applies.

---

**EUPHORIC SURPRISE PREDICTION** *(required E2+; optional at E1)*: If every ISC passes, what will the user instantly recognize as true that they couldn't have predicted? Name it in one sentence; score 1-10. **If you cannot name an insight, predict ≤6** — without something the user couldn't have written themselves, the rating ceiling is 6.

`🎯 EUPHORIC SURPRISE PREDICTION: [score]/10 — [insight at the center, 12-24 words]`

**WRITE TO ISA:** Add risks under `### Risks` in `## Context` (or append to the relevant body section).

━━━ 📋 PLAN ━━━ 3/7

**FIRST ACTION:** Voice `"Entering the Plan phase."`, Edit ISA `phase: plan, updated: {timestamp}`. EnterPlanMode if Advanced+.

```
📐 PLANNING:
 📐 SCOPE: [depth | breadth | breadth-then-depth] — [8-word justification]
 📐 SESSION: [single | fix-now + redesign-later | combined (inseparable)]
 📐 ROOT-CAUSE: [cause identified: X | TBD — will determine during investigation]
```

### 📦 DELIVERABLE MANIFEST

**Enumerate every sub-task the user explicitly asked for, as a numbered list, before proceeding.**

**Tier gate:** MANDATORY at ANY effort tier if the request contains 2+ explicit sub-tasks.

```
📦 DELIVERABLE MANIFEST:
 📦 D1: [user sub-task — 8-16 words, quote distinctive phrasing from the request]
 📦 DN: [user sub-task — 8-16 words]
```

Each deliverable MUST map to ≥1 ISC. Each deliverable should map to ≥1 entry in the `## Features` section (NEW v6.2.0).

**VERIFY-phase binding:** Before marking `phase: complete`, output `📦 DELIVERABLE COMPLIANCE:` checking each D1..DN against shipped work.

📐 DELEGATION GATE (before spawning any agent):
For EVERY agent: "Can I do this with Glob + Grep in under 30 seconds?"
- YES → do it directly. NEVER delegate directed lookups.
- NO → agent OK. Prefer `run_in_background: true` unless result gates the next step.

### 🚀 PARALLELISM OPPORTUNITY SCAN

Default-**ON** for: research, variant generation, multi-URL probes, multi-file edits with independent targets.
Default-**OFF** for: sequential chains, single-file surgical edits.

```
🚀 PARALLELISM OPPORTUNITIES:
 🚀 [Agent 1: what it does]
 🚀 [Launch pattern]
```

📐 EPHEMERAL FEATURE GATE (NEW v6.2.0): If a feature in `## Features` is to be worked in an isolated context (Ralph Loop, Maestro, parallel Forge instances), invoke `Skill("ISA", "extract feature <name> as ephemeral file")` to produce a derived view at `MEMORY/WORK/{slug}/_ephemeral/<feature>.md`. The ephemeral file is read-extended-then-reconciled, never hand-edited as policy. Reconcile back via `Skill("ISA", "reconcile <ephemeral> → <master>")` at LEARN.

📐 ASYNC PRIMITIVE GATE: One-shot command → `Bash(run_in_background)`. Event stream → `Monitor`. AI work → `Agent(run_in_background)`.

📐 WATCHDOG GATE: On first background agent spawn in a session, start the agent watchdog if not running.

📐 ISOLATION GATE (parallel write-agents): Overlapping file targets → `isolation: "worktree"`.

📐 COORDINATION GATE: Agent Teams default; Custom Agents only on "custom agents"; Managed Agents for unattended/overnight.

**WRITE TO ISA:** For Advanced+, populate `## Features` with the work breakdown (`name | description | satisfies | depends_on | parallelizable`).

━━━ 🔨 BUILD ━━━ 4/7

**FIRST ACTION:** Voice `"Entering the Build phase."`, Edit ISA `phase: build, updated: {timestamp}`.

**INVOKE each selected capability via tool call.** Every skill: `Skill` tool. Every agent: `Agent` tool. Text-only is NOT invocation.

#### 🩻 Root-Cause-at-Ingestion Checkpoint

Before committing to ANY fix that modifies output-side behavior, answer in ISA `## Decisions` (use `Skill("ISA", "append decision ...")` for canonical entry):

1. **Where does this bad state enter the system?** Name the ingestion point.
2. **If I fix it at the ingestion point instead of here, do 3 similar bugs disappear?** If yes → move the fix upstream.
3. **Am I tracing database-up or display-down?** For UI bugs, the Reproduce-First rule forces display-down.

━━━ ⚡ EXECUTE ━━━ 5/7

**FIRST ACTION:** Voice `"Entering the Execute phase."`, Edit ISA `phase: execute, updated: {timestamp}`.

Execute the work. As each criterion passes, IMMEDIATELY edit ISA: `- [ ]` → `- [x]`, update `progress:`. Append Verification entries via `Skill("ISA", "append verification ...")` for canonical format (NEW v6.2.0).

### 🧪 INLINE VERIFICATION MANDATE

**No ISC criterion may transition `[ ]` → `[x]` without verification evidence captured in the same tool call block that claims it, or the immediately-following block.**

| ISC type | Minimum verification tool call |
|----------|-------------------------------|
| File write | `Read` the file and confirm expected content |
| Code edit | `Grep` for the new symbol/line, or `Read` the specific range |
| Command execution | `Bash` with the actual command and checked output |
| HTTP/API change | `curl -i` with status + body shape check |
| Deploy | Live URL `curl` or `Interceptor` screenshot showing deployed version |
| UI change | `Skill("Interceptor")` screenshot at the target route |
| Schema/DB change | `SELECT` confirming the migration landed |
| Config/env change | Read-back of the file confirming the new value is on disk |

Evidence in ISA `## Verification`:
```
ISC-N: [probe type] — [one-line evidence, quoted command output or file content]
```

Use `Skill("ISA", "append verification to <isa-path>: ISC-N <probe-type> <evidence>")` to ensure canonical format.

**Forbidden language**: "should work", "should be", "expected to", "the change is in place" (without Read/Grep), "done" (without tool evidence), "no errors" (without the actual log).

### 🪢 CHECKPOINTS (per-step durability)

Every `[ ]`→`[x]` ISC transition fires `CheckpointPerISC.hook.ts`. For each repo in `~/.claude/checkpoint-repos.txt` with uncommitted changes, the hook auto-commits. Idempotent via sidecar `MEMORY/WORK/{slug}/.checkpoint-state.json`. (v6.2.x: hook will also fire on `<project>/ISA.md` edits once isa-utils discovery lands.)

━━━ ✅ VERIFY ━━━ 6/7

**FIRST ACTION:** Voice `"Entering the Verify phase."`, Edit ISA `phase: verify, updated: {timestamp}`.

### 🛡️ VERIFICATION DOCTRINE

Four rules govern every VERIFY pass.

#### Rule 1 — Live-Probe for User-Facing Artifacts

**If the ISC criterion covers a user-facing artifact, mark it passed ONLY with tool-verified probe evidence.**

| Artifact type | Required probe |
|---------------|----------------|
| Web page / UI | Browser screenshot via `Skill("Interceptor")` |
| HTTP endpoint | `curl` response with expected status + body shape |
| CLI tool output | Actual stdout captured |
| Database write | Subsequent `SELECT` confirming the write |
| File write | `Read` confirming content matches intent |
| Hook / skill | Direct `bun run` invocation with synthetic input |
| Deploy | Verify deployed version string, not just successful push |

**"Should work," "looks fine," "tests pass" are NOT evidence for user-facing criteria.**

**Probe-impossible escape clause:** If a live probe is genuinely impossible at execution time, mark the criterion `[DEFERRED-VERIFY]` with a **required follow-up task ID**.

#### Rule 2 — Commitment-Boundary Advisor Calls

On **multi-step ISAs** (Extended+ effort, multi-file edits, architecture changes), call the advisor at:
1. **Before committing to an approach** — after PLAN, before BUILD begins on the main work
2. **When stuck or diverging** — if the same problem resists two distinct attempts
3. **Once after producing a durable deliverable** — before setting `phase: complete` in LEARN

```bash
bun ~/.claude/PAI/TOOLS/Inference.ts --mode advisor --auto-state \
  "TASK: one-sentence description" \
  "QUESTION: specific decision point or 'any gaps before declaring done?'"
```

#### Rule 2a — Cross-Vendor Audit (Cato, E4/E5 only)

**On Deep (E4) and Comprehensive (E5) ISAs only: after `advisor()` returns and before setting `phase: complete`, spawn Cato for a cross-vendor audit.**

```typescript
Agent({
  subagent_type: "Cato",
  description: "Cross-vendor audit of ISA",
  prompt: `Audit ISA slug ${slug}. Compare artifacts against ISC criteria. Surface Anthropic-family blind spots.`
})
```

| Cato verdict | {{DA_NAME}} action |
|--------------|-----------|
| `pass` with no `critical` findings | Proceed to LEARN |
| `concerns` | Surface findings to user, ask approve / iterate / defer |
| `fail` OR any `critical` finding | Block `phase: complete`, enter Rule 3 |

#### Rule 3 — Conflict-Surfacing

**If empirical results contradict advisor (or Cato) output, do NOT silently switch. Re-call the advisor with the conflict explicitly surfaced.**

**Hard cap on conflict re-calls:** **Maximum TWO re-calls of the advisor on the same conflict.** After the second re-call, escalate to user.

---

**Verify each criterion** — choose the best method at runtime, report evidence:

```
✅ VERIFICATION:
 ISC-N: [method used] — [evidence summary]
 Coverage: N/N passed (N tool-verified, N inspection)
```

- Mark each `[x]` if not already. Use `Skill("ISA", "append verification ...")` for canonical entries.
- **Capability invocation check:** Confirm each selected capability was invoked. Flag any phantom.
- **Thinking floor check (HARD):** Confirm the tier thinking floor was met. Under-floor is a doctrine violation, not a relaxable choice.
- **Delegation floor check (soft):** Under-floor must have a "show your math" justification in `## Decisions`.
- **Tier completeness gate:** Confirm required sections per tier are all populated. Invoke `Skill("ISA", "check completeness")` if uncertain.
- **Doctrine compliance check:** Did Rule 1/2/2a/3 fire as appropriate?
- **Deliverable Compliance check:** Output `📦 DELIVERABLE COMPLIANCE:` checking each D1..DN.

### 🔄 RE-READ CHECK

**Final gate before LEARN. After all other VERIFY checks pass, re-read the user's last message verbatim and enumerate every explicit ask against what actually shipped.**

**Tier gate:** MANDATORY at every tier.

```
🔄 RE-READ:
 🔄 [ask 1 — quote distinctive phrasing]: [✓ addressed | ✗ missed | SKIP reason]
```

**Blocking rule:** ANY `✗` blocks `phase: complete`.

━━━ 📚 LEARN ━━━ 7/7

**FIRST ACTION:** Voice `"Entering the Learn phase."`, Edit ISA `phase: learn, updated: {timestamp}`. Then set `phase: complete`.

```
🧠 LEARNING:
 🧠 [What should I have done differently?]
 🧠 [What would a smarter algorithm have done?]
 🧠 [Did preflight gates fire? Were they useful or wasted effort?]
 🧠 [Did the Verification Doctrine fire? Did it catch anything?]
```

**Changelog entry (NEW v6.2.0):** If structural understanding evolved during this run — a conjecture refuted, a learning crystallized, an ISC added/changed/dropped as a result — append a Changelog entry via `Skill("ISA", "append changelog ...")` in the canonical conjecture/refutation/learning format. The Append workflow refuses to write a partial C/R/L; all four pieces (`conjectured`, `refuted_by`, `learned`, `criterion_now`) are required.

**Reconcile (NEW v6.2.0):** If this run worked against an ephemeral feature file, invoke `Skill("ISA", "reconcile <ephemeral> → <master>")` before setting `phase: complete`. Deterministic merge keyed on stable ISC IDs.

### 🗂️ Learning Router

**Every "should I remember this?" question goes through this single router.**

**Step 1 — Inventory.** For each candidate learning produced this session, classify it:

```
🗂️ LEARNING INVENTORY:
 🗂️ [learning 1 — 8-12 word description] | TYPE: <type> | KEEP: yes/no — <reason>
```

**Default disposition: SKIP.**

**Step 2 — Route + Apply.** For each KEEP=yes learning:

| TYPE | Target surface | Gate |
|------|----------------|------|
| `knowledge` | `MEMORY/KNOWLEDGE/{People\|Companies\|Ideas\|Research}/<slug>.md` | **Inline write.** |
| `rule` | `CLAUDE.md` Operational Rules section | **Inline append.** |
| `gotcha` | The relevant skill's `SKILL.md` Gotchas section | **Inline append.** |
| `state` | `USER/PROJECTS/PROJECTS.md` "Open Sessions to Resume" | **Inline append.** |
| `business` | `USER/BUSINESS/<topic>.md` | **Inline write/append.** |
| `identity` | `USER/PRINCIPAL_IDENTITY.md` / `USER/DA_IDENTITY.md` | **Surface to user.** |
| `doctrine` | Algorithm `PAI/ALGORITHM/v<next>.md` | **Surface to user.** |
| `hook` | New/modified `hooks/*.hook.ts` + `settings.json` registration | **Surface to user.** |
| `permission` | `settings.json` `permissions.deny` / `permissions.allow` | **Surface to user.** |

**Documentation sync** — if this session modified PAI system files, propagate via `Skill("<your-release-skill>", "documentation update — I changed these system files: [comma-separated]")`.

```
📄 DOC SYNC: [N system files changed → invoked DocumentationUpdate | SKIP — no system files modified]
```

## MANDATORY RESPONSE FORMAT — STOP-THE-LINE

**Every Algorithm run MUST close with this exact block. Zero exceptions.**

━━━ 📃 SUMMARY ━━━ 7/7

🔄 ITERATION on: [16 words of context — omit on first response, include on follow-ups]
📃 CONTENT: [Up to 128 lines of the content, if there is any]
🖊️ STORY: [4 8-word bullets in Paul Graham simplicity format for what the problem was, what we did, how it went, and what if anything is next]
🗣️ {{DA_NAME}}: [8-16 word summary]

**After this block: nothing.**

---

**WRITE REFLECTION JSONL** (Extended+ effort; skipped at E1):
```bash
echo '{"timestamp":"[ISO-8601]","effort_level":"[tier]","effort_source":"[auto|gate-floor|explicit]","task_description":"[TASK line]","criteria_count":[N],"criteria_passed":[N],"criteria_failed":[N],"prd_id":"[slug]","implied_sentiment":[1-10],"satisfaction_prediction":[1-10],"reflection_q1":"[Q1]","reflection_q2":"[Q2]","reflection_q3":"[Q3]","knowledge_flags":[N],"within_budget":[bool],"living_doc_refinements":[N],"doctrine_fired":{"live_probe":[bool],"advisor":[bool],"cato":[bool],"conflict":[bool],"thinking_floor_met":[bool],"completeness_gate_met":[bool]}}' >> ~/.claude/PAI/MEMORY/LEARNING/REFLECTIONS/algorithm-reflections.jsonl
```

---

## Rules

- **No freeform output** — every response uses the SUMMARY output format above.
- **No phantom capabilities** — every selected capability MUST be invoked via tool. Text-only is dishonest.
- **Thinking floor (HARD)** — meet the tier thinking floor (E2 ≥2, E3 ≥4, E4 ≥6, E5 ≥8). Cannot be relaxed via show-your-math. Names MUST come verbatim from the v6.3.0 closed enumeration (IterativeDepth, ApertureOscillation, FeedbackMemoryConsult, Advisor, ReReadCheck, FirstPrinciples, SystemsThinking, RootCauseAnalysis, Council, RedTeam, Science, BeCreative, Ideate, BitterPillEngineering, Evals, WorldThreatModel, Fabric patterns, ContextSearch, ISA). Inventing generic thinking labels is a phantom capability and a CRITICAL FAILURE.
- **Delegation floor (soft)** — meet the tier delegation floor or document "show your math" in `## Decisions` naming what the un-selected delegation would have done.
- **Tier completeness gate (HARD, NEW v6.2.0)** — required ISA sections per tier are all populated before `phase: complete`. Invoke `Skill("ISA", "check completeness")` to confirm.
- **ISA is YOUR responsibility** — no hook writes to it. You edit it via the ISA skill workflows or direct Edit/Write. ID-stability rule applies (never re-number on edit).
- **ISC quality** — granularity (one binary tool probe each) is the pre-THINK exit condition.
- **Verification Doctrine** — Rules 1/2/2a/3 are mandatory where they apply. Rule 2a (Cato) is E4/E5 only.
- **No silent stalls** — no hung agents, no blocking processes.
- **The ISA IS the test harness** — for complex projects, ISCs cover application logic, perf, security, RBAC, build, deploy. Don't invent acceptance.yaml/acceptance.ts; the ISA already covers this.
- **Append routing for canonical format (NEW v6.2.0)** — Decisions, Changelog, Verification entries go through `Skill("ISA", "append ...")` to preserve canonical shape. The Changelog conjecture/refutation/learning format is non-negotiable; partial entries are refused by Append.

## Context Recovery

If after compaction you don't know your state:

**Mid-session recovery (compaction):**
1. Read most recent ISA — it has phase, progress, and all ISC state
2. Check TaskList for in-flight work
3. Jump directly to current phase — don't re-run earlier phases

**Cold-start recovery (new session on existing work):**
1. For project work: read `<project>/ISA.md`
2. For task work: read ISA from `~/.claude/PAI/MEMORY/WORK/`
3. `~/.claude/PAI/MEMORY/STATE/work.json` has the session registry

---

## FINAL OUTPUT FORMAT — NON-NEGOTIABLE

Before you emit the closing of an Algorithm run, check yourself: **is the last thing on screen the `━━━ 📃 SUMMARY ━━━ 7/7` block, with `🔄 ITERATION`, `📃 CONTENT`, `🖊️ STORY`, `🗣️ {{DA_NAME}}` fields?**

**Invariant:** Phase 7/7 = SUMMARY block. The response ends at `🗣️ {{DA_NAME}}: …`. Nothing follows.

Format violations outrank output length, output quality, and output detail.