opencode-swarm 4.5.0 → 5.0.2

package/dist/index.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -9,6 +24,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = import.meta.require;
 
 // src/config/constants.ts
 var QA_AGENTS = ["reviewer", "critic"];
@@ -33,6 +49,11 @@ var DEFAULT_MODELS = {
   critic: "google/gemini-2.0-flash",
   default: "google/gemini-2.0-flash"
 };
+// src/config/loader.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -13586,8 +13607,48 @@ var ContextBudgetConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   warn_threshold: exports_external.number().min(0).max(1).default(0.7),
   critical_threshold: exports_external.number().min(0).max(1).default(0.9),
-  model_limits: exports_external.record(exports_external.string(), exports_external.number().min(1000)).default({ default: 128000 })
+  model_limits: exports_external.record(exports_external.string(), exports_external.number().min(1000)).default({ default: 128000 }),
+  max_injection_tokens: exports_external.number().min(100).max(50000).default(4000)
 });
+var EvidenceConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  max_age_days: exports_external.number().min(1).max(365).default(90),
+  max_bundles: exports_external.number().min(10).max(1e4).default(1000),
+  auto_archive: exports_external.boolean().default(false)
+});
+var GuardrailsProfileSchema = exports_external.object({
+  max_tool_calls: exports_external.number().min(10).max(1000).optional(),
+  max_duration_minutes: exports_external.number().min(1).max(120).optional(),
+  max_repetitions: exports_external.number().min(3).max(50).optional(),
+  max_consecutive_errors: exports_external.number().min(2).max(20).optional(),
+  warning_threshold: exports_external.number().min(0.1).max(0.9).optional()
+});
+var DEFAULT_ARCHITECT_PROFILE = {
+  max_tool_calls: 600,
+  max_duration_minutes: 90,
+  max_consecutive_errors: 8,
+  warning_threshold: 0.7
+};
+var GuardrailsConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  max_tool_calls: exports_external.number().min(10).max(1000).default(200),
+  max_duration_minutes: exports_external.number().min(1).max(120).default(30),
+  max_repetitions: exports_external.number().min(3).max(50).default(10),
+  max_consecutive_errors: exports_external.number().min(2).max(20).default(5),
+  warning_threshold: exports_external.number().min(0.1).max(0.9).default(0.5),
+  profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional()
+});
+function resolveGuardrailsConfig(base, agentName) {
+  if (!agentName) {
+    return base;
+  }
+  const builtIn = agentName === ORCHESTRATOR_NAME ? DEFAULT_ARCHITECT_PROFILE : undefined;
+  const userProfile = base.profiles?.[agentName];
+  if (!builtIn && !userProfile) {
+    return base;
+  }
+  return { ...base, ...builtIn, ...userProfile };
+}
 var PluginConfigSchema = exports_external.object({
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
@@ -13595,12 +13656,12 @@ var PluginConfigSchema = exports_external.object({
   qa_retry_limit: exports_external.number().min(1).max(10).default(3),
   inject_phase_reminders: exports_external.boolean().default(true),
   hooks: HooksConfigSchema.optional(),
-  context_budget: ContextBudgetConfigSchema.optional()
+  context_budget: ContextBudgetConfigSchema.optional(),
+  guardrails: GuardrailsConfigSchema.optional(),
+  evidence: EvidenceConfigSchema.optional()
 });
+
 // src/config/loader.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
 var CONFIG_FILENAME = "opencode-swarm.json";
 var PROMPTS_DIR_NAME = "opencode-swarm";
 var MAX_CONFIG_FILE_BYTES = 102400;
@@ -13693,6 +13754,125 @@ function loadAgentPrompt(agentName) {
   }
   return result;
 }
+// src/config/plan-schema.ts
+var TaskStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked"
+]);
+var TaskSizeSchema = exports_external.enum(["small", "medium", "large"]);
+var PhaseStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "complete",
+  "blocked"
+]);
+var MigrationStatusSchema = exports_external.enum([
+  "native",
+  "migrated",
+  "migration_failed"
+]);
+var TaskSchema = exports_external.object({
+  id: exports_external.string(),
+  phase: exports_external.number().int().min(1),
+  status: TaskStatusSchema.default("pending"),
+  size: TaskSizeSchema.default("small"),
+  description: exports_external.string().min(1),
+  depends: exports_external.array(exports_external.string()).default([]),
+  acceptance: exports_external.string().optional(),
+  files_touched: exports_external.array(exports_external.string()).default([]),
+  evidence_path: exports_external.string().optional(),
+  blocked_reason: exports_external.string().optional()
+});
+var PhaseSchema = exports_external.object({
+  id: exports_external.number().int().min(1),
+  name: exports_external.string().min(1),
+  status: PhaseStatusSchema.default("pending"),
+  tasks: exports_external.array(TaskSchema).default([])
+});
+var PlanSchema = exports_external.object({
+  schema_version: exports_external.literal("1.0.0"),
+  title: exports_external.string().min(1),
+  swarm: exports_external.string().min(1),
+  current_phase: exports_external.number().int().min(1),
+  phases: exports_external.array(PhaseSchema).min(1),
+  migration_status: MigrationStatusSchema.optional()
+});
+// src/config/evidence-schema.ts
+var EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
+var EVIDENCE_MAX_PATCH_BYTES = 5 * 1024 * 1024;
+var EVIDENCE_MAX_TASK_BYTES = 20 * 1024 * 1024;
+var EvidenceTypeSchema = exports_external.enum([
+  "review",
+  "test",
+  "diff",
+  "approval",
+  "note"
+]);
+var EvidenceVerdictSchema = exports_external.enum([
+  "pass",
+  "fail",
+  "approved",
+  "rejected",
+  "info"
+]);
+var BaseEvidenceSchema = exports_external.object({
+  task_id: exports_external.string().min(1),
+  type: EvidenceTypeSchema,
+  timestamp: exports_external.string().datetime(),
+  agent: exports_external.string().min(1),
+  verdict: EvidenceVerdictSchema,
+  summary: exports_external.string().min(1),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var ReviewEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("review"),
+  risk: exports_external.enum(["low", "medium", "high", "critical"]),
+  issues: exports_external.array(exports_external.object({
+    severity: exports_external.enum(["error", "warning", "info"]),
+    message: exports_external.string().min(1),
+    file: exports_external.string().optional(),
+    line: exports_external.number().int().optional()
+  })).default([])
+});
+var TestEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("test"),
+  tests_passed: exports_external.number().int().min(0),
+  tests_failed: exports_external.number().int().min(0),
+  test_file: exports_external.string().optional(),
+  failures: exports_external.array(exports_external.object({
+    name: exports_external.string().min(1),
+    message: exports_external.string().min(1)
+  })).default([])
+});
+var DiffEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("diff"),
+  files_changed: exports_external.array(exports_external.string()).default([]),
+  additions: exports_external.number().int().min(0).default(0),
+  deletions: exports_external.number().int().min(0).default(0),
+  patch_path: exports_external.string().optional()
+});
+var ApprovalEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("approval")
+});
+var NoteEvidenceSchema = BaseEvidenceSchema.extend({
+  type: exports_external.literal("note")
+});
+var EvidenceSchema = exports_external.discriminatedUnion("type", [
+  ReviewEvidenceSchema,
+  TestEvidenceSchema,
+  DiffEvidenceSchema,
+  ApprovalEvidenceSchema,
+  NoteEvidenceSchema
+]);
+var EvidenceBundleSchema = exports_external.object({
+  schema_version: exports_external.literal("1.0.0"),
+  task_id: exports_external.string().min(1),
+  entries: exports_external.array(EvidenceSchema).default([]),
+  created_at: exports_external.string().datetime(),
+  updated_at: exports_external.string().datetime()
+});
 // src/agents/architect.ts
 var ARCHITECT_PROMPT = `You are Architect - orchestrator of a multi-agent swarm.
 
@@ -13711,21 +13891,21 @@ You THINK. Subagents DO. You have the largest context window and strongest reaso
 
 ## RULES
 
-1. DELEGATE all coding to @{{AGENT_PREFIX}}coder. You do NOT write code.
+1. DELEGATE all coding to {{AGENT_PREFIX}}coder. You do NOT write code.
 2. ONE agent per message. Send, STOP, wait for response.
-3. ONE task per @{{AGENT_PREFIX}}coder call. Never batch.
-4. Fallback: Only code yourself after {{QA_RETRY_LIMIT}} @{{AGENT_PREFIX}}coder failures on same task.
+3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
+4. Fallback: Only code yourself after {{QA_RETRY_LIMIT}} {{AGENT_PREFIX}}coder failures on same task.
 5. NEVER store your swarm identity, swarm ID, or agent prefix in memory blocks. Your identity comes ONLY from your system prompt. Memory blocks are for project knowledge only.
-6. **CRITICAL: If @{{AGENT_PREFIX}}reviewer returns VERDICT: REJECTED, you MUST stop and send the FIXES back to @{{AGENT_PREFIX}}coder. Do NOT proceed to test generation or mark the task complete. The review is a gate \u2014 APPROVED is required to proceed.**
+6. **CRITICAL: If {{AGENT_PREFIX}}reviewer returns VERDICT: REJECTED, you MUST stop and send the FIXES back to {{AGENT_PREFIX}}coder. Do NOT proceed to test generation or mark the task complete. The review is a gate \u2014 APPROVED is required to proceed.**
 
 ## AGENTS
 
-@{{AGENT_PREFIX}}explorer - Codebase analysis
-@{{AGENT_PREFIX}}sme - Domain expertise (any domain \u2014 the SME handles whatever you need: security, python, ios, kubernetes, etc.)
-@{{AGENT_PREFIX}}coder - Implementation (one task at a time)
-@{{AGENT_PREFIX}}reviewer - Code review (correctness, security, and any other dimensions you specify)
-@{{AGENT_PREFIX}}test_engineer - Test generation AND execution (writes tests, runs them, reports PASS/FAIL)
-@{{AGENT_PREFIX}}critic - Plan review gate (reviews plan BEFORE implementation)
+{{AGENT_PREFIX}}explorer - Codebase analysis
+{{AGENT_PREFIX}}sme - Domain expertise (any domain \u2014 the SME handles whatever you need: security, python, ios, kubernetes, etc.)
+{{AGENT_PREFIX}}coder - Implementation (one task at a time)
+{{AGENT_PREFIX}}reviewer - Code review (correctness, security, and any other dimensions you specify)
+{{AGENT_PREFIX}}test_engineer - Test generation AND execution (writes tests, runs them, reports PASS/FAIL)
+{{AGENT_PREFIX}}critic - Plan review gate (reviews plan BEFORE implementation)
 
 SMEs advise only. Reviewer and critic review only. None of them write code.
 
@@ -13733,7 +13913,7 @@ SMEs advise only. Reviewer and critic review only. None of them write code.
 
 All delegations use this structure:
 
-@{{AGENT_PREFIX}}[agent]
+{{AGENT_PREFIX}}[agent]
 TASK: [single objective]
 FILE: [path] (if applicable)
 INPUT: [what to analyze/use]
@@ -13742,43 +13922,43 @@ CONSTRAINT: [what NOT to do]
 
 Examples:
 
-@{{AGENT_PREFIX}}explorer
+{{AGENT_PREFIX}}explorer
 TASK: Analyze codebase for auth implementation
 INPUT: Focus on src/auth/, src/middleware/
 OUTPUT: Structure, frameworks, key files, relevant domains
 
-@{{AGENT_PREFIX}}sme
+{{AGENT_PREFIX}}sme
 TASK: Review auth token patterns
 DOMAIN: security
 INPUT: src/auth/login.ts uses JWT with RS256
 OUTPUT: Security considerations, recommended patterns
 CONSTRAINT: Focus on auth only, not general code style
 
-@{{AGENT_PREFIX}}sme
+{{AGENT_PREFIX}}sme
 TASK: Advise on state management approach
 DOMAIN: ios
 INPUT: Building a SwiftUI app with offline-first sync
 OUTPUT: Recommended patterns, frameworks, gotchas
 
-@{{AGENT_PREFIX}}coder
+{{AGENT_PREFIX}}coder
 TASK: Add input validation to login
 FILE: src/auth/login.ts
 INPUT: Validate email format, password >= 8 chars
 OUTPUT: Modified file
 CONSTRAINT: Do not modify other functions
 
-@{{AGENT_PREFIX}}reviewer
+{{AGENT_PREFIX}}reviewer
 TASK: Review login validation
 FILE: src/auth/login.ts
 CHECK: [security, correctness, edge-cases]
 OUTPUT: VERDICT + RISK + ISSUES
 
-@{{AGENT_PREFIX}}test_engineer
+{{AGENT_PREFIX}}test_engineer
 TASK: Generate and run login validation tests
 FILE: src/auth/login.ts
 OUTPUT: Test file at src/auth/login.test.ts + VERDICT: PASS/FAIL with failure details
 
-@{{AGENT_PREFIX}}critic
+{{AGENT_PREFIX}}critic
 TASK: Review plan for user authentication feature
 PLAN: [paste the plan.md content]
 CONTEXT: [codebase summary from explorer]
@@ -13804,7 +13984,7 @@ Ambiguous request \u2192 Ask up to 3 questions, wait for answers
 Clear request \u2192 Phase 2
 
 ### Phase 2: Discover
-Delegate to @{{AGENT_PREFIX}}explorer. Wait for response.
+Delegate to {{AGENT_PREFIX}}explorer. Wait for response.
 For complex tasks, make a second explorer call focused on risk/gap analysis:
 - Hidden requirements, unstated assumptions, scope risks
 - Existing patterns that the implementation must follow
@@ -13812,7 +13992,7 @@ For complex tasks, make a second explorer call focused on risk/gap analysis:
 ### Phase 3: Consult SMEs
 Check .swarm/context.md for cached guidance first.
 Identify 1-3 relevant domains from the task requirements.
-Call @{{AGENT_PREFIX}}sme once per domain, serially. Max 3 SME calls per project phase.
+Call {{AGENT_PREFIX}}sme once per domain, serially. Max 3 SME calls per project phase.
 Re-consult if a new domain emerges or if significant changes require fresh evaluation.
 Cache guidance in context.md.
 
@@ -13826,7 +14006,7 @@ Create .swarm/context.md:
 - Decisions, patterns, SME cache, file map
 
 ### Phase 4.5: Critic Gate
-Delegate plan to @{{AGENT_PREFIX}}critic for review BEFORE any implementation begins.
+Delegate plan to {{AGENT_PREFIX}}critic for review BEFORE any implementation begins.
 - Send the full plan.md content and codebase context summary
 - **APPROVED** \u2192 Proceed to Phase 5
 - **NEEDS_REVISION** \u2192 Revise the plan based on critic feedback, then resubmit (max 2 revision cycles)
@@ -13835,18 +14015,18 @@ Delegate plan to @{{AGENT_PREFIX}}critic for review BEFORE any implementation be
 ### Phase 5: Execute
 For each task (respecting dependencies):
 
-5a. @{{AGENT_PREFIX}}coder - Implement (MANDATORY)
-5b. @{{AGENT_PREFIX}}reviewer - Review (specify CHECK dimensions relevant to the change)
+5a. {{AGENT_PREFIX}}coder - Implement (MANDATORY)
+5b. {{AGENT_PREFIX}}reviewer - Review (specify CHECK dimensions relevant to the change)
 5c. **GATE - Check VERDICT:**
     - **APPROVED** \u2192 Proceed to 5d
-    - **REJECTED** (attempt < {{QA_RETRY_LIMIT}}) \u2192 STOP. Send FIXES to @{{AGENT_PREFIX}}coder with specific changes. Retry from 5a. Do NOT proceed to 5d.
+    - **REJECTED** (attempt < {{QA_RETRY_LIMIT}}) \u2192 STOP. Send FIXES to {{AGENT_PREFIX}}coder with specific changes. Retry from 5a. Do NOT proceed to 5d.
     - **REJECTED** (attempt {{QA_RETRY_LIMIT}}) \u2192 STOP. Escalate to user or handle directly.
-5d. @{{AGENT_PREFIX}}test_engineer - Generate AND run tests (ONLY if 5c = APPROVED). Expect VERDICT: PASS/FAIL.
-5e. If test VERDICT is FAIL \u2192 Send failures to @{{AGENT_PREFIX}}coder for fixes, then re-run from 5b.
+5d. {{AGENT_PREFIX}}test_engineer - Generate AND run tests (ONLY if 5c = APPROVED). Expect VERDICT: PASS/FAIL.
+5e. If test VERDICT is FAIL \u2192 Send failures to {{AGENT_PREFIX}}coder for fixes, then re-run from 5b.
 5f. Update plan.md [x], proceed to next task (ONLY if tests PASS)
 
 ### Phase 6: Phase Complete
-1. @{{AGENT_PREFIX}}explorer - Rescan
+1. {{AGENT_PREFIX}}explorer - Rescan
 2. Update context.md
 3. Summarize to user
 4. Ask: "Ready for Phase [N+1]?"
@@ -14388,12 +14568,12 @@ function getAgentConfigs(config2) {
 }
 
 // src/commands/agents.ts
-function handleAgentsCommand(agents) {
+function handleAgentsCommand(agents, guardrails) {
   const entries = Object.entries(agents);
   if (entries.length === 0) {
     return "No agents registered.";
   }
-  const lines = ["## Registered Agents", ""];
+  const lines = [`## Registered Agents (${entries.length} total)`, ""];
   for (const [key, agent] of entries) {
     const model = agent.config.model || "default";
     const temp = agent.config.temperature !== undefined ? agent.config.temperature.toString() : "default";
@@ -14401,43 +14581,46 @@ function handleAgentsCommand(agents) {
     const isReadOnly = tools.write === false || tools.edit === false;
     const access = isReadOnly ? "\uD83D\uDD12 read-only" : "\u270F\uFE0F read-write";
     const desc = agent.description || agent.config.description || "";
-    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access}`);
+    const hasCustomProfile = guardrails?.profiles?.[key] !== undefined;
+    const profileIndicator = hasCustomProfile ? " | \u26A1 custom limits" : "";
+    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access}${profileIndicator}`);
     if (desc) {
       lines.push(`  ${desc}`);
     }
   }
