opencode-swarm 4.5.0 → 5.0.0

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,38 @@ 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 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 || !base.profiles?.[agentName]) {
+    return base;
+  }
+  const profile = base.profiles[agentName];
+  return { ...base, ...profile };
+}
 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 +13646,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 +13744,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.
 
@@ -14388,12 +14558,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 +14571,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 +14677,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 +14707,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 +15263,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 +15310,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 +15417,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 +15496,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 +15763,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 +15863,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 +15885,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 +15900,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 +15928,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 +16025,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 +16075,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 +16105,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 +16199,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 +16395,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 +17211,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 +17573,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 +17745,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 +17755,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 +17787,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 +28984,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 +29062,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 +29099,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 +29188,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 +29202,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 +29234,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)
   };
 };