opencode-swarm 4.5.0 → 5.0.0

package/README.md

@@ -1,9 +1,9 @@
 <p align="center">
-  <img src="https://img.shields.io/badge/version-4.5.0-blue" alt="Version">
+  <img src="https://img.shields.io/badge/version-5.0.0-blue" alt="Version">
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License">
   <img src="https://img.shields.io/badge/opencode-plugin-purple" alt="OpenCode Plugin">
   <img src="https://img.shields.io/badge/agents-8-orange" alt="Agents">
-  <img src="https://img.shields.io/badge/tests-622-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/tests-876-brightgreen" alt="Tests">
 </p>
 
 <h1 align="center">🐝 OpenCode Swarm</h1>
@@ -168,8 +168,11 @@ Other frameworks lose everything when the session ends. Swarm doesn't.
 
 ```
 .swarm/
-├── plan.md          # Your project roadmap
+├── plan.md          # Your project roadmap (+ plan.json)
 ├── context.md       # Everything a new Architect needs
+├── evidence/        # Per-task execution evidence
+│   ├── 1.1/         # Evidence for task 1.1
+│   └── 2.3/         # Evidence for task 2.3
 └── history/
     ├── phase-1.md   # What was done, what was learned
     └── phase-2.md
@@ -331,6 +334,21 @@ bunx opencode-swarm uninstall --clean
 
 ## What's New
 
+### v5.0.0 — Verifiable Execution
+- **Canonical plan schema** — Machine-readable `plan.json` with Zod-validated `PlanSchema`/`TaskSchema`/`PhaseSchema`. Automatic migration from legacy `plan.md` format. Structured status tracking (`pending`, `in_progress`, `completed`, `blocked`).
+- **Evidence bundles** — Per-task execution evidence persisted to `.swarm/evidence/`. Five evidence types: `review`, `test`, `diff`, `approval`, `note`. Sanitized task IDs, atomic writes, configurable size limits. `/swarm evidence` to view, `/swarm archive` to manage retention.
+- **Per-agent guardrail profiles** — Override guardrail limits for individual agents via `guardrails.profiles`. `resolveGuardrailsConfig()` merges base + profile with per-agent specificity.
+- **Context injection budget** — `max_injection_tokens` config controls how much context is injected into system prompts. Priority-ordered: phase → task → decisions → agent context. Lower-priority items dropped when budget exhausted.
+- **Enhanced `/swarm agents`** — Agent count summary, `⚡ custom limits` indicator for profiled agents, guardrail profiles section.
+- **Packaging smoke tests** — CI-safe `dist/` validation (8 tests).
+- **208 new tests** — 876 total tests across 39 files (up from 668 in v4.6.0).
+
+### v4.6.0 — Agent Guardrails
+- **Circuit breaker** — Two-layer protection against runaway agents. Soft warning at 50% of limits, hard block at 100%. Prevents infinite loops and runaway API costs.
+- **Detection signals** — Tool call count, wall-clock time, consecutive repetition, and consecutive error tracking per agent session.
+- **Configurable limits** — All thresholds tunable via `guardrails` config: `max_tool_calls`, `max_duration_minutes`, `max_repetitions`, `max_consecutive_errors`, `warning_threshold`.
+- **46 new tests** — 668 total tests across 30 files.
+
 ### v4.5.0 — Tech Debt + New Commands
 - **Lint cleanup** — Replaced string concatenation with template literals, documented `as any` casts with biome-ignore comments.
 - **Code deduplication** — Extracted `stripSwarmPrefix()` utility to eliminate 3 duplicate prefix-stripping blocks.
@@ -402,6 +420,8 @@ All features are opt-in via configuration. See [Installation Guide](docs/install
 | `/swarm diagnose` | Health check for .swarm/ files and config |
 | `/swarm export` | Export plan and context as portable JSON |
 | `/swarm reset --confirm` | Clear swarm state files (with safety gate) |
+| `/swarm evidence [task]` | View evidence bundles for a task or all tasks |
+| `/swarm archive [--dry-run]` | Archive old evidence bundles with retention policy |
 
 ---
 
@@ -433,6 +453,73 @@ Create `~/.config/opencode/opencode-swarm.json`:
 
 ---
 
+## Guardrails
+
+OpenCode Swarm includes a built-in circuit breaker that prevents subagents from running away — burning API credits in infinite loops, repeating the same tool call, or spinning for hours.
+
+### How It Works
+
+| Layer | Trigger | Action |
+|-------|---------|--------|
+| ⚠️ **Soft Warning** | 50% of any limit reached | Injects warning message into agent's chat stream |
+| 🛑 **Hard Block** | 100% of any limit reached | Blocks ALL further tool calls + injects stop message |
+
+### Detection Signals
+
+| Signal | Default Limit | Description |
+|--------|---------------|-------------|
+| Tool calls | 200 | Total tool invocations per agent session |
+| Duration | 30 min | Wall-clock time since delegation started |
+| Repetition | 10 | Same tool + args called consecutively |
+| Consecutive errors | 5 | Sequential null/undefined tool outputs |
+
+### Configuration
+
+Guardrails are **enabled by default**. Customize in your swarm config:
+
+```jsonc
+{
+  "guardrails": {
+    "enabled": true,              // default: true
+    "max_tool_calls": 200,        // range: 10–1000
+    "max_duration_minutes": 30,   // range: 1–120
+    "max_repetitions": 10,        // range: 3–50
+    "max_consecutive_errors": 5,  // range: 2–20
+    "warning_threshold": 0.5      // range: 0.1–0.9 (fraction of limit for soft warning)
+  }
+}
+```
+
+### Per-Agent Profiles
+
+Override limits for specific agents that need more (or less) room:
+
+```jsonc
+{
+  "guardrails": {
+    "max_tool_calls": 200,
+    "profiles": {
+      "coder": { "max_tool_calls": 500, "max_duration_minutes": 60 },
+      "explorer": { "max_tool_calls": 50 }
+    }
+  }
+}
+```
+
+Profiles merge with base config — only specified fields are overridden.
+
+### Disable Guardrails
+
+```json
+{
+  "guardrails": {
+    "enabled": false
+  }
+}
+```
+
+---
+
 ## Comparison
 
 | Feature | OpenCode Swarm | AutoGen | CrewAI | LangGraph |
@@ -473,7 +560,7 @@ bun test
 bun test tests/unit/config/schema.test.ts
 ```
 
-622 unit tests across 29 files covering config, tools, agents, hooks, commands, and state. Uses Bun's built-in test runner — zero additional test dependencies.
+876 unit tests across 39 files covering config, tools, agents, hooks, commands, state, guardrails, evidence, and plan schemas. Uses Bun's built-in test runner — zero additional test dependencies.
 
 ## Troubleshooting
 

package/dist/commands/agents.d.ts

@@ -1,2 +1,3 @@
 import type { AgentDefinition } from '../agents';
-export declare function handleAgentsCommand(agents: Record<string, AgentDefinition>): string;
+import type { GuardrailsConfig } from '../config/schema';
+export declare function handleAgentsCommand(agents: Record<string, AgentDefinition>, guardrails?: GuardrailsConfig): string;

package/dist/commands/archive.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles the /swarm archive command.
+ * Archives old evidence bundles based on retention policy.
+ */
+export declare function handleArchiveCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/evidence.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles the /swarm evidence command.
+ * Lists all evidence bundles or shows details for a specific task.
+ */
+export declare function handleEvidenceCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/index.d.ts

@@ -1,7 +1,9 @@
 import type { AgentDefinition } from '../agents';
 export { handleAgentsCommand } from './agents';
+export { handleArchiveCommand } from './archive';
 export { handleConfigCommand } from './config';
 export { handleDiagnoseCommand } from './diagnose';
+export { handleEvidenceCommand } from './evidence';
 export { handleExportCommand } from './export';
 export { handleHistoryCommand } from './history';
 export { handlePlanCommand } from './plan';

package/dist/config/evidence-schema.d.ts

@@ -0,0 +1,353 @@
+import { z } from 'zod';
+export declare const EVIDENCE_MAX_JSON_BYTES: number;
+export declare const EVIDENCE_MAX_PATCH_BYTES: number;
+export declare const EVIDENCE_MAX_TASK_BYTES: number;
+export declare const EvidenceTypeSchema: z.ZodEnum<{
+    review: "review";
+    test: "test";
+    diff: "diff";
+    approval: "approval";
+    note: "note";
+}>;
+export type EvidenceType = z.infer<typeof EvidenceTypeSchema>;
+export declare const EvidenceVerdictSchema: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    approved: "approved";
+    rejected: "rejected";
+    info: "info";
+}>;
+export type EvidenceVerdict = z.infer<typeof EvidenceVerdictSchema>;
+export declare const BaseEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    type: z.ZodEnum<{
+        review: "review";
+        test: "test";
+        diff: "diff";
+        approval: "approval";
+        note: "note";
+    }>;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type BaseEvidence = z.infer<typeof BaseEvidenceSchema>;
+export declare const ReviewEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"review">;
+    risk: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+        critical: "critical";
+    }>;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ReviewEvidence = z.infer<typeof ReviewEvidenceSchema>;
+export declare const TestEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"test">;
+    tests_passed: z.ZodNumber;
+    tests_failed: z.ZodNumber;
+    test_file: z.ZodOptional<z.ZodString>;
+    failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TestEvidence = z.infer<typeof TestEvidenceSchema>;
+export declare const DiffEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"diff">;
+    files_changed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    additions: z.ZodDefault<z.ZodNumber>;
+    deletions: z.ZodDefault<z.ZodNumber>;
+    patch_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DiffEvidence = z.infer<typeof DiffEvidenceSchema>;
+export declare const ApprovalEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"approval">;
+}, z.core.$strip>;
+export type ApprovalEvidence = z.infer<typeof ApprovalEvidenceSchema>;
+export declare const NoteEvidenceSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"note">;
+}, z.core.$strip>;
+export type NoteEvidence = z.infer<typeof NoteEvidenceSchema>;
+export declare const EvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"review">;
+    risk: z.ZodEnum<{
+        medium: "medium";
+        low: "low";
+        high: "high";
+        critical: "critical";
+    }>;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"test">;
+    tests_passed: z.ZodNumber;
+    tests_failed: z.ZodNumber;
+    test_file: z.ZodOptional<z.ZodString>;
+    failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"diff">;
+    files_changed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    additions: z.ZodDefault<z.ZodNumber>;
+    deletions: z.ZodDefault<z.ZodNumber>;
+    patch_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"approval">;
+}, z.core.$strip>, z.ZodObject<{
+    task_id: z.ZodString;
+    timestamp: z.ZodString;
+    agent: z.ZodString;
+    verdict: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        approved: "approved";
+        rejected: "rejected";
+        info: "info";
+    }>;
+    summary: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"note">;
+}, z.core.$strip>], "type">;
+export type Evidence = z.infer<typeof EvidenceSchema>;
+export declare const EvidenceBundleSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    task_id: z.ZodString;
+    entries: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        task_id: z.ZodString;
+        timestamp: z.ZodString;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            approved: "approved";
+            rejected: "rejected";
+            info: "info";
+        }>;
+        summary: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"review">;
+        risk: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+            critical: "critical";
+        }>;
+        issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+            }>;
+            message: z.ZodString;
+            file: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        task_id: z.ZodString;
+        timestamp: z.ZodString;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            approved: "approved";
+            rejected: "rejected";
+            info: "info";
+        }>;
+        summary: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"test">;
+        tests_passed: z.ZodNumber;
+        tests_failed: z.ZodNumber;
+        test_file: z.ZodOptional<z.ZodString>;
+        failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        task_id: z.ZodString;
+        timestamp: z.ZodString;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            approved: "approved";
+            rejected: "rejected";
+            info: "info";
+        }>;
+        summary: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"diff">;
+        files_changed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        additions: z.ZodDefault<z.ZodNumber>;
+        deletions: z.ZodDefault<z.ZodNumber>;
+        patch_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        task_id: z.ZodString;
+        timestamp: z.ZodString;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            approved: "approved";
+            rejected: "rejected";
+            info: "info";
+        }>;
+        summary: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"approval">;
+    }, z.core.$strip>, z.ZodObject<{
+        task_id: z.ZodString;
+        timestamp: z.ZodString;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            approved: "approved";
+            rejected: "rejected";
+            info: "info";
+        }>;
+        summary: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodLiteral<"note">;
+    }, z.core.$strip>], "type">>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type EvidenceBundle = z.infer<typeof EvidenceBundleSchema>;

package/dist/config/index.d.ts

@@ -1,5 +1,9 @@
-export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, DEFAULT_MODELS, ORCHESTRATOR_NAME, PIPELINE_AGENTS, QA_AGENTS, isQAAgent, isSubagent, } from './constants';
 export type { AgentName, PipelineAgentName, QAAgentName, } from './constants';
-export { AgentOverrideConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';
-export type { AgentOverrideConfig, PluginConfig, SwarmConfig, } from './schema';
+export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, DEFAULT_MODELS, isQAAgent, isSubagent, ORCHESTRATOR_NAME, PIPELINE_AGENTS, QA_AGENTS, } from './constants';
 export { loadAgentPrompt, loadPluginConfig, } from './loader';
+export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
+export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
+export type { ApprovalEvidence, BaseEvidence, DiffEvidence, Evidence, EvidenceBundle, EvidenceType, EvidenceVerdict, NoteEvidence, ReviewEvidence, TestEvidence, } from './evidence-schema';
+export { ApprovalEvidenceSchema, BaseEvidenceSchema, DiffEvidenceSchema, EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceBundleSchema, EvidenceSchema, EvidenceTypeSchema, EvidenceVerdictSchema, NoteEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, } from './evidence-schema';
+export type { AgentOverrideConfig, PluginConfig, SwarmConfig, } from './schema';
+export { AgentOverrideConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';

package/dist/config/plan-schema.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    in_progress: "in_progress";
+    completed: "completed";
+    blocked: "blocked";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TaskSizeSchema: z.ZodEnum<{
+    small: "small";
+    medium: "medium";
+    large: "large";
+}>;
+export type TaskSize = z.infer<typeof TaskSizeSchema>;
+export declare const PhaseStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    in_progress: "in_progress";
+    blocked: "blocked";
+    complete: "complete";
+}>;
+export type PhaseStatus = z.infer<typeof PhaseStatusSchema>;
+export declare const MigrationStatusSchema: z.ZodEnum<{
+    native: "native";
+    migrated: "migrated";
+    migration_failed: "migration_failed";
+}>;
+export type MigrationStatus = z.infer<typeof MigrationStatusSchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    phase: z.ZodNumber;
+    status: z.ZodDefault<z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        blocked: "blocked";
+    }>>;
+    size: z.ZodDefault<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>;
+    description: z.ZodString;
+    depends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    acceptance: z.ZodOptional<z.ZodString>;
+    files_touched: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidence_path: z.ZodOptional<z.ZodString>;
+    blocked_reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const PhaseSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        blocked: "blocked";
+        complete: "complete";
+    }>>;
+    tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        phase: z.ZodNumber;
+        status: z.ZodDefault<z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            blocked: "blocked";
+        }>>;
+        size: z.ZodDefault<z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        description: z.ZodString;
+        depends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        acceptance: z.ZodOptional<z.ZodString>;
+        files_touched: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        evidence_path: z.ZodOptional<z.ZodString>;
+        blocked_reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Phase = z.infer<typeof PhaseSchema>;
+export declare const PlanSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    title: z.ZodString;
+    swarm: z.ZodString;
+    current_phase: z.ZodNumber;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            blocked: "blocked";
+            complete: "complete";
+        }>>;
+        tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            phase: z.ZodNumber;
+            status: z.ZodDefault<z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                blocked: "blocked";
+            }>>;
+            size: z.ZodDefault<z.ZodEnum<{
+                small: "small";
+                medium: "medium";
+                large: "large";
+            }>>;
+            description: z.ZodString;
+            depends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            acceptance: z.ZodOptional<z.ZodString>;
+            files_touched: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            evidence_path: z.ZodOptional<z.ZodString>;
+            blocked_reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    migration_status: z.ZodOptional<z.ZodEnum<{
+        native: "native";
+        migrated: "migrated";
+        migration_failed: "migration_failed";
+    }>>;
+}, z.core.$strip>;
+export type Plan = z.infer<typeof PlanSchema>;