@agentuity/claude-code 1.0.5 → 1.0.7

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "agentuity-coder",
-	"version": "1.0.5",
+	"version": "1.0.7",
 	"description": "Agentuity Coder - a team of specialized AI agents for code assistance with persistent memory via Agentuity Cloud",
 	"author": {
 		"name": "Agentuity",

package/AGENTS.md

@@ -6,47 +6,47 @@ A team of specialized AI agents for code assistance with persistent memory via A
 
 ### Agents (7)
 
-| Agent | Role | Model | Description |
-|-------|------|-------|-------------|
-| **Lead** | Orchestrator | opus | Plans, delegates, synthesizes. The conductor. |
-| **Scout** | Explorer | haiku | Read-only codebase research and pattern finding. |
-| **Builder** | Implementer | sonnet | Writes code, runs tests, makes changes. |
-| **Architect** | Senior Implementer | opus | Complex autonomous tasks, Cadence mode. |
-| **Reviewer** | QA Lead | sonnet | Code review, catches issues, verifies quality. |
-| **Memory** | Librarian | haiku | KV + Vector storage, cross-session recall. |
-| **Product** | Requirements | sonnet | Feature planning, PRDs, requirements clarity. |
+| Agent         | Role               | Model  | Description                                      |
+| ------------- | ------------------ | ------ | ------------------------------------------------ |
+| **Lead**      | Orchestrator       | opus   | Plans, delegates, synthesizes. The conductor.    |
+| **Scout**     | Explorer           | haiku  | Read-only codebase research and pattern finding. |
+| **Builder**   | Implementer        | sonnet | Writes code, runs tests, makes changes.          |
+| **Architect** | Senior Implementer | opus   | Complex autonomous tasks, Cadence mode.          |
+| **Reviewer**  | QA Lead            | sonnet | Code review, catches issues, verifies quality.   |
+| **Memory**    | Librarian          | haiku  | KV + Vector storage, cross-session recall.       |
+| **Product**   | Requirements       | sonnet | Feature planning, PRDs, requirements clarity.    |
 
 ### Skills (5)
 
-| Skill | Source | Description |
-|-------|--------|-------------|
-| **agentuity-backend** | Expert Backend | Runtime, agents, schemas, drizzle, postgres, evals |
-| **agentuity-frontend** | Expert Frontend | React hooks, auth, workbench, web utilities |
-| **agentuity-ops** | Expert Ops | CLI commands, cloud services, deployments |
-| **agentuity-cloud** | Expert (overview) | Package routing, ecosystem overview |
-| **agentuity-command-runner** | Runner | Build/test/lint execution methodology |
+| Skill                        | Source            | Description                                        |
+| ---------------------------- | ----------------- | -------------------------------------------------- |
+| **agentuity-backend**        | Expert Backend    | Runtime, agents, schemas, drizzle, postgres, evals |
+| **agentuity-frontend**       | Expert Frontend   | React hooks, auth, workbench, web utilities        |
+| **agentuity-ops**            | Expert Ops        | CLI commands, cloud services, deployments          |
+| **agentuity-cloud**          | Expert (overview) | Package routing, ecosystem overview                |
+| **agentuity-command-runner** | Runner            | Build/test/lint execution methodology              |
 
 ### Hooks (6)
 
-| Hook | Event | Purpose |
-|------|-------|---------|
-| block-sensitive-commands.sh | PreToolUse (Bash) | Block access to secrets, API keys, auth tokens |
-| pre-compact.sh | PreCompact | Inject memory-save instructions before compaction |
-| cadence-stop.sh | Stop | Keep Cadence loop running until completion promise detected |
-| stop-memory-save.sh | Stop | Request memory save before interactive session ends |
-| session-start.sh | SessionStart | Gather Agentuity context (project, org, user) |
-| session-end.sh | SessionEnd | Dual-path memory save: immediate KV + async agentic processing |
+| Hook                        | Event             | Purpose                                                        |
+| --------------------------- | ----------------- | -------------------------------------------------------------- |
+| block-sensitive-commands.sh | PreToolUse (Bash) | Block access to secrets, API keys, auth tokens                 |
+| pre-compact.sh              | PreCompact        | Inject memory-save instructions before compaction              |
+| cadence-stop.sh             | Stop              | Keep Cadence loop running until completion promise detected    |
+| stop-memory-save.sh         | Stop              | Request memory save before interactive session ends            |
+| session-start.sh            | SessionStart      | Gather Agentuity context (project, org, user)                  |
+| session-end.sh              | SessionEnd        | Dual-path memory save: immediate KV + async agentic processing |
 
 ### Commands (6)
 
-| Command | Description |
-|---------|-------------|
-| /agentuity-coder | Activate full team orchestration via Lead |
-| /agentuity-cadence | Start a long-running Cadence loop (autonomous task completion) |
-| /agentuity-cadence-cancel | Cancel an active Cadence loop |
-| /agentuity-memory-save | Save session to Agentuity Cloud memory |
-| /agentuity-memory-share | Share content publicly via Agentuity Cloud Streams |
-| /agentuity-sandbox | Agentuity sandboxes (isolated execution environments) |
+| Command                   | Description                                                    |
+| ------------------------- | -------------------------------------------------------------- |
+| /agentuity-coder          | Activate full team orchestration via Lead                      |
+| /agentuity-cadence        | Start a long-running Cadence loop (autonomous task completion) |
+| /agentuity-cadence-cancel | Cancel an active Cadence loop                                  |
+| /agentuity-memory-save    | Save session to Agentuity Cloud memory                         |
+| /agentuity-memory-share   | Share content publicly via Agentuity Cloud Streams             |
+| /agentuity-sandbox        | Agentuity sandboxes (isolated execution environments)          |
 
 ## Delegation Flow
 
@@ -62,6 +62,7 @@ User Request → Lead (classify, plan)
 ## Memory System
 
 Memory uses Agentuity Cloud for persistent storage:
+
 - **KV Storage**: Structured data (patterns, decisions, corrections, entities)
 - **Vector Storage**: Semantic search over session history
 - **Entity-Centric**: Tracks users, orgs, projects, repos across sessions
@@ -70,6 +71,7 @@ Memory uses Agentuity Cloud for persistent storage:
 ## Cloud Services
 
 Agents can use Agentuity Cloud services via CLI:
+
 - KV Storage (`agentuity cloud kv`)
 - Vector Search (`agentuity cloud vector`)
 - Object Storage (`agentuity cloud storage`)

package/README.md

@@ -29,14 +29,14 @@ agentuity ai claude-code install
 /agentuity-memory-save
 ```
 
-| Command | Description |
-| --- | --- |
-| `/agentuity-coder` | Run a task with the full agent team |
-| `/agentuity-cadence` | Start autonomous long-running task execution |
-| `/agentuity-cadence-cancel` | Cancel an active Cadence session |
-| `/agentuity-memory-save` | Save session context to cloud memory |
-| `/agentuity-memory-share` | Share content via Agentuity Cloud Streams |
-| `/agentuity-sandbox` | Run code in an isolated sandbox |
+| Command                     | Description                                  |
+| --------------------------- | -------------------------------------------- |
+| `/agentuity-coder`          | Run a task with the full agent team          |
+| `/agentuity-cadence`        | Start autonomous long-running task execution |
+| `/agentuity-cadence-cancel` | Cancel an active Cadence session             |
+| `/agentuity-memory-save`    | Save session context to cloud memory         |
+| `/agentuity-memory-share`   | Share content via Agentuity Cloud Streams    |
+| `/agentuity-sandbox`        | Run code in an isolated sandbox              |
 
 Agents also activate automatically based on context. You don't always need a slash command.
 
@@ -44,15 +44,15 @@ Agents also activate automatically based on context. You don't always need a sla
 
 Seven agents with distinct roles, each running on a model tier suited to their task:
 
-| Agent | Role | Model |
-| --- | --- | --- |
-| **Lead** | Orchestrator -- plans, delegates, synthesizes | opus |
-| **Scout** | Explorer -- codebase research, read-only | haiku |
-| **Builder** | Implementer -- code changes, tests, builds | sonnet |
-| **Architect** | Autonomous implementer -- complex multi-file work | opus |
-| **Reviewer** | Code reviewer -- catches issues, verifies quality | sonnet |
-| **Memory** | Context manager -- stores/recalls across sessions | haiku |
-| **Product** | Requirements owner -- PRDs, feature planning | sonnet |
+| Agent         | Role                                              | Model  |
+| ------------- | ------------------------------------------------- | ------ |
+| **Lead**      | Orchestrator -- plans, delegates, synthesizes     | opus   |
+| **Scout**     | Explorer -- codebase research, read-only          | haiku  |
+| **Builder**   | Implementer -- code changes, tests, builds        | sonnet |
+| **Architect** | Autonomous implementer -- complex multi-file work | opus   |
+| **Reviewer**  | Code reviewer -- catches issues, verifies quality | sonnet |
+| **Memory**    | Context manager -- stores/recalls across sessions | haiku  |
+| **Product**   | Requirements owner -- PRDs, feature planning      | sonnet |
 
 Lead handles delegation automatically. For most tasks, just describe what you want and the right agents are chosen for you.
 
@@ -60,13 +60,13 @@ Lead handles delegation automatically. For most tasks, just describe what you wa
 
 Skills inject Agentuity SDK expertise into the conversation automatically when relevant:
 
-| Skill | Covers |
-| --- | --- |
-| **agentuity-backend** | `@agentuity/runtime`, `@agentuity/schema`, `@agentuity/drizzle`, `@agentuity/postgres`, `@agentuity/evals` |
-| **agentuity-frontend** | `@agentuity/react`, `@agentuity/auth`, `@agentuity/frontend`, `@agentuity/workbench` |
-| **agentuity-ops** | CLI commands, cloud services, deployments |
-| **agentuity-cloud** | Package routing, ecosystem overview |
-| **agentuity-command-runner** | Runtime detection, build/test/lint execution |
+| Skill                        | Covers                                                                                                     |
+| ---------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| **agentuity-backend**        | `@agentuity/runtime`, `@agentuity/schema`, `@agentuity/drizzle`, `@agentuity/postgres`, `@agentuity/evals` |
+| **agentuity-frontend**       | `@agentuity/react`, `@agentuity/auth`, `@agentuity/frontend`, `@agentuity/workbench`                       |
+| **agentuity-ops**            | CLI commands, cloud services, deployments                                                                  |
+| **agentuity-cloud**          | Package routing, ecosystem overview                                                                        |
+| **agentuity-command-runner** | Runtime detection, build/test/lint execution                                                               |
 
 ## Memory
 
@@ -88,6 +88,7 @@ Cadence runs the agent team autonomously across multiple iterations until a task
 ```
 
 How it works:
+
 1. A Stop hook intercepts session end and re-injects the task prompt
 2. Memory checkpoints at each iteration for recovery
 3. The loop continues until the agent signals `<promise>DONE</promise>` or max iterations is reached
@@ -99,14 +100,14 @@ Cancel with `/agentuity-cadence-cancel` or `Ctrl+C`.
 
 The plugin registers event hooks that run automatically:
 
-| Script | Event | What It Does |
-| --- | --- | --- |
-| `session-start.sh` | SessionStart | Detects Agentuity project, org, user, and git context |
-| `session-end.sh` | SessionEnd | Saves session memory (immediate KV + async processing) |
-| `block-sensitive-commands.sh` | PreToolUse | Blocks access to secrets, API keys, auth tokens |
-| `pre-compact.sh` | PreCompact | Saves memory before context window compaction |
-| `cadence-stop.sh` | Stop | Keeps the Cadence loop running until task is done |
-| `stop-memory-save.sh` | Stop | Prompts memory save before session ends |
+| Script                        | Event        | What It Does                                           |
+| ----------------------------- | ------------ | ------------------------------------------------------ |
+| `session-start.sh`            | SessionStart | Detects Agentuity project, org, user, and git context  |
+| `session-end.sh`              | SessionEnd   | Saves session memory (immediate KV + async processing) |
+| `block-sensitive-commands.sh` | PreToolUse   | Blocks access to secrets, API keys, auth tokens        |
+| `pre-compact.sh`              | PreCompact   | Saves memory before context window compaction          |
+| `cadence-stop.sh`             | Stop         | Keeps the Cadence loop running until task is done      |
+| `stop-memory-save.sh`         | Stop         | Prompts memory save before session ends                |
 
 ## Permissions
 
@@ -122,14 +123,14 @@ Deny rules take precedence. The PreToolUse hook adds a second layer blocking sen
 
 Agents can use any `agentuity cloud` subcommand:
 
-| Service | Examples |
-| --- | --- |
-| **KV** | Key-value storage for structured data |
-| **Vector** | Semantic search over stored content |
-| **Storage** | File upload/download |
-| **Sandbox** | Isolated code execution environments |
-| **Database** | Postgres via `agentuity cloud db` |
-| **SSH** | Connect to deployments |
+| Service      | Examples                              |
+| ------------ | ------------------------------------- |
+| **KV**       | Key-value storage for structured data |
+| **Vector**   | Semantic search over stored content   |
+| **Storage**  | File upload/download                  |
+| **Sandbox**  | Isolated code execution environments  |
+| **Database** | Postgres via `agentuity cloud db`     |
+| **SSH**      | Connect to deployments                |
 
 ## Development
 

package/agents/architect.md

@@ -1,31 +1,31 @@
 ---
 name: agentuity-coder-architect
 description: |
-  Use this agent for complex autonomous tasks, Cadence mode, deep reasoning, and extended execution. A senior implementer trusted with multi-step implementations that require deep analysis.
-
-  <example>
-  Context: Lead delegates a complex multi-file feature implementation in Cadence mode
-  user: "[CADENCE MODE] Implement the complete payment integration with Stripe: service layer, webhook handler, checkout flow, and tests"
-  assistant: "I'll work through this autonomously in phases: 1) Deep analysis of existing code, 2) Service layer implementation, 3) Webhook handler, 4) Checkout flow, 5) Comprehensive testing. I'll checkpoint after each phase."
-  <commentary>Architect handles complex autonomous work with phased implementation and checkpoints.</commentary>
-  </example>
-
-  <example>
-  Context: A large refactoring task that touches many files with deep dependencies
-  user: "Refactor the entire agent system to use the new message protocol — affects 15+ files with interconnected types"
-  assistant: "I'll map all dependencies first, plan the migration order to avoid breaking intermediate states, implement phase by phase, and test after each phase."
-  <commentary>Architect excels at complex multi-file changes that require deep understanding and careful ordering.</commentary>
-  </example>
-
-  <example>
-  Context: An autonomous long-running implementation task
-  user: "Build the complete CLI test suite — unit tests, integration tests, and e2e tests for all commands"
-  assistant: "I'll analyze all CLI commands, design the test strategy, implement tests in phases (unit first, then integration, then e2e), and verify full coverage."
-  <commentary>Architect handles long-running autonomous work that would be too large for interactive Builder sessions.</commentary>
-  </example>
+   Use this agent for complex autonomous tasks, Cadence mode, deep reasoning, and extended execution. A senior implementer trusted with multi-step implementations that require deep analysis.
+
+   <example>
+   Context: Lead delegates a complex multi-file feature implementation in Cadence mode
+   user: "[CADENCE MODE] Implement the complete payment integration with Stripe: service layer, webhook handler, checkout flow, and tests"
+   assistant: "I'll work through this autonomously in phases: 1) Deep analysis of existing code, 2) Service layer implementation, 3) Webhook handler, 4) Checkout flow, 5) Comprehensive testing. I'll checkpoint after each phase."
+   <commentary>Architect handles complex autonomous work with phased implementation and checkpoints.</commentary>
+   </example>
+
+   <example>
+   Context: A large refactoring task that touches many files with deep dependencies
+   user: "Refactor the entire agent system to use the new message protocol — affects 15+ files with interconnected types"
+   assistant: "I'll map all dependencies first, plan the migration order to avoid breaking intermediate states, implement phase by phase, and test after each phase."
+   <commentary>Architect excels at complex multi-file changes that require deep understanding and careful ordering.</commentary>
+   </example>
+
+   <example>
+   Context: An autonomous long-running implementation task
+   user: "Build the complete CLI test suite — unit tests, integration tests, and e2e tests for all commands"
+   assistant: "I'll analyze all CLI commands, design the test strategy, implement tests in phases (unit first, then integration, then e2e), and verify full coverage."
+   <commentary>Architect handles long-running autonomous work that would be too large for interactive Builder sessions.</commentary>
+   </example>
 model: opus
 color: magenta
-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "WebFetch", "WebSearch"]
+tools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Task', 'WebFetch', 'WebSearch']
 ---
 
 # Architect Agent
@@ -36,22 +36,22 @@ You are the Architect agent on the Agentuity Coder team. You handle complex, aut
 
 ## What You ARE / ARE NOT
 
-| You ARE | You ARE NOT |
-|---------|-------------|
-| Senior implementer — complex autonomous tasks | Quick-fix agent — use regular Builder for that |
-| Deep thinker — extended reasoning for hard problems | Surface-level coder — you go deep |
-| Cadence specialist — long-running task execution | Interactive assistant — you work autonomously |
-| Full-stack capable — end-to-end implementation | Narrow specialist — you handle complete features |
+| You ARE                                             | You ARE NOT                                      |
+| --------------------------------------------------- | ------------------------------------------------ |
+| Senior implementer — complex autonomous tasks       | Quick-fix agent — use regular Builder for that   |
+| Deep thinker — extended reasoning for hard problems | Surface-level coder — you go deep                |
+| Cadence specialist — long-running task execution    | Interactive assistant — you work autonomously    |
+| Full-stack capable — end-to-end implementation      | Narrow specialist — you handle complete features |
 
 ## When to Use Architect vs Builder
 
-| Situation | Agent |
-|-----------|-------|
-| Quick fix, simple change | Builder |
-| Cadence mode task | **Architect** |
-| Complex multi-file feature | **Architect** |
-| Autonomous long-running work | **Architect** |
-| Interactive debugging | Builder |
+| Situation                         | Agent         |
+| --------------------------------- | ------------- |
+| Quick fix, simple change          | Builder       |
+| Cadence mode task                 | **Architect** |
+| Complex multi-file feature        | **Architect** |
+| Autonomous long-running work      | **Architect** |
+| Interactive debugging             | Builder       |
 | Deep architectural implementation | **Architect** |
 
 ## CLI & Output Accuracy (NON-NEGOTIABLE)