+  if (guardrails?.profiles && Object.keys(guardrails.profiles).length > 0) {
+    lines.push("", "### Guardrail Profiles", "");
+    for (const [profileName, profile] of Object.entries(guardrails.profiles)) {
+      const overrides = [];
+      if (profile.max_tool_calls !== undefined) {
+        overrides.push(`max_tool_calls=${profile.max_tool_calls}`);
+      }
+      if (profile.max_duration_minutes !== undefined) {
+        overrides.push(`max_duration_minutes=${profile.max_duration_minutes}`);
+      }
+      if (profile.max_repetitions !== undefined) {
+        overrides.push(`max_repetitions=${profile.max_repetitions}`);
+      }
+      if (profile.max_consecutive_errors !== undefined) {
+        overrides.push(`max_consecutive_errors=${profile.max_consecutive_errors}`);
+      }
+      if (profile.warning_threshold !== undefined) {
+        overrides.push(`warning_threshold=${profile.warning_threshold}`);
+      }
+      const overrideStr = overrides.length > 0 ? overrides.join(", ") : "no overrides";
+      lines.push(`- **${profileName}**: ${overrideStr}`);
+    }
+  }
   return lines.join(`
 `);
 }
 
-// src/commands/config.ts
-import * as os2 from "os";
-import * as path2 from "path";
-function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path2.join(os2.homedir(), ".config");
-}
-async function handleConfigCommand(directory, _args) {
-  const config2 = loadPluginConfig(directory);
-  const userConfigPath = path2.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path2.join(directory, ".opencode", "opencode-swarm.json");
-  const lines = [
-    "## Swarm Configuration",
-    "",
-    "### Config Files",
-    `- User: \`${userConfigPath}\``,
-    `- Project: \`${projectConfigPath}\``,
-    "",
-    "### Resolved Config",
-    "```json",
-    JSON.stringify(config2, null, 2),
-    "```"
-  ];
-  return lines.join(`
-`);
-}
+// src/evidence/manager.ts
+import { mkdirSync, readdirSync, renameSync, rmSync, statSync as statSync2 } from "fs";
+import * as path3 from "path";
 
 // src/hooks/utils.ts
-import * as path3 from "path";
+import * as path2 from "path";
 
 // src/utils/errors.ts
 class SwarmError extends Error {
@@ -14504,14 +14687,14 @@ function validateSwarmPath(directory, filename) {
   if (/\.\.[/\\]/.test(filename)) {
     throw new Error("Invalid filename: path traversal detected");
   }
-  const baseDir = path3.normalize(path3.resolve(directory, ".swarm"));
-  const resolved = path3.normalize(path3.resolve(baseDir, filename));
+  const baseDir = path2.normalize(path2.resolve(directory, ".swarm"));
+  const resolved = path2.normalize(path2.resolve(baseDir, filename));
   if (process.platform === "win32") {
-    if (!resolved.toLowerCase().startsWith((baseDir + path3.sep).toLowerCase())) {
+    if (!resolved.toLowerCase().startsWith((baseDir + path2.sep).toLowerCase())) {
       throw new Error("Invalid filename: path escapes .swarm directory");
     }
   } else {
-    if (!resolved.startsWith(baseDir + path3.sep)) {
+    if (!resolved.startsWith(baseDir + path2.sep)) {
       throw new Error("Invalid filename: path escapes .swarm directory");
     }
   }
@@ -14534,30 +14717,535 @@ function estimateTokens(text) {
   return Math.ceil(text.length * 0.33);
 }
 
+// src/evidence/manager.ts
+var TASK_ID_REGEX = /^[\w-]+(\.[\w-]+)*$/;
+function sanitizeTaskId(taskId) {
+  if (!taskId || taskId.length === 0) {
+    throw new Error("Invalid task ID: empty string");
+  }
+  if (/\0/.test(taskId)) {
+    throw new Error("Invalid task ID: contains null bytes");
+  }
+  for (let i = 0;i < taskId.length; i++) {
+    if (taskId.charCodeAt(i) < 32) {
+      throw new Error("Invalid task ID: contains control characters");
+    }
+  }
+  if (taskId.includes("..") || taskId.includes("../") || taskId.includes("..\\")) {
+    throw new Error("Invalid task ID: path traversal detected");
+  }
+  if (!TASK_ID_REGEX.test(taskId)) {
+    throw new Error(`Invalid task ID: must match pattern ^[\\w-]+(\\.[\\w-]+)*$, got "${taskId}"`);
+  }
+  return taskId;
+}
+async function loadEvidence(directory, taskId) {
+  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const relativePath = path3.join("evidence", sanitizedTaskId, "evidence.json");
+  validateSwarmPath(directory, relativePath);
+  const content = await readSwarmFileAsync(directory, relativePath);
+  if (content === null) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    const validated = EvidenceBundleSchema.parse(parsed);
+    return validated;
+  } catch (error49) {
+    warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
+    return null;
+  }
+}
+async function listEvidenceTaskIds(directory) {
+  const evidenceBasePath = validateSwarmPath(directory, "evidence");
+  try {
+    statSync2(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  let entries;
+  try {
+    entries = readdirSync(evidenceBasePath);
+  } catch {
+    return [];
+  }
+  const taskIds = [];
+  for (const entry of entries) {
+    const entryPath = path3.join(evidenceBasePath, entry);
+    try {
+      const stats = statSync2(entryPath);
+      if (!stats.isDirectory()) {
+        continue;
+      }
+      sanitizeTaskId(entry);
+      taskIds.push(entry);
+    } catch (error49) {
+      if (error49 instanceof Error && !error49.message.startsWith("Invalid task ID")) {
+        warn(`Error reading evidence entry '${entry}': ${error49.message}`);
+      }
+    }
+  }
+  return taskIds.sort();
+}
+async function deleteEvidence(directory, taskId) {
+  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const relativePath = path3.join("evidence", sanitizedTaskId);
+  const evidenceDir = validateSwarmPath(directory, relativePath);
+  try {
+    statSync2(evidenceDir);
+  } catch {
+    return false;
+  }
+  try {
+    rmSync(evidenceDir, { recursive: true, force: true });
+    return true;
+  } catch (error49) {
+    warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
+    return false;
+  }
+}
+async function archiveEvidence(directory, maxAgeDays, maxBundles) {
+  const taskIds = await listEvidenceTaskIds(directory);
+  const cutoffDate = new Date;
+  cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+  const cutoffIso = cutoffDate.toISOString();
+  const archived = [];
+  const remainingBundles = [];
+  for (const taskId of taskIds) {
+    const bundle = await loadEvidence(directory, taskId);
+    if (!bundle) {
+      continue;
+    }
+    if (bundle.updated_at < cutoffIso) {
+      const deleted = await deleteEvidence(directory, taskId);
+      if (deleted) {
+        archived.push(taskId);
+      }
+    } else {
+      remainingBundles.push({
+        taskId,
+        updatedAt: bundle.updated_at
+      });
+    }
+  }
+  if (maxBundles !== undefined && remainingBundles.length > maxBundles) {
+    remainingBundles.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+    const toDelete = remainingBundles.length - maxBundles;
+    for (let i = 0;i < toDelete; i++) {
+      const deleted = await deleteEvidence(directory, remainingBundles[i].taskId);
+      if (deleted) {
+        archived.push(remainingBundles[i].taskId);
+      }
+    }
+  }
+  return archived;
+}
+
+// src/commands/archive.ts
+async function handleArchiveCommand(directory, args) {
+  const config2 = loadPluginConfig(directory);
+  const maxAgeDays = config2?.evidence?.max_age_days ?? 90;
+  const maxBundles = config2?.evidence?.max_bundles ?? 1000;
+  const dryRun = args.includes("--dry-run");
+  const beforeTaskIds = await listEvidenceTaskIds(directory);
+  if (beforeTaskIds.length === 0) {
+    return "No evidence bundles to archive.";
+  }
+  if (dryRun) {
+    const cutoffDate = new Date;
+    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+    const cutoffIso = cutoffDate.toISOString();
+    const wouldArchiveAge = [];
+    const remainingBundles = [];
+    for (const taskId of beforeTaskIds) {
+      const bundle = await loadEvidence(directory, taskId);
+      if (bundle && bundle.updated_at < cutoffIso) {
+        wouldArchiveAge.push(taskId);
+      } else if (bundle) {
+        remainingBundles.push({ taskId, updatedAt: bundle.updated_at });
+      }
+    }
+    const wouldArchiveMaxBundles = [];
+    const remainingAfterAge = beforeTaskIds.length - wouldArchiveAge.length;
+    if (remainingAfterAge > maxBundles) {
+      remainingBundles.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+      const excessCount = remainingAfterAge - maxBundles;
+      wouldArchiveMaxBundles.push(...remainingBundles.slice(0, excessCount).map((b) => b.taskId));
+    }
+    const totalWouldArchive = wouldArchiveAge.length + wouldArchiveMaxBundles.length;
+    if (totalWouldArchive === 0) {
+      return `No evidence bundles older than ${maxAgeDays} days found, and bundle count (${beforeTaskIds.length}) is within max_bundles limit (${maxBundles}).`;
+    }
+    const lines2 = [
+      "## Archive Preview (dry run)",
+      "",
+      `**Retention**: ${maxAgeDays} days`,
+      `**Max bundles**: ${maxBundles}`,
+      `**Would archive**: ${totalWouldArchive} bundle(s)`
+    ];
+    if (wouldArchiveAge.length > 0) {
+      lines2.push("", `**Age-based (${wouldArchiveAge.length})**:`, ...wouldArchiveAge.map((id) => `- ${id}`));
+    }
+    if (wouldArchiveMaxBundles.length > 0) {
+      lines2.push("", `**Max bundles limit (${wouldArchiveMaxBundles.length})**:`, ...wouldArchiveMaxBundles.map((id) => `- ${id}`));
+    }
+    return lines2.join(`
+`);
+  }
+  const archived = await archiveEvidence(directory, maxAgeDays, maxBundles);
+  if (archived.length === 0) {
+    return `No evidence bundles older than ${maxAgeDays} days found.`;
+  }
+  const lines = [
+    "## Evidence Archived",
+    "",
+    `**Retention**: ${maxAgeDays} days`,
+    `**Archived**: ${archived.length} bundle(s)`,
+    "",
+    ...archived.map((id) => `- ${id}`)
+  ];
+  return lines.join(`
+`);
+}
+
+// src/commands/config.ts
+import * as os2 from "os";
+import * as path4 from "path";
+function getUserConfigDir2() {
+  return process.env.XDG_CONFIG_HOME || path4.join(os2.homedir(), ".config");
+}
+async function handleConfigCommand(directory, _args) {
+  const config2 = loadPluginConfig(directory);
+  const userConfigPath = path4.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path4.join(directory, ".opencode", "opencode-swarm.json");
+  const lines = [
+    "## Swarm Configuration",
+    "",
+    "### Config Files",
+    `- User: \`${userConfigPath}\``,
+    `- Project: \`${projectConfigPath}\``,
+    "",
+    "### Resolved Config",
+    "```json",
+    JSON.stringify(config2, null, 2),
+    "```"
+  ];
+  return lines.join(`
+`);
+}
+
+// src/plan/manager.ts
+import * as path5 from "path";
+async function loadPlanJsonOnly(directory) {
+  const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
+  if (planJsonContent !== null) {
+    try {
+      const parsed = JSON.parse(planJsonContent);
+      const validated = PlanSchema.parse(parsed);
+      return validated;
+    } catch (error49) {
+      warn(`Plan validation failed for .swarm/plan.json: ${error49 instanceof Error ? error49.message : String(error49)}`);
+    }
+  }
+  return null;
+}
+async function loadPlan(directory) {
+  const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
+  if (planJsonContent !== null) {
+    try {
+      const parsed = JSON.parse(planJsonContent);
+      const validated = PlanSchema.parse(parsed);
+      return validated;
+    } catch (error49) {
+      warn(`Plan validation failed for .swarm/plan.json: ${error49 instanceof Error ? error49.message : String(error49)}`);
+    }
+  }
+  const planMdContent = await readSwarmFileAsync(directory, "plan.md");
+  if (planMdContent !== null) {
+    const migrated = migrateLegacyPlan(planMdContent);
+    await savePlan(directory, migrated);
+    return migrated;
+  }
+  return null;
+}
+async function savePlan(directory, plan) {
+  const validated = PlanSchema.parse(plan);
+  const swarmDir = path5.resolve(directory, ".swarm");
+  const planPath = path5.join(swarmDir, "plan.json");
+  const tempPath = path5.join(swarmDir, `plan.json.tmp.${Date.now()}`);
+  await Bun.write(tempPath, JSON.stringify(validated, null, 2));
+  const { renameSync: renameSync2 } = await import("fs");
+  renameSync2(tempPath, planPath);
+  const markdown = derivePlanMarkdown(validated);
+  await Bun.write(path5.join(swarmDir, "plan.md"), markdown);
+}
+function derivePlanMarkdown(plan) {
+  const statusMap = {
+    pending: "PENDING",
+    in_progress: "IN PROGRESS",
+    complete: "COMPLETE",
+    blocked: "BLOCKED"
+  };
+  const now = new Date().toISOString();
+  const phaseStatus = statusMap[plan.phases[plan.current_phase - 1]?.status] || "PENDING";
+  let markdown = `# ${plan.title}
+Swarm: ${plan.swarm}
+Phase: ${plan.current_phase} [${phaseStatus}] | Updated: ${now}
+`;
+  for (const phase of plan.phases) {
+    const phaseStatusText = statusMap[phase.status] || "PENDING";
+    markdown += `
+## Phase ${phase.id}: ${phase.name} [${phaseStatusText}]
+`;
+    let currentTaskMarked = false;
+    for (const task of phase.tasks) {
+      let taskLine = "";
+      let suffix = "";
+      if (task.status === "completed") {
+        taskLine = `- [x] ${task.id}: ${task.description}`;
+      } else if (task.status === "blocked") {
+        taskLine = `- [BLOCKED] ${task.id}: ${task.description}`;
+        if (task.blocked_reason) {
+          taskLine += ` - ${task.blocked_reason}`;
+        }
+      } else {
+        taskLine = `- [ ] ${task.id}: ${task.description}`;
+      }
+      taskLine += ` [${task.size.toUpperCase()}]`;
+      if (task.depends.length > 0) {
+        suffix += ` (depends: ${task.depends.join(", ")})`;
+      }
+      if (phase.id === plan.current_phase && task.status === "in_progress" && !currentTaskMarked) {
+        suffix += " \u2190 CURRENT";
+        currentTaskMarked = true;
+      }
+      markdown += `${taskLine}${suffix}
+`;
+    }
+  }
+  const phaseSections = markdown.split(`
+## `);
+  if (phaseSections.length > 1) {
+    const header = phaseSections[0];
+    const phases = phaseSections.slice(1).map((p) => `## ${p}`);
+    markdown = `${header}
+---
+${phases.join(`
+---
+`)}`;
+  }
+  return `${markdown.trim()}
+`;
+}
+function migrateLegacyPlan(planContent, swarmId) {
+  const lines = planContent.split(`
+`);
+  let title = "Untitled Plan";
+  let swarm = swarmId || "default-swarm";
+  let currentPhaseNum = 1;
+  const phases = [];
+  let currentPhase = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# ") && title === "Untitled Plan") {
+      title = trimmed.substring(2).trim();
+      continue;
+    }
+    if (trimmed.startsWith("Swarm:")) {
+      swarm = trimmed.substring(6).trim();
+      continue;
+    }
+    if (trimmed.startsWith("Phase:")) {
+      const match = trimmed.match(/Phase:\s*(\d+)/i);
+      if (match) {
+        currentPhaseNum = parseInt(match[1], 10);
+      }
+      continue;
+    }
+    const phaseMatch = trimmed.match(/^##\s*Phase\s+(\d+)(?::\s*([^[]+))?\s*(?:\[([^\]]+)\])?/i);
+    if (phaseMatch) {
+      if (currentPhase !== null) {
+        phases.push(currentPhase);
+      }
+      const phaseId = parseInt(phaseMatch[1], 10);
+      const phaseName = phaseMatch[2]?.trim() || `Phase ${phaseId}`;
+      const statusText = phaseMatch[3]?.toLowerCase() || "pending";
+      const statusMap = {
+        complete: "complete",
+        completed: "complete",
+        "in progress": "in_progress",
+        in_progress: "in_progress",
+        inprogress: "in_progress",
+        pending: "pending",
+        blocked: "blocked"
+      };
+      currentPhase = {
+        id: phaseId,
+        name: phaseName,
+        status: statusMap[statusText] || "pending",
+        tasks: []
+      };
+      continue;
+    }
+    const taskMatch = trimmed.match(/^-\s*\[([^\]]+)\]\s+(\d+\.\d+):\s*(.+?)(?:\s*\[(\w+)\])?(?:\s*-\s*(.+))?$/i);
+    if (taskMatch && currentPhase !== null) {
+      const checkbox = taskMatch[1].toLowerCase();
+      const taskId = taskMatch[2];
+      let description = taskMatch[3].trim();
+      const sizeText = taskMatch[4]?.toLowerCase() || "small";
+      let blockedReason;
+      const dependsMatch = description.match(/\s*\(depends:\s*([^)]+)\)$/i);
+      const depends = [];
+      if (dependsMatch) {
+        const depsText = dependsMatch[1];
+        depends.push(...depsText.split(",").map((d) => d.trim()));
+        description = description.substring(0, dependsMatch.index).trim();
+      }
+      let status = "pending";
+      if (checkbox === "x") {
+        status = "completed";
+      } else if (checkbox === "blocked") {
+        status = "blocked";
+        const blockedReasonMatch = taskMatch[5];
+        if (blockedReasonMatch) {
+          blockedReason = blockedReasonMatch.trim();
+        }
+      }
+      const sizeMap = {
+        small: "small",
+        medium: "medium",
+        large: "large"
+      };
+      const task = {
+        id: taskId,
+        phase: currentPhase.id,
+        status,
+        size: sizeMap[sizeText] || "small",
+        description,
+        depends,
+        acceptance: undefined,
+        files_touched: [],
+        evidence_path: undefined,
+        blocked_reason: blockedReason
+      };
+      currentPhase.tasks.push(task);
+    }
+  }
+  if (currentPhase !== null) {
+    phases.push(currentPhase);
+  }
+  let migrationStatus = "migrated";
+  if (phases.length === 0) {
+    migrationStatus = "migration_failed";
+    phases.push({
+      id: 1,
+      name: "Migration Failed",
+      status: "blocked",
+      tasks: [
+        {
+          id: "1.1",
+          phase: 1,
+          status: "blocked",
+          size: "large",
+          description: "Review and restructure plan manually",
+          depends: [],
+          files_touched: [],
+          blocked_reason: "Legacy plan could not be parsed automatically"
+        }
+      ]
+    });
+  }
+  phases.sort((a, b) => a.id - b.id);
+  const plan = {
+    schema_version: "1.0.0",
+    title,
+    swarm,
+    current_phase: currentPhaseNum,
+    phases,
+    migration_status: migrationStatus
+  };
+  return plan;
+}
+
 // src/commands/diagnose.ts
 async function handleDiagnoseCommand(directory, _args) {
   const checks3 = [];
-  const planContent = await readSwarmFileAsync(directory, "plan.md");
-  const contextContent = await readSwarmFileAsync(directory, "context.md");
-  if (planContent) {
-    const hasPhases = /^## Phase \d+/m.test(planContent);
-    const hasTasks = /^- \[[ x]\]/m.test(planContent);
-    if (hasPhases && hasTasks) {
+  const plan = await loadPlanJsonOnly(directory);
+  if (plan) {
+    checks3.push({
+      name: "plan.json",
+      status: "\u2705",
+      detail: "Valid schema (v1.0.0)"
+    });
+    if (plan.migration_status === "migrated") {
       checks3.push({
-        name: "plan.md",
+        name: "Migration",
         status: "\u2705",
-        detail: "Found with valid phase structure"
+        detail: "Plan was migrated from legacy plan.md"
+      });
+    } else if (plan.migration_status === "migration_failed") {
+      checks3.push({
+        name: "Migration",
+        status: "\u274C",
+        detail: "Migration from plan.md failed \u2014 review manually"
+      });
+    }
+    const allTaskIds = new Set;
+    for (const phase of plan.phases) {
+      for (const task of phase.tasks) {
+        allTaskIds.add(task.id);
+      }
+    }
+    const missingDeps = [];
+    for (const phase of plan.phases) {
+      for (const task of phase.tasks) {
+        for (const dep of task.depends) {
+          if (!allTaskIds.has(dep)) {
+            missingDeps.push(`${task.id} depends on missing ${dep}`);
+          }
+        }
+      }
+    }
+    if (missingDeps.length > 0) {
+      checks3.push({
+        name: "Task DAG",
+        status: "\u274C",
+        detail: `Missing dependencies: ${missingDeps.join(", ")}`
       });
+    } else {
+      checks3.push({
+        name: "Task DAG",
+        status: "\u2705",
+        detail: "All dependencies resolved"
+      });
+    }
+  } else {
+    const planContent = await readSwarmFileAsync(directory, "plan.md");
+    if (planContent) {
+      const hasPhases = /^## Phase \d+/m.test(planContent);
+      const hasTasks = /^- \[[ x]\]/m.test(planContent);
+      if (hasPhases && hasTasks) {
+        checks3.push({
+          name: "plan.md",
+          status: "\u2705",
+          detail: "Found with valid phase structure"
+        });
+      } else {
+        checks3.push({
+          name: "plan.md",
+          status: "\u274C",
+          detail: "Found but missing phase/task structure"
+        });
+      }
     } else {
       checks3.push({
         name: "plan.md",
         status: "\u274C",
-        detail: "Found but missing phase/task structure"
+        detail: "Not found"
       });
     }
-  } else {
-    checks3.push({ name: "plan.md", status: "\u274C", detail: "Not found" });
   }
+  const contextContent = await readSwarmFileAsync(directory, "context.md");
   if (contextContent) {
     checks3.push({ name: "context.md", status: "\u2705", detail: "Found" });
   } else {
@@ -14585,6 +15273,39 @@ async function handleDiagnoseCommand(directory, _args) {
       detail: "Invalid configuration"
     });
   }
+  if (plan) {
+    const completedTaskIds = [];
+    for (const phase of plan.phases) {
+      for (const task of phase.tasks) {
+        if (task.status === "completed") {
+          completedTaskIds.push(task.id);
+        }
+      }
+    }
+    if (completedTaskIds.length > 0) {
+      const evidenceTaskIds = new Set(await listEvidenceTaskIds(directory));
+      const missingEvidence = completedTaskIds.filter((id) => !evidenceTaskIds.has(id));
+      if (missingEvidence.length === 0) {
+        checks3.push({
+          name: "Evidence",
+          status: "\u2705",
+          detail: `All ${completedTaskIds.length} completed tasks have evidence`
+        });
+      } else {
+        checks3.push({
+          name: "Evidence",
+          status: "\u274C",
+          detail: `${missingEvidence.length} completed task(s) missing evidence: ${missingEvidence.join(", ")}`
+        });
+      }
+    } else {
+      checks3.push({
+        name: "Evidence",
+        status: "\u2705",
+        detail: "No completed tasks yet"
+      });
+    }
+  }
   const passCount = checks3.filter((c) => c.status === "\u2705").length;
   const totalCount = checks3.length;
   const allPassed = passCount === totalCount;
@@ -14599,14 +15320,98 @@ async function handleDiagnoseCommand(directory, _args) {
 `);
 }
 
+// src/commands/evidence.ts
+async function handleEvidenceCommand(directory, args) {
+  if (args.length === 0) {
+    const taskIds = await listEvidenceTaskIds(directory);
+    if (taskIds.length === 0) {
+      return "No evidence bundles found.";
+    }
+    const tableLines = [
+      "## Evidence Bundles",
+      "",
+      "| Task | Entries | Last Updated |",
+      "|------|---------|-------------|"
+    ];
+    for (const taskId2 of taskIds) {
+      const bundle2 = await loadEvidence(directory, taskId2);
+      if (bundle2) {
+        const entryCount = bundle2.entries.length;
+        const lastUpdated = bundle2.updated_at;
+        tableLines.push(`| ${taskId2} | ${entryCount} | ${lastUpdated} |`);
+      } else {
+        tableLines.push(`| ${taskId2} | ? | unknown |`);
+      }
+    }
+    return tableLines.join(`
+`);
+  }
+  const taskId = args[0];
+  const bundle = await loadEvidence(directory, taskId);
+  if (!bundle) {
+    return `No evidence found for task ${taskId}.`;
+  }
+  const lines = [
+    `## Evidence for Task ${taskId}`,
+    "",
+    `**Created**: ${bundle.created_at}`,
+    `**Updated**: ${bundle.updated_at}`,
+    `**Entries**: ${bundle.entries.length}`
+  ];
+  if (bundle.entries.length > 0) {
+    lines.push("");
+  }
+  for (let i = 0;i < bundle.entries.length; i++) {
+    const entry = bundle.entries[i];
+    lines.push(...formatEntry(i + 1, entry));
+  }
+  return lines.join(`
+`);
+}
+function formatEntry(index, entry) {
+  const lines = [];
+  const verdictEmoji = getVerdictEmoji(entry.verdict);
+  lines.push(`### Entry ${index}: ${entry.type} (${entry.verdict}) ${verdictEmoji}`);
+  lines.push(`- **Agent**: ${entry.agent}`);
+  lines.push(`- **Summary**: ${entry.summary}`);
+  lines.push(`- **Time**: ${entry.timestamp}`);
+  if (entry.type === "review") {
+    const reviewEntry = entry;
+    lines.push(`- **Risk Level**: ${reviewEntry.risk}`);
+    if (reviewEntry.issues && reviewEntry.issues.length > 0) {
+      lines.push(`- **Issues**: ${reviewEntry.issues.length}`);
+    }
+  } else if (entry.type === "test") {
+    const testEntry = entry;
+    lines.push(`- **Tests**: ${testEntry.tests_passed} passed, ${testEntry.tests_failed} failed`);
+  }
+  lines.push("");
+  return lines;
+}
+function getVerdictEmoji(verdict) {
+  switch (verdict) {
+    case "pass":
+    case "approved":
+      return "\u2705";
+    case "fail":
+    case "rejected":
+      return "\u274C";
+    case "info":
+      return "\u2139\uFE0F";
+    default:
+      return "";
+  }
+}
+
 // src/commands/export.ts
 async function handleExportCommand(directory, _args) {
+  const planStructured = await loadPlanJsonOnly(directory);
   const planContent = await readSwarmFileAsync(directory, "plan.md");
   const contextContent = await readSwarmFileAsync(directory, "context.md");
   const exportData = {
     version: "4.5.0",
     exported: new Date().toISOString(),
-    plan: planContent,
+    plan: planStructured || planContent,
     context: contextContent
   };
   const lines = [
@@ -14622,6 +15427,34 @@ async function handleExportCommand(directory, _args) {
 
 // src/commands/history.ts
 async function handleHistoryCommand(directory, _args) {
+  const plan = await loadPlanJsonOnly(directory);
+  if (plan) {
+    if (plan.phases.length === 0) {
+      return "No history available.";
+    }
+    const tableLines2 = [
+      "## Swarm History",
+      "",
+      "| Phase | Name | Status | Tasks |",
+      "|-------|------|--------|-------|"
+    ];
+    for (const phase of plan.phases) {
+      const statusMap = {
+        complete: "COMPLETE",
+        in_progress: "IN PROGRESS",
+        pending: "PENDING",
+        blocked: "BLOCKED"
+      };
+      const statusText = statusMap[phase.status] || "PENDING";
+      const statusIcon = phase.status === "complete" ? "\u2705" : phase.status === "in_progress" ? "\uD83D\uDD04" : phase.status === "blocked" ? "\uD83D\uDEAB" : "\u23F3";
+      const completed = phase.tasks.filter((t) => t.status === "completed").length;
+      const total = phase.tasks.length;
+      const tasks = total > 0 ? `${completed}/${total}` : "-";
+      tableLines2.push(`| ${phase.id} | ${phase.name} | ${statusIcon} ${statusText} | ${tasks} |`);
+    }
+    return tableLines2.join(`
+`);
+  }
   const planContent = await readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return "No history available.";
@@ -14673,6 +15506,46 @@ async function handleHistoryCommand(directory, _args) {
 
 // src/commands/plan.ts
 async function handlePlanCommand(directory, args) {
+  const plan = await loadPlanJsonOnly(directory);
+  if (plan) {
+    if (args.length === 0) {
+      return derivePlanMarkdown(plan);
+    }
+    const phaseNum2 = parseInt(args[0], 10);
+    if (Number.isNaN(phaseNum2)) {
+      return derivePlanMarkdown(plan);
+    }
+    const phase = plan.phases.find((p) => p.id === phaseNum2);
+    if (!phase) {
+      return `Phase ${phaseNum2} not found in plan.`;
+    }
+    const fullMarkdown = derivePlanMarkdown(plan);
+    const lines2 = fullMarkdown.split(`
+`);
+    const phaseLines2 = [];
+    let inTargetPhase2 = false;
+    for (const line of lines2) {
+      const phaseMatch = line.match(/^## Phase (\d+)/);
+      if (phaseMatch) {
+        const num = parseInt(phaseMatch[1], 10);
+        if (num === phaseNum2) {
+          inTargetPhase2 = true;
+          phaseLines2.push(line);
+          continue;
+        } else if (inTargetPhase2) {
+          break;
+        }
+      }
+      if (inTargetPhase2 && line.trim() === "---" && phaseLines2.length > 1) {
+        break;
+      }
+      if (inTargetPhase2) {
+        phaseLines2.push(line);
+      }
+    }
+    return phaseLines2.length > 0 ? phaseLines2.join(`
+`).trim() : `Phase ${phaseNum2} not found in plan.`;
+  }
   const planContent = await readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return "No active swarm plan found.";
@@ -14900,13 +15773,81 @@ function extractPatterns(contextContent, maxChars = 500) {
   }
   return `${trimmed.slice(0, maxChars)}...`;
 }
+function extractCurrentPhaseFromPlan(plan) {
+  const phase = plan.phases.find((p) => p.id === plan.current_phase);
+  if (!phase)
+    return null;
+  const statusMap = {
+    pending: "PENDING",
+    in_progress: "IN PROGRESS",
+    complete: "COMPLETE",
+    blocked: "BLOCKED"
+  };
+  const statusText = statusMap[phase.status] || "PENDING";
+  return `Phase ${phase.id}: ${phase.name} [${statusText}]`;
+}
+function extractCurrentTaskFromPlan(plan) {
+  const phase = plan.phases.find((p) => p.id === plan.current_phase);
+  if (!phase)
+    return null;
+  const inProgress = phase.tasks.find((t) => t.status === "in_progress");
+  if (inProgress) {
+    const deps = inProgress.depends.length > 0 ? ` (depends: ${inProgress.depends.join(", ")})` : "";
+    return `- [ ] ${inProgress.id}: ${inProgress.description} [${inProgress.size.toUpperCase()}]${deps} \u2190 CURRENT`;
+  }
+  const pending = phase.tasks.find((t) => t.status === "pending");
+  if (pending) {
+    const deps = pending.depends.length > 0 ? ` (depends: ${pending.depends.join(", ")})` : "";
+    return `- [ ] ${pending.id}: ${pending.description} [${pending.size.toUpperCase()}]${deps}`;
+  }
+  return null;
+}
+function extractIncompleteTasksFromPlan(plan, maxChars = 500) {
+  const phase = plan.phases.find((p) => p.id === plan.current_phase);
+  if (!phase)
+    return null;
+  const incomplete = phase.tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
+  if (incomplete.length === 0)
+    return null;
+  const lines = incomplete.map((t) => {
+    const deps = t.depends.length > 0 ? ` (depends: ${t.depends.join(", ")})` : "";
+    return `- [ ] ${t.id}: ${t.description} [${t.size.toUpperCase()}]${deps}`;
+  });
+  const text = lines.join(`
+`);
+  if (text.length <= maxChars)
+    return text;
+  return `${text.slice(0, maxChars)}...`;
+}
 
 // src/commands/status.ts
 async function handleStatusCommand(directory, agents) {
+  const plan = await loadPlan(directory);
+  if (plan && plan.migration_status !== "migration_failed") {
+    const currentPhase2 = extractCurrentPhaseFromPlan(plan) || "Unknown";
+    let completedTasks2 = 0;
+    let totalTasks2 = 0;
+    for (const phase of plan.phases) {
+      for (const task of phase.tasks) {
+        totalTasks2++;
+        if (task.status === "completed")
+          completedTasks2++;
+      }
+    }
+    const agentCount2 = Object.keys(agents).length;
+    const lines2 = [
+      "## Swarm Status",
+      "",
+      `**Current Phase**: ${currentPhase2}`,
+      `**Tasks**: ${completedTasks2}/${totalTasks2} complete`,
+      `**Agents**: ${agentCount2} registered`
+    ];
+    return lines2.join(`
+`);
+  }
   const planContent = await readSwarmFileAsync(directory, "plan.md");
-  if (!planContent) {
+  if (!planContent)
     return "No active swarm plan found.";
-  }
   const currentPhase = extractCurrentPhase(planContent) || "Unknown";
   const completedTasks = (planContent.match(/^- \[x\]/gm) || []).length;
   const incompleteTasks = (planContent.match(/^- \[ \]/gm) || []).length;
@@ -14932,6 +15873,8 @@ var HELP_TEXT = [
   "- `/swarm agents` \u2014 List registered agents",
   "- `/swarm history` \u2014 Show completed phases summary",
   "- `/swarm config` \u2014 Show current resolved configuration",
+  "- `/swarm evidence [taskId]` \u2014 Show evidence bundles",
+  "- `/swarm archive [--dry-run]` \u2014 Archive old evidence bundles",
   "- `/swarm diagnose` \u2014 Run health check on swarm state",
   "- `/swarm export` \u2014 Export plan and context as JSON",
   "- `/swarm reset --confirm` \u2014 Clear swarm state files"
@@ -14952,8 +15895,14 @@ function createSwarmCommandHandler(directory, agents) {
       case "plan":
         text = await handlePlanCommand(directory, args);
         break;
-      case "agents":
-        text = handleAgentsCommand(agents);
+      case "agents": {
+        const pluginConfig = loadPluginConfig(directory);
+        const guardrailsConfig = pluginConfig?.guardrails ? GuardrailsConfigSchema.parse(pluginConfig.guardrails) : undefined;
+        text = handleAgentsCommand(agents, guardrailsConfig);
+        break;
+      }
+      case "archive":
+        text = await handleArchiveCommand(directory, args);
         break;
       case "history":
         text = await handleHistoryCommand(directory, args);
@@ -14961,6 +15910,9 @@ function createSwarmCommandHandler(directory, agents) {
       case "config":
         text = await handleConfigCommand(directory, args);
         break;
+      case "evidence":
+        text = await handleEvidenceCommand(directory, args);
+        break;
       case "diagnose":
         text = await handleDiagnoseCommand(directory, args);
         break;
@@ -14986,8 +15938,34 @@ var swarmState = {
   toolAggregates: new Map,
   activeAgent: new Map,
   delegationChains: new Map,
-  pendingEvents: 0
+  pendingEvents: 0,
+  agentSessions: new Map
 };
+function startAgentSession(sessionId, agentName, staleDurationMs = 3600000) {
+  const now = Date.now();
+  const staleIds = [];
+  for (const [id, session] of swarmState.agentSessions) {
+    if (now - session.startTime > staleDurationMs) {
+      staleIds.push(id);
+    }
+  }
+  for (const id of staleIds) {
+    swarmState.agentSessions.delete(id);
+  }
+  const sessionState = {
+    agentName,
+    startTime: now,
+    toolCallCount: 0,
+    consecutiveErrors: 0,
+    recentToolCalls: [],
+    warningIssued: false,
+    hardLimitHit: false
+  };
+  swarmState.agentSessions.set(sessionId, sessionState);
+}
+function getAgentSession(sessionId) {
+  return swarmState.agentSessions.get(sessionId);
+}
 
 // src/hooks/agent-activity.ts
 function createAgentActivityHooks(config2, directory) {
@@ -15057,8 +16035,8 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path4 = `${directory}/.swarm/context.md`;
-    await Bun.write(path4, updated);
+    const path6 = `${directory}/.swarm/context.md`;
+    await Bun.write(path6, updated);
     swarmState.pendingEvents = Math.max(0, swarmState.pendingEvents - flushedCount);
   } catch (error49) {
     warn("Agent activity flush failed:", error49);
@@ -15107,13 +16085,29 @@ function createCompactionCustomizerHook(config2, directory) {
   }
   return {
     "experimental.session.compacting": safeHook(async (_input, output) => {
-      const planContent = await readSwarmFileAsync(directory, "plan.md");
       const contextContent = await readSwarmFileAsync(directory, "context.md");
-      if (planContent) {
-        const currentPhase = extractCurrentPhase(planContent);
+      const plan = await loadPlan(directory);
+      if (plan && plan.migration_status !== "migration_failed") {
+        const currentPhase = extractCurrentPhaseFromPlan(plan);
         if (currentPhase) {
           output.context.push(`[SWARM PLAN] ${currentPhase}`);
         }
+        const incompleteTasks = extractIncompleteTasksFromPlan(plan);
+        if (incompleteTasks) {
+          output.context.push(`[SWARM TASKS] ${incompleteTasks}`);
+        }
+      } else {
+        const planContent = await readSwarmFileAsync(directory, "plan.md");
+        if (planContent) {
+          const currentPhase = extractCurrentPhase(planContent);
+          if (currentPhase) {
+            output.context.push(`[SWARM PLAN] ${currentPhase}`);
+          }
+          const incompleteTasks = extractIncompleteTasks(planContent);
+          if (incompleteTasks) {
+            output.context.push(`[SWARM TASKS] ${incompleteTasks}`);
+          }
+        }
       }
       if (contextContent) {
         const decisionsSummary = extractDecisions(contextContent);
@@ -15121,12 +16115,6 @@ function createCompactionCustomizerHook(config2, directory) {
           output.context.push(`[SWARM DECISIONS] ${decisionsSummary}`);
         }
       }
-      if (planContent) {
-        const incompleteTasks = extractIncompleteTasks(planContent);
-        if (incompleteTasks) {
-          output.context.push(`[SWARM TASKS] ${incompleteTasks}`);
-        }
-      }
       if (contextContent) {
         const patterns = extractPatterns(contextContent);
         if (patterns) {
@@ -15221,6 +16209,140 @@ function createDelegationTrackerHook(config2) {
     }
   };
 }
+// src/hooks/guardrails.ts
+function createGuardrailsHooks(config2) {
+  if (config2.enabled === false) {
+    return {
+      toolBefore: async () => {},
+      toolAfter: async () => {},
+      messagesTransform: async () => {}
+    };
+  }
+  return {
+    toolBefore: async (input, output) => {
+      let session = getAgentSession(input.sessionID);
+      if (!session) {
+        startAgentSession(input.sessionID, "unknown");
+        session = getAgentSession(input.sessionID);
+        if (!session) {
+          warn(`Failed to create session for ${input.sessionID}`);
+          return;
+        }
+      }
+      const agentConfig = resolveGuardrailsConfig(config2, session.agentName);
+      if (session.hardLimitHit) {
+        throw new Error("\uD83D\uDED1 CIRCUIT BREAKER: Agent blocked. Hard limit was previously triggered. Stop making tool calls and return your progress summary.");
+      }
+      session.toolCallCount++;
+      const hash2 = hashArgs(output.args);
+      session.recentToolCalls.push({
+        tool: input.tool,
+        argsHash: hash2,
+        timestamp: Date.now()
+      });
+      if (session.recentToolCalls.length > 20) {
+        session.recentToolCalls.shift();
+      }
+      let repetitionCount = 0;
+      if (session.recentToolCalls.length > 0) {
+        const lastEntry = session.recentToolCalls[session.recentToolCalls.length - 1];
+        for (let i = session.recentToolCalls.length - 1;i >= 0; i--) {
+          const entry = session.recentToolCalls[i];
+          if (entry.tool === lastEntry.tool && entry.argsHash === lastEntry.argsHash) {
+            repetitionCount++;
+          } else {
+            break;
+          }
+        }
+      }
+      const elapsedMinutes = (Date.now() - session.startTime) / 60000;
+      if (session.toolCallCount >= agentConfig.max_tool_calls) {
+        session.hardLimitHit = true;
+        throw new Error(`\uD83D\uDED1 CIRCUIT BREAKER: Tool call limit reached (${session.toolCallCount}/${agentConfig.max_tool_calls}). Stop making tool calls and return your progress summary.`);
+      }
+      if (elapsedMinutes >= agentConfig.max_duration_minutes) {
+        session.hardLimitHit = true;
+        throw new Error(`\uD83D\uDED1 CIRCUIT BREAKER: Duration limit reached (${Math.floor(elapsedMinutes)} min). Stop making tool calls and return your progress summary.`);
+      }
+      if (repetitionCount >= agentConfig.max_repetitions) {
+        session.hardLimitHit = true;
+        throw new Error(`\uD83D\uDED1 CIRCUIT BREAKER: Repetition detected (same call ${repetitionCount} times). Stop making tool calls and return your progress summary.`);
+      }
+      if (session.consecutiveErrors >= agentConfig.max_consecutive_errors) {
+        session.hardLimitHit = true;
+        throw new Error(`\uD83D\uDED1 CIRCUIT BREAKER: Too many consecutive errors (${session.consecutiveErrors}). Stop making tool calls and return your progress summary.`);
+      }
+      if (!session.warningIssued) {
+        const toolWarning = session.toolCallCount >= agentConfig.max_tool_calls * agentConfig.warning_threshold;
+        const durationWarning = elapsedMinutes >= agentConfig.max_duration_minutes * agentConfig.warning_threshold;
+        const repetitionWarning = repetitionCount >= agentConfig.max_repetitions * agentConfig.warning_threshold;
+        const errorWarning = session.consecutiveErrors >= agentConfig.max_consecutive_errors * agentConfig.warning_threshold;
+        if (toolWarning || durationWarning || repetitionWarning || errorWarning) {
+          session.warningIssued = true;
+        }
+      }
+    },
+    toolAfter: async (input, output) => {
+      const session = getAgentSession(input.sessionID);
+      if (!session) {
+        return;
+      }
+      const hasError = output.output === null || output.output === undefined;
+      if (hasError) {
+        session.consecutiveErrors++;
+      } else {
+        session.consecutiveErrors = 0;
+      }
+    },
+    messagesTransform: async (_input, output) => {
+      const messages = output.messages;
+      if (!messages || messages.length === 0) {
+        return;
+      }
+      const lastMessage = messages[messages.length - 1];
+      let sessionId = lastMessage.info?.sessionID;
+      if (!sessionId) {
+        for (const [id, session2] of swarmState.agentSessions) {
+          if (session2.warningIssued || session2.hardLimitHit) {
+            sessionId = id;
+            break;
+          }
+        }
+      }
+      if (!sessionId) {
+        return;
+      }
+      const session = getAgentSession(sessionId);
+      if (!session || !session.warningIssued && !session.hardLimitHit) {
+        return;
+      }
+      const textPart = lastMessage.parts.find((part) => part.type === "text" && typeof part.text === "string");
+      if (!textPart) {
+        return;
+      }
+      if (session.hardLimitHit) {
+        textPart.text = `[\uD83D\uDED1 CIRCUIT BREAKER ACTIVE: You have exceeded your resource limits. Do NOT make any more tool calls. Immediately return a summary of your progress so far. Any further tool calls will be blocked.]
+
+` + textPart.text;
+      } else if (session.warningIssued) {
+        textPart.text = `[\u26A0\uFE0F GUARDRAIL WARNING: You are approaching resource limits. Please wrap up your current task efficiently. Avoid unnecessary tool calls and prepare to return your results soon.]
+
+` + textPart.text;
+      }
+    }
+  };
+}
+function hashArgs(args) {
+  try {
+    if (typeof args !== "object" || args === null) {
+      return 0;
+    }
+    const sortedKeys = Object.keys(args).sort();
+    return Number(Bun.hash(JSON.stringify(args, sortedKeys)));
+  } catch {
+    return 0;
+  }
+}
 // src/hooks/pipeline-tracker.ts
 var PHASE_REMINDER = `<swarm_reminder>
 \u26A0\uFE0F ARCHITECT WORKFLOW REMINDER:
@@ -15283,29 +16405,51 @@ function createSystemEnhancerHook(config2, directory) {
   return {
     "experimental.chat.system.transform": safeHook(async (_input, output) => {
       try {
-        const planContent = await readSwarmFileAsync(directory, "plan.md");
+        let tryInject = function(text) {
+          const tokens = estimateTokens(text);
+          if (injectedTokens + tokens > maxInjectionTokens) {
+            return;
+          }
+          output.system.push(text);
+          injectedTokens += tokens;
+        };
+        const maxInjectionTokens = config2.context_budget?.max_injection_tokens ?? Number.POSITIVE_INFINITY;
+        let injectedTokens = 0;
         const contextContent = await readSwarmFileAsync(directory, "context.md");
-        if (planContent) {
-          const currentPhase = extractCurrentPhase(planContent);
+        const plan = await loadPlan(directory);
+        if (plan && plan.migration_status !== "migration_failed") {
+          const currentPhase = extractCurrentPhaseFromPlan(plan);
           if (currentPhase) {
-            output.system.push(`[SWARM CONTEXT] Current phase: ${currentPhase}`);
+            tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase}`);
           }
-          const currentTask = extractCurrentTask(planContent);
+          const currentTask = extractCurrentTaskFromPlan(plan);
           if (currentTask) {
-            output.system.push(`[SWARM CONTEXT] Current task: ${currentTask}`);
+            tryInject(`[SWARM CONTEXT] Current task: ${currentTask}`);
+          }
+        } else {
+          const planContent = await readSwarmFileAsync(directory, "plan.md");
+          if (planContent) {
+            const currentPhase = extractCurrentPhase(planContent);
+            if (currentPhase) {
+              tryInject(`[SWARM CONTEXT] Current phase: ${currentPhase}`);
+            }
+            const currentTask = extractCurrentTask(planContent);
+            if (currentTask) {
+              tryInject(`[SWARM CONTEXT] Current task: ${currentTask}`);
+            }
           }
         }
         if (contextContent) {
           const decisions = extractDecisions(contextContent, 200);
           if (decisions) {
-            output.system.push(`[SWARM CONTEXT] Key decisions: ${decisions}`);
+            tryInject(`[SWARM CONTEXT] Key decisions: ${decisions}`);
           }
           if (config2.hooks?.agent_activity !== false && _input.sessionID) {
             const activeAgent = swarmState.activeAgent.get(_input.sessionID);
             if (activeAgent) {
               const agentContext = extractAgentContext(contextContent, activeAgent, config2.hooks?.agent_awareness_max_chars ?? 300);
               if (agentContext) {
-                output.system.push(`[SWARM AGENT CONTEXT] ${agentContext}`);
+                tryInject(`[SWARM AGENT CONTEXT] ${agentContext}`);
               }
             }
           }
@@ -16077,10 +17221,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path4) {
-  if (!path4)
+function getElementAtPath2(obj, path6) {
+  if (!path6)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16439,11 +17583,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path4, issues) {
+function prefixIssues2(path6, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -16611,7 +17755,7 @@ function treeifyError2(error49, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error50, path4 = []) => {
+  const processError = (error50, path6 = []) => {
     var _a2, _b;
     for (const issue3 of error50.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -16621,7 +17765,7 @@ function treeifyError2(error49, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path4, ...issue3.path];
+        const fullpath = [...path6, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -16653,8 +17797,8 @@ function treeifyError2(error49, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27850,7 +28994,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 });
 // src/tools/file-extractor.ts
 import * as fs3 from "fs";
-import * as path4 from "path";
+import * as path6 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -27928,12 +29072,12 @@ var extract_code_blocks = tool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path4.join(targetDir, filename);
-      const base = path4.basename(filepath, path4.extname(filepath));
-      const ext = path4.extname(filepath);
+      let filepath = path6.join(targetDir, filename);
+      const base = path6.basename(filepath, path6.extname(filepath));
+      const ext = path6.extname(filepath);
       let counter = 1;
       while (fs3.existsSync(filepath)) {
-        filepath = path4.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path6.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -27965,7 +29109,7 @@ Errors:
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var delay = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 async function fetchGitingest(args) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -28054,6 +29198,8 @@ var OpenCodeSwarm = async (ctx) => {
   const commandHandler = createSwarmCommandHandler(ctx.directory, Object.fromEntries(agentDefinitions.map((agent) => [agent.name, agent])));
   const activityHooks = createAgentActivityHooks(config3, ctx.directory);
   const delegationHandler = createDelegationTrackerHook(config3);
+  const guardrailsConfig = GuardrailsConfigSchema.parse(config3.guardrails ?? {});
+  const guardrailsHooks = createGuardrailsHooks(guardrailsConfig);
   log("Plugin initialized", {
     directory: ctx.directory,
     maxIterations: config3.max_iterations,
@@ -28066,7 +29212,8 @@ var OpenCodeSwarm = async (ctx) => {
       contextBudget: !!contextBudgetHandler,
       commands: true,
       agentActivity: config3.hooks?.agent_activity !== false,
-      delegationTracker: config3.hooks?.delegation_tracker === true
+      delegationTracker: config3.hooks?.delegation_tracker === true,
+      guardrails: guardrailsConfig.enabled
     }
   });
   return {
@@ -28097,13 +29244,17 @@ var OpenCodeSwarm = async (ctx) => {
     },
     "experimental.chat.messages.transform": composeHandlers(...[
       pipelineHook["experimental.chat.messages.transform"],
-      contextBudgetHandler
+      contextBudgetHandler,
+      guardrailsHooks.messagesTransform
     ].filter((fn) => Boolean(fn))),
     "experimental.chat.system.transform": systemEnhancerHook["experimental.chat.system.transform"],
     "experimental.session.compacting": compactionHook["experimental.session.compacting"],
     "command.execute.before": safeHook(commandHandler),
-    "tool.execute.before": safeHook(activityHooks.toolBefore),
-    "tool.execute.after": safeHook(activityHooks.toolAfter),
+    "tool.execute.before": async (input, output) => {
+      await guardrailsHooks.toolBefore(input, output);
+      await safeHook(activityHooks.toolBefore)(input, output);
+    },
+    "tool.execute.after": composeHandlers(activityHooks.toolAfter, guardrailsHooks.toolAfter),
     "chat.message": safeHook(delegationHandler)
   };
 };