guild-agents 0.3.0 → 0.3.1-snapshot.20260225.2

package/README.md

@@ -5,37 +5,25 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js >= 20](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
 
-Claude Code is powerful but chaotic. Guild gives it structure.
+**Guild makes Claude Code think before it builds.**
 
-Guild is an npm CLI that sets up 9 specialized agents and 10 skill-based workflows as `.claude/` files in any project. Agents define **who** does the work. Skills define **how** it gets done. Everything is markdown, tracked by git, works offline.
+Guild is a spec-driven development CLI for Claude Code. It installs structured design and development workflows as `.claude/` markdown files in any project. Before code is written, features are evaluated, debated by independent AI perspectives, and specified in a design doc. Everything is markdown, tracked by git, works offline, zero infrastructure.
 
-## Why Guild?
+## The Problem
 
-- **Structure over chaos.** Claude Code without guidance produces inconsistent results. Guild gives every task a clear owner and a repeatable process.
-- **Agents = WHO, Skills = HOW.** Agents are flat `.md` files with identity and expertise. Skills are workflow definitions invoked as slash commands. Clean separation, no magic.
-- **State that persists.** Context lives in `CLAUDE.md`, `PROJECT.md`, and `SESSION.md` -- tracked by git, readable by humans, never lost between sessions.
-- **Zero infrastructure.** No servers, no APIs, no config files. Just markdown files that Claude Code reads natively.
+Without structure, Claude Code:
 
-## How It Works
+- Writes code before understanding the problem
+- Has no design phase and no review gate
+- Loses decisions between sessions
+- Produces results that vary with every conversation
 
-```
-You ──> /build-feature "Add JWT auth"
-         │
-         ▼
-    ┌─────────┐     ┌───────────────┐     ┌───────────────┐
-    │ Advisor  │────>│  Tech Lead    │────>│  Developer    │
-    │ evaluate │     │  plan         │     │  implement    │
-    └─────────┘     └───────────────┘     └───────┬───────┘
-                                                  │
-                                    ┌─────────────┼─────────────┐
-                                    ▼             ▼             ▼
-                              ┌──────────┐ ┌──────────┐ ┌──────────┐
-                              │ Reviewer │ │    QA    │ │  Bugfix  │
-                              │ review   │ │  test    │ │  fix     │
-                              └──────────┘ └──────────┘ └──────────┘
-```
+## How Guild Solves It
 
-Skills orchestrate agents through structured pipelines. You invoke a skill as a slash command, and it coordinates the right agents in the right order.
+- **Spec before code**: every feature starts with a design doc
+- **Structured deliberation**: `/council` runs parallel independent analysis -- multiple perspectives evaluate independently, then synthesize
+- **Decisions that persist**: design docs, session state, and project context live in git-tracked markdown
+- **Zero infrastructure**: no servers, no APIs, just markdown files and Claude Code
 
 ## Quick Start
 
@@ -44,28 +32,68 @@ npm install -g guild-agents
 guild init
 ```
 
-The interactive onboarding asks for project name, type, stack, and repo details, then generates the full structure: 9 agents, 10 skills, and 3 state files.
-
-Next, let Guild learn your codebase:
+Then use skills as slash commands in Claude Code:
 
+```text
+/guild-specialize        # Learn your codebase, enrich CLAUDE.md
+/council "Add JWT auth"  # Spec a feature through structured deliberation
+/build-feature           # Implement from spec through the full pipeline
 ```
-/guild-specialize
+
+## The Pipeline
+
+```text
+You ──> /council "Add JWT auth"
+         │
+         ▼
+    ┌──────────┐     ┌──────────────┐     ┌──────────┐
+    │ Evaluate │────>│  Design Doc  │────>│  Build   │
+    │ debate   │     │  spec        │     │ implement│
+    └──────────┘     └──────────────┘     └────┬─────┘
+                                               │
+                                         ┌─────┴─────┐
+                                         ▼           ▼
+                                   ┌──────────┐┌──────────┐
+                                   │  Review  ││    QA    │
+                                   └──────────┘└──────────┘
 ```
 
-This explores your actual code and enriches `CLAUDE.md` with real conventions, patterns, and stack details. Every agent now understands your project.
+Six phases: **evaluate**, **specify**, **plan**, **implement**, **review**, **validate**. Phases 1-3 happen before any code is written.
 
-Then build something:
+## Skills Reference
 
-```
-/build-feature Add user authentication with JWT
+All 11 skills, grouped by function:
+
+| Skill | Group | Description |
+| --- | --- | --- |
+| `/build-feature` | Pipeline | Full pipeline: evaluate, spec, implement, review, QA |
+| `/new-feature` | Pipeline | Create branch and scaffold for a new feature |
+| `/create-pr` | Pipeline | Create a structured pull request from current branch |
+| `/council` | Decision | Multi-perspective deliberation on a decision or feature |
+| `/review` | Quality | Code review on the current diff |
+| `/qa-cycle` | Quality | QA and bugfix loop until clean |
+| `/guild-specialize` | Context | Explore codebase, enrich CLAUDE.md with real conventions |
+| `/session-start` | Context | Load context and resume work |
+| `/session-end` | Context | Save state to SESSION.md |
+| `/status` | Context | Project and session state overview |
+| `/dev-flow` | Context | Show current pipeline phase and next step |
+
+## CLI Commands
+
+```bash
+guild init              # Interactive project onboarding
+guild new-agent <name>  # Create a custom agent
+guild status            # Show project status
+guild doctor            # Diagnose setup
+guild list              # List agents and skills
 ```
 
-This runs the full pipeline -- advisor evaluation, tech lead planning, developer implementation, code review, and QA -- all coordinated automatically.
+## Under the Hood
 
-## Agents
+Guild coordinates 9 specialized agents through the pipeline. Each agent handles one phase.
 
 | Agent | Role |
-|---|---|
+| --- | --- |
 | advisor | Evaluates ideas and provides strategic direction |
 | product-owner | Turns approved ideas into concrete tasks |
 | tech-lead | Defines technical approach and architecture |
@@ -74,70 +102,13 @@ This runs the full pipeline -- advisor evaluation, tech lead planning, developer
 | qa | Testing, edge cases, regression validation |
 | bugfix | Bug diagnosis and resolution |
 | db-migration | Schema changes and safe migrations |
-| platform-expert | Diagnoses and resolves Claude Code integration issues |
-
-## Skills
-
-| Skill | Description |
-|---|---|
-| `/guild-specialize` | Explores codebase, enriches CLAUDE.md with real stack and conventions |
-| `/build-feature` | Full pipeline: evaluation, spec, implementation, review, QA |
-| `/new-feature` | Creates branch and scaffold for a new feature |
-| `/council` | Convenes multiple agents to debate a decision |
-| `/qa-cycle` | QA and bugfix loop until clean |
-| `/review` | Code review on the current diff |
-| `/dev-flow` | Shows current pipeline phase and next step |
-| `/status` | Project and session state overview |
-| `/session-start` | Loads context and resumes work |
-| `/session-end` | Saves state to SESSION.md |
-
-## CLI Commands
-
-```bash
-guild init                  # Interactive project onboarding
-guild new-agent <name>      # Create a custom agent
-guild status                # Show project status
-guild doctor                # Diagnose installation state
-guild list                  # List installed agents and skills
-```
-
-## Generated Structure
+| platform-expert | Diagnoses Claude Code integration issues |
 
-Running `guild init` creates the following in your project root:
-
-```
-CLAUDE.md
-PROJECT.md
-SESSION.md
-.claude/
-  agents/
-    advisor.md
-    product-owner.md
-    tech-lead.md
-    developer.md
-    code-reviewer.md
-    qa.md
-    bugfix.md
-    db-migration.md
-    platform-expert.md
-  skills/
-    guild-specialize/SKILL.md
-    build-feature/SKILL.md
-    new-feature/SKILL.md
-    council/SKILL.md
-    qa-cycle/SKILL.md
-    review/SKILL.md
-    dev-flow/SKILL.md
-    status/SKILL.md
-    session-start/SKILL.md
-    session-end/SKILL.md
-```
-
-All files are markdown, tracked by git, and work fully offline.
+Agents are flat `.md` files with identity and expertise. Skills orchestrate agents through structured pipelines. Everything lives in `.claude/`, readable by humans, tracked by git.
 
 ## Guild Builds Itself
 
-This project uses its own agents and skills to develop itself. Every feature, review, and bugfix goes through the same pipelines that Guild installs in your project.
+Every feature in Guild goes through the same spec-first pipeline that Guild installs in your project. Guild's own design decisions live in `docs/specs/`.
 
 ## Requirements
 
@@ -147,12 +118,7 @@ This project uses its own agents and skills to develop itself. Every feature, re
 
 ## Contributing
 
-Two types of contributions:
-
-- **Agent and skill templates** (`src/templates/`) -- improve agent definitions or skill workflows.
-- **CLI code** (`src/`, `bin/`) -- bug fixes, new commands, onboarding improvements.
-
-See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for details.
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for setup, branching, and contribution guidelines.
 
 ## License
 

package/bin/guild.js

@@ -14,14 +14,25 @@ import { program } from 'commander';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import chalk from 'chalk';
+import { parseVersion, getPreReleaseWarning } from '../src/utils/version.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
 
+const { channel } = parseVersion(pkg.version);
+const prereleaseWarning = getPreReleaseWarning(pkg.version);
+if (prereleaseWarning) {
+  const color = channel === 'snapshot' ? chalk.red : chalk.yellow;
+  console.error(color(`Guild v${pkg.version} -- ${prereleaseWarning}`));
+}
+
 program
   .name('guild')
-  .description('Multi-agent framework for Claude Code')
-  .version(pkg.version);
+  .description('Specification-driven development CLI for Claude Code')
+  .version(pkg.version)
+  .option('--verbose', 'Enable verbose logging (records decision trail)')
+  .option('--debug', 'Enable debug logging (records full prompts and responses)');
 
 // guild init
 program
@@ -94,4 +105,19 @@ program
     }
   });
 
+// guild reset-learnings
+program
+  .command('reset-learnings')
+  .description('Reset the compound learnings file')
+  .option('-f, --force', 'Skip confirmation prompt')
+  .action(async (options) => {
+    try {
+      const { runResetLearnings } = await import('../src/commands/reset-learnings.js');
+      await runResetLearnings(options);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "guild-agents",
-  "version": "0.3.0",
-  "description": "A multi-agent framework for Claude Code — specialized AI teams for every project",
+  "version": "0.3.1-snapshot.20260225.2",
+  "description": "Specification-driven development CLI for Claude Code — think before you build",
   "type": "module",
   "files": [
     "bin/",
@@ -17,24 +17,32 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src/ && markdownlint-cli2 'src/templates/**/*.md'",
-    "lint:js": "eslint src/",
+    "lint": "eslint src/ scripts/ && markdownlint-cli2 'src/templates/**/*.md'",
+    "lint:js": "eslint src/ scripts/",
     "lint:md": "markdownlint-cli2 'src/templates/**/*.md'",
     "dev": "node bin/guild.js",
-    "prepublishOnly": "npm test && npm run lint"
+    "prepublishOnly": "npm test && npm run lint",
+    "version:snapshot": "node scripts/version-snapshot.js",
+    "version:beta": "node scripts/version-beta.js",
+    "version:stable": "node scripts/version-stable.js",
+    "publish:snapshot": "npm run version:snapshot && npm publish --tag snapshot",
+    "publish:beta": "npm run version:beta && npm publish --tag beta",
+    "publish:stable": "npm run version:stable && npm publish --tag latest",
+    "publish:promote-beta": "npm dist-tag add guild-agents@$(node --input-type=commonjs -p \"require('./package.json').version\") beta"
   },
   "keywords": [
     "claude",
     "claude-code",
+    "anthropic",
+    "specification-driven",
+    "spec-driven",
+    "spec-first",
+    "design-docs",
+    "developer-tools",
+    "cli",
     "agents",
     "ai",
     "workflow",
-    "multi-agent",
-    "developer-tools",
-    "cli",
-    "framework",
-    "anthropic",
-    "ai-agents",
     "automation",
     "code-review",
     "nodejs"
@@ -52,7 +60,9 @@
   "dependencies": {
     "@clack/prompts": "^1.0.1",
     "chalk": "^5.3.0",
-    "commander": "^14.0.3"
+    "commander": "^14.0.3",
+    "guild-agents": "0.3.1-snapshot.20260225.1",
+    "yaml": "^2.8.2"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/commands/doctor.js

@@ -6,8 +6,15 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { existsSync, readdirSync } from 'fs';
 import { join } from 'path';
+import { resolveProjectRoot } from '../utils/files.js';
+import { loadAllSkills } from '../utils/skill-loader.js';
 
 export async function runDoctor() {
+  const root = resolveProjectRoot();
+  if (root) {
+    process.chdir(root);
+  }
+
   p.intro(chalk.bold.cyan('Guild — Doctor'));
 
   const checks = [];
@@ -77,9 +84,77 @@ export async function runDoctor() {
     healthy = false;
   }
 
+  // Check workflow validation in skills
+  if (existsSync(skillsDir)) {
+    const skills = loadAllSkills(skillsDir);
+    let workflowCount = 0;
+    let workflowErrors = 0;
+    const errorDetails = [];
+
+    for (const [name, skill] of skills) {
+      if (skill.workflow) {
+        workflowCount++;
+        if (skill.errors.length > 0) {
+          workflowErrors++;
+          errorDetails.push(`${name}: ${skill.errors.join('; ')}`);
+        }
+      }
+
+      // Check that agent references exist
+      if (skill.workflow) {
+        for (const step of skill.workflow.steps) {
+          if (step.role !== 'system' && step.role !== 'dynamic') {
+            const agentPath = join(agentsDir, `${step.role}.md`);
+            if (!existsSync(agentPath)) {
+              errorDetails.push(`${name}: step "${step.id}" references agent "${step.role}" — agent not found`);
+              workflowErrors++;
+            }
+          }
+        }
+      }
+    }
+
+    if (workflowCount > 0 && workflowErrors === 0) {
+      checks.push({ name: `Workflows (${workflowCount} valid)`, pass: true });
+    } else if (workflowCount > 0 && workflowErrors > 0) {
+      checks.push({
+        name: `Workflows (${workflowErrors} issue(s))`,
+        pass: false,
+        fix: errorDetails.join('\n    '),
+      });
+      healthy = false;
+    }
+    // If workflowCount === 0, don't add a check (no workflows to validate)
+
+    // Check for dual-format skills (workflow frontmatter + body step/phase headings)
+    // Matches "### Step 1", "## Phase 2", etc. — requires digit after Step/Phase
+    const STEP_PHASE_RE = /^#{1,3}\s+(Step|Phase)\s+\d/im;
+    const dualFormatWarnings = [];
+
+    for (const [name, skill] of skills) {
+      if (skill.workflow && skill.body && STEP_PHASE_RE.test(skill.body)) {
+        dualFormatWarnings.push(name);
+      }
+    }
+
+    if (dualFormatWarnings.length > 0) {
+      checks.push({
+        name: `Dual-format skills (${dualFormatWarnings.length} warning(s))`,
+        pass: true,
+        warn: true,
+        detail: `Skills with both workflow frontmatter and body step/phase headings: ${dualFormatWarnings.join(', ')}. Workflow steps take precedence — consider removing prose steps from body.`,
+      });
+    }
+  }
+
   // Display results
   for (const check of checks) {
-    if (check.pass) {
+    if (check.warn) {
+      p.log.warn(`${chalk.yellow('⚠')} ${check.name}`);
+      if (check.detail) {
+        p.log.info(chalk.gray(`  ${check.detail}`));
+      }
+    } else if (check.pass) {
       p.log.success(`${chalk.green('✓')} ${check.name}`);
     } else {
       p.log.error(`${chalk.red('✗')} ${check.name}`);

package/src/commands/init.js

@@ -127,19 +127,19 @@ export async function runInit() {
   p.log.success(`Created: CLAUDE.md, PROJECT.md, SESSION.md, ${agentCount} agents, ${skillCount} skills`);
 
   const relevantSkills = projectData.hasExistingCode
-    ? ['/guild-specialize', '/build-feature', '/review']
-    : ['/build-feature', '/new-feature', '/council'];
+    ? ['/guild-specialize', '/council', '/build-feature']
+    : ['/council', '/build-feature', '/new-feature'];
   p.log.info(`Start with: ${relevantSkills.join('  ')}`);
 
   const quickStart = projectData.hasExistingCode
-    ? '1. Open Claude Code in this directory\n' +
-      '2. Run /guild-specialize to analyze your codebase\n' +
-      '3. Start building with /build-feature'
-    : '1. Open Claude Code in this directory\n' +
-      '2. Start building with /build-feature\n' +
+    ? '1. Run /guild-specialize to analyze your codebase\n' +
+      '2. Run /council to spec your first feature\n' +
+      '3. Build it with /build-feature'
+    : '1. Run /council to spec your first feature\n' +
+      '2. Build it with /build-feature\n' +
       '3. Run /guild-specialize once you have code';
 
   p.note(quickStart, 'Quick start');
 
-  p.outro(chalk.bold.cyan('Guild v1 ready.'));
+  p.outro(chalk.bold.cyan('Guild ready — spec before you build.'));
 }

package/src/commands/list.js

@@ -6,9 +6,11 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { parseFrontmatter } from '../utils/files.js';
+import { ensureProjectRoot, parseFrontmatter } from '../utils/files.js';
 
 export async function runList() {
+  ensureProjectRoot();
+
   p.intro(chalk.bold.cyan('Guild — Agents & Skills'));
 
   // List agents

package/src/commands/new-agent.js

@@ -13,10 +13,13 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { existsSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { ensureProjectRoot } from '../utils/files.js';
 
 const AGENTS_DIR = join('.claude', 'agents');
 
 export async function runNewAgent(agentName) {
+  ensureProjectRoot();
+
   p.intro(chalk.bold.cyan('Guild — New agent'));
 
   // Validate name

package/src/commands/reset-learnings.js

@@ -0,0 +1,44 @@
+/**
+ * reset-learnings.js — Resets the compound learnings file
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { join } from 'path';
+import { ensureProjectRoot } from '../utils/files.js';
+import { learningsExist, deleteLearnings } from '../utils/learnings-io.js';
+import { GUILD_LEARNINGS_PATH } from '../utils/learnings.js';
+
+/**
+ * Runs the `guild reset-learnings` command.
+ * @param {object} [options]
+ * @param {boolean} [options.force] - Skip confirmation prompt
+ */
+export async function runResetLearnings(options = {}) {
+  const root = ensureProjectRoot();
+  const filePath = join(root, GUILD_LEARNINGS_PATH);
+
+  p.intro(chalk.bold.cyan('Guild — Reset Learnings'));
+
+  if (!learningsExist(filePath)) {
+    p.log.info('No learnings file found. Nothing to reset.');
+    p.outro('Done.');
+    return;
+  }
+
+  if (!options.force) {
+    const confirmed = await p.confirm({
+      message: 'This will delete all accumulated learnings. Continue?',
+      initialValue: false,
+    });
+
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel('Reset cancelled.');
+      return;
+    }
+  }
+
+  deleteLearnings(filePath);
+  p.log.success(`${chalk.green('✓')} Learnings file deleted.`);
+  p.outro('Learnings have been reset. They will be regenerated on the next workflow execution.');
+}

package/src/commands/status.js

@@ -6,11 +6,10 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
+import { ensureProjectRoot } from '../utils/files.js';
 
 export async function runStatus() {
-  if (!existsSync('PROJECT.md')) {
-    throw new Error('Guild is not installed. Run: guild init');
-  }
+  ensureProjectRoot();
 
   const projectMd = readFileSync('PROJECT.md', 'utf8');
   const nameMatch = projectMd.match(/\*\*Name:\*\*\s*(.+)/);

package/src/templates/agents/advisor.md

@@ -3,6 +3,7 @@ name: advisor
 description: "Evaluates ideas and provides strategic direction before committing work"
 tools: Read, Glob, Grep
 permissionMode: plan
+default-tier: reasoning
 ---
 
 # Advisor

package/src/templates/agents/bugfix.md

@@ -3,6 +3,7 @@ name: bugfix
 description: "Bug diagnosis and resolution"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
+default-tier: execution
 ---
 
 # Bugfix

package/src/templates/agents/code-reviewer.md

@@ -3,6 +3,7 @@ name: code-reviewer
 description: "Reviews quality, patterns, and technical debt"
 tools: Read, Glob, Grep
 permissionMode: plan
+default-tier: reasoning
 ---
 
 # Code Reviewer

package/src/templates/agents/db-migration.md

@@ -3,6 +3,7 @@ name: db-migration
 description: "Schema changes and safe migrations"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
+default-tier: execution
 ---
 
 # DB Migration

package/src/templates/agents/developer.md

@@ -3,6 +3,7 @@ name: developer
 description: "Implements features following the project conventions"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
+default-tier: execution
 ---
 
 # Developer

package/src/templates/agents/learnings-extractor.md

@@ -0,0 +1,49 @@
+---
+name: learnings-extractor
+description: "Extracts compound learnings from pipeline executions"
+tools: Read, Glob, Grep
+permissionMode: plan
+default-tier: routine
+---
+
+# Learnings Extractor
+
+You are the Learnings Extractor for [PROJECT]. Your job is to analyze completed pipeline traces and extract reusable patterns, recurring issues, and optimization opportunities that improve future executions.
+
+## Responsibilities
+
+- Read pipeline trace files from `.claude/guild/traces/`
+- Identify patterns across multiple executions (recurring review loops, common failures)
+- Extract actionable learnings that reduce future iteration count
+- Update `.claude/guild/learnings.md` with new findings
+- Prioritize learnings by impact (reduces tokens, reduces loops, improves quality)
+
+## What you do NOT do
+
+- You do not implement features — that is the Developer's role
+- You do not evaluate strategy — that is the Advisor's role
+- You do not modify source code — you only read traces and write learnings
+
+## Process
+
+1. Read the pipeline trace provided as input
+2. Analyze step results, loop counts, and failure patterns
+3. Compare with existing learnings in `.claude/guild/learnings.md`
+4. Extract new learnings or reinforce existing ones
+5. Write updated learnings in a structured format
+
+## Output format
+
+Each learning should include:
+
+- **Pattern**: What was observed
+- **Frequency**: How often it occurs (first-seen or recurring)
+- **Recommendation**: What to do differently next time
+- **Impact**: Expected reduction in loops, tokens, or failures
+
+## Behavior rules
+
+- Never duplicate an existing learning — update its frequency instead
+- Focus on actionable recommendations, not observations
+- Keep learnings concise — one paragraph maximum per entry
+- Tag learnings with the workflow they came from

package/src/templates/agents/platform-expert.md

@@ -3,6 +3,7 @@ name: platform-expert
 description: "Diagnoses and resolves Claude Code integration issues -- permissions, subagents, hooks, settings"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
+default-tier: execution
 ---
 
 # Platform Expert

package/src/templates/agents/product-owner.md

@@ -3,6 +3,7 @@ name: product-owner
 description: "Converts approved ideas into concrete, implementable tasks"
 tools: Read, Glob, Grep
 permissionMode: plan
+default-tier: reasoning
 ---
 
 # Product Owner

package/src/templates/agents/qa.md

@@ -3,6 +3,7 @@ name: qa
 description: "Testing, edge cases, regression"
 tools: Read, Write, Edit, Bash, Glob, Grep
 permissionMode: bypassPermissions
+default-tier: execution
 ---
 
 # QA