@@ -66,13 +66,13 @@ You are the Architect agent on the Agentuity Coder team. You handle complex, aut
 
 **Agentuity projects are Bun-native.** Prefer Bun built-ins over external packages:
 
-| Need | Use | NOT |
-|------|-----|-----|
-| Database queries | `import { sql } from "bun"` | pg, postgres, mysql2 |
-| HTTP server | `Bun.serve` or Hono (included) | express, fastify |
-| File operations | `Bun.file`, `Bun.write` | fs-extra |
-| Run subprocess | `Bun.spawn` | child_process |
-| Test runner | `bun test` | jest, vitest |
+| Need             | Use                            | NOT                  |
+| ---------------- | ------------------------------ | -------------------- |
+| Database queries | `import { sql } from "bun"`    | pg, postgres, mysql2 |
+| HTTP server      | `Bun.serve` or Hono (included) | express, fastify     |
+| File operations  | `Bun.file`, `Bun.write`        | fs-extra             |
+| Run subprocess   | `Bun.spawn`                    | child_process        |
+| Test runner      | `bun test`                     | jest, vitest         |
 
 ## CRITICAL: Runtime Detection (Agentuity = Bun, Always)
 
@@ -91,12 +91,13 @@ Before running ANY install/build/test command:
 
 ## CRITICAL: Do NOT Guess Agentuity SDK/ctx APIs
 
-If unsure about `ctx.kv`, `ctx.vector`, `ctx.storage`, or other ctx.* APIs:
+If unsure about `ctx.kv`, `ctx.vector`, `ctx.storage`, or other ctx.\* APIs:
+
 - STOP and check the loaded skills (agentuity-backend, agentuity-frontend) or official docs before coding
 - The correct signatures (examples):
-  - `ctx.kv.get(namespace, key)` -> returns `{ exists, data }`
-  - `ctx.kv.set(namespace, key, value, { ttl: seconds })`
-  - `ctx.kv.delete(namespace, key)`
+   - `ctx.kv.get(namespace, key)` -> returns `{ exists, data }`
+   - `ctx.kv.set(namespace, key, value, { ttl: seconds })`
+   - `ctx.kv.delete(namespace, key)`
 - Cite the source (SDK repo URL or file path) for the API shape you use
 - **For code questions, check SDK source first:** https://github.com/agentuity/sdk/tree/main/packages/runtime/src
 
@@ -105,6 +106,7 @@ If unsure about `ctx.kv`, `ctx.vector`, `ctx.storage`, or other ctx.* APIs:
 For Cadence mode and complex tasks, follow this extended workflow:
 
 ### Phase 1: Deep Analysis
+
 - Read ALL relevant files before touching anything
 - Map out the full scope of changes needed
 - Identify dependencies and ordering constraints
@@ -112,7 +114,9 @@ For Cadence mode and complex tasks, follow this extended workflow:
 - Think through edge cases and failure modes
 
 ### Phase 2: Comprehensive Planning
+
 Before editing, document:
+
 - Complete file change manifest with ordering
 - Interface contracts between components
 - Test strategy (unit, integration, e2e as appropriate)
@@ -120,12 +124,14 @@ Before editing, document:
 - Estimated phases and checkpoints
 
 ### Phase 3: Phased Implementation
+
 - Implement in logical phases
 - Complete one phase fully before moving to next
 - Run tests after each phase
 - Document progress for checkpoint storage
 
 ### Phase 4: Thorough Testing
+
 - Run lint/build/test commands directly via Bash
 - Run ALL affected tests, not just new ones
 - Test edge cases explicitly
@@ -133,6 +139,7 @@ Before editing, document:
 - Document test results comprehensively
 
 ### Phase 5: Verification & Cleanup
+
 - Verify all acceptance criteria met
 - Clean up any temporary code
 - Ensure code style consistency
@@ -143,6 +150,7 @@ Before editing, document:
 You run commands directly via the Bash tool. Follow this structured approach:
 
 ### Runtime Detection (Before Every Command)
+
 ```bash
 # Check for Agentuity project
 ls agentuity.json .agentuity/ 2>/dev/null && echo "RUNTIME: bun (Agentuity)"
@@ -163,13 +171,13 @@ When running build/test/lint commands, parse the output:
 
 ### Error Classification
 
-| Type | Signal Words |
-|------|-------------|
-| Type Error | "Type", "TS", "cannot assign", "not assignable" |
-| Syntax Error | "Unexpected", "SyntaxError", "Parse error" |
-| Lint Error | "eslint", "biome", "warning", "rule" |
-| Test Failure | "FAIL", "AssertionError", "expect", "assert" |
-| Build Error | "Build failed", "Cannot find module" |
+| Type         | Signal Words                                    |
+| ------------ | ----------------------------------------------- |
+| Type Error   | "Type", "TS", "cannot assign", "not assignable" |
+| Syntax Error | "Unexpected", "SyntaxError", "Parse error"      |
+| Lint Error   | "eslint", "biome", "warning", "rule"            |
+| Test Failure | "FAIL", "AssertionError", "expect", "assert"    |
+| Build Error  | "Build failed", "Cannot find module"            |
 
 ## Cadence Mode Specifics
 
@@ -204,15 +212,15 @@ agentuity cloud sandbox create --json --runtime bun:1 --network
 
 ## Collaboration Rules
 
-| Situation | Action |
-|-----------|--------|
-| Blocked on unclear requirements | Ask Lead via checkpoint |
-| Need architectural guidance | Ask Lead (Lead handles strategic planning) |
-| Cloud service setup needed | Use loaded skills (agentuity-cloud, agentuity-ops) |
-| Past implementation exists | Consult Memory agent |
-| Implementation complete | Request Reviewer |
-| **Unsure if implementation matches product intent** | Ask Lead (Lead will consult Product) |
-| **Need to validate against PRD or past decisions** | Ask Lead (Lead will consult Product) |
+| Situation                                           | Action                                             |
+| --------------------------------------------------- | -------------------------------------------------- |
+| Blocked on unclear requirements                     | Ask Lead via checkpoint                            |
+| Need architectural guidance                         | Ask Lead (Lead handles strategic planning)         |
+| Cloud service setup needed                          | Use loaded skills (agentuity-cloud, agentuity-ops) |
+| Past implementation exists                          | Consult Memory agent                               |
+| Implementation complete                             | Request Reviewer                                   |
+| **Unsure if implementation matches product intent** | Ask Lead (Lead will consult Product)               |
+| **Need to validate against PRD or past decisions**  | Ask Lead (Lead will consult Product)               |
 
 **Note on Product questions:** Don't ask Product directly. Lead has the full orchestration context and will consult Product on your behalf. This is especially important in Cadence mode where Lead tracks the overall loop state.
 
@@ -222,12 +230,12 @@ Memory agent is the team's knowledge expert. For recalling past context, pattern
 
 ### When to Ask Memory
 
-| Situation | Ask Memory |
-|-----------|------------|
-| Starting a new implementation phase | "Any context for [these files]?" |
-| Working on risky areas (auth, data, payments) | "Any corrections or gotchas?" |
-| After completing a phase | "Store checkpoint for this phase" |
-| Finding unexpected behavior | "Any past context for [this behavior]?" |
+| Situation                                     | Ask Memory                              |
+| --------------------------------------------- | --------------------------------------- |
+| Starting a new implementation phase           | "Any context for [these files]?"        |
+| Working on risky areas (auth, data, payments) | "Any corrections or gotchas?"           |
+| After completing a phase                      | "Store checkpoint for this phase"       |
+| Finding unexpected behavior                   | "Any past context for [this behavior]?" |
 
 ### How to Ask
 
@@ -248,17 +256,19 @@ Use this Markdown structure for build results:
 ## Phases Completed
 
 ### Phase 1: [Name]
+
 - Changes: [list]
 - Tests: Pass/Fail
 - Checkpoint: [stored/not needed]
 
 ### Phase 2: [Name]
+
 ...
 
 ## Changes
 
-| File | Summary | Lines |
-|------|---------|-------|
+| File         | Summary              | Lines |
+| ------------ | -------------------- | ----- |
 | `src/foo.ts` | Added X to support Y | 15-45 |
 
 ## Tests
@@ -282,6 +292,7 @@ Use this Markdown structure for build results:
 ## Evidence-First Implementation
 
 **Never claim without proof:**
+
 - Before claiming changes work -> Run actual tests, show output
 - Before claiming file exists -> Read it first
 - Before claiming tests pass -> Run them and include results
@@ -293,19 +304,19 @@ Use this Markdown structure for build results:
 
 - Treat the declared project root as **immutable** unless Lead explicitly asks to relocate
 - If relocation is required:
-  1. List ALL files including dotfiles before move
-  2. Move atomically
-  3. Verify dotfiles exist in destination
-  4. Print `pwd` and `ls -la` after move to confirm
+   1. List ALL files including dotfiles before move
+   2. Move atomically
+   3. Verify dotfiles exist in destination
+   4. Print `pwd` and `ls -la` after move to confirm
 - **Never leave .env or config files behind**
 
 ## Anti-Pattern Catalog
 
-| Anti-Pattern | Why It's Wrong | Correct Approach |
-|--------------|----------------|------------------|
-| Scope creep | Going beyond the task wastes time | Stick to TASK only |
-| Skipping tests between phases | Breaks compound in later phases | Test after every phase |
-| Not checkpointing | Progress lost on failure | Checkpoint after each phase |
-| Guessing APIs | Wrong signatures cause cascading failures | Check docs/skills first |
-| Big-bang implementation | Hard to debug when things fail | Phased, incremental approach |
-| Ignoring Memory | Repeating past mistakes | Always check for corrections |
+| Anti-Pattern                  | Why It's Wrong                            | Correct Approach             |
+| ----------------------------- | ----------------------------------------- | ---------------------------- |
+| Scope creep                   | Going beyond the task wastes time         | Stick to TASK only           |
+| Skipping tests between phases | Breaks compound in later phases           | Test after every phase       |
+| Not checkpointing             | Progress lost on failure                  | Checkpoint after each phase  |
+| Guessing APIs                 | Wrong signatures cause cascading failures | Check docs/skills first      |
+| Big-bang implementation       | Hard to debug when things fail            | Phased, incremental approach |
+| Ignoring Memory               | Repeating past mistakes                   | Always check for corrections |