opencode-swarm 6.60.0 → 6.61.0

package/dist/index.js

@@ -297,7 +297,8 @@ var init_constants = __esm(() => {
       "imports",
       "retrieve_summary",
       "symbols",
-      "knowledge_recall"
+      "knowledge_recall",
+      "req_coverage"
     ],
     critic_drift_verifier: [
       "complexity_hotspots",
@@ -14990,7 +14991,8 @@ var init_schema = __esm(() => {
       ]),
       require_reviewer_test_engineer: exports_external.boolean().default(true)
     }).optional(),
-    profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional()
+    profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional(),
+    block_destructive_commands: exports_external.boolean().default(true)
   });
   WatchdogConfigSchema = exports_external.object({
     scope_guard: exports_external.boolean().default(true),
@@ -30654,7 +30656,7 @@ var init_dist = __esm(() => {
 
 // src/tools/create-tool.ts
 function classifyToolError(error93) {
-  const msg = (error93 instanceof Error ? error93.message : String(error93)).toLowerCase();
+  const msg = (error93 instanceof Error ? error93.message ?? "" : String(error93)).toLowerCase();
   if (msg.includes("not registered") || msg.includes("unknown tool"))
     return "not_registered";
   if (msg.includes("not whitelisted") || msg.includes("not allowed"))
@@ -34920,6 +34922,10 @@ async function discoverBuildCommands(workingDir, options) {
   const skipped = [...profileSkipped];
   for (const ecosystem of ECOSYSTEMS) {
     if (coveredEcosystems.has(ecosystem.ecosystem)) {
+      skipped.push({
+        ecosystem: ecosystem.ecosystem,
+        reason: `Covered by profile detection`
+      });
       continue;
     }
     if (!checkToolchain(ecosystem.toolchainCommands)) {
@@ -41322,7 +41328,7 @@ async function scanDocIndex(directory) {
         try {
           const fullPath = path46.join(directory, file3.path);
           const stat2 = fs34.statSync(fullPath);
-          if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
+          if (stat2.mtimeMs > file3.mtime) {
             cacheValid = false;
             break;
           }
@@ -41619,6 +41625,98 @@ var init_doc_scan = __esm(() => {
   });
 });
 
+// src/tools/knowledge-recall.ts
+var exports_knowledge_recall = {};
+__export(exports_knowledge_recall, {
+  knowledge_recall: () => knowledge_recall
+});
+var knowledge_recall;
+var init_knowledge_recall = __esm(() => {
+  init_dist();
+  init_knowledge_store();
+  init_create_tool();
+  knowledge_recall = createSwarmTool({
+    description: "Search the knowledge base for relevant past decisions, patterns, and lessons learned. Returns ranked results by semantic similarity.",
+    args: {
+      query: tool.schema.string().min(3).describe("Natural language search query"),
+      top_n: tool.schema.number().int().min(1).max(20).optional().describe("Maximum results to return (default: 5)"),
+      tier: tool.schema.enum(["all", "swarm", "hive"]).optional().describe("Knowledge tier to search (default: 'all')")
+    },
+    execute: async (args2, directory) => {
+      let queryInput;
+      let topNInput;
+      let tierInput;
+      try {
+        if (args2 && typeof args2 === "object") {
+          const obj = args2;
+          queryInput = obj.query;
+          topNInput = obj.top_n;
+          tierInput = obj.tier;
+        }
+      } catch {}
+      if (typeof queryInput !== "string" || queryInput.length < 3) {
+        return JSON.stringify({
+          results: [],
+          total: 0,
+          error: "query must be a string with at least 3 characters"
+        });
+      }
+      let topN = 5;
+      if (topNInput !== undefined) {
+        if (typeof topNInput === "number" && Number.isInteger(topNInput)) {
+          topN = Math.max(1, Math.min(20, topNInput));
+        }
+      }
+      let tier = "all";
+      if (tierInput !== undefined && typeof tierInput === "string") {
+        if (tierInput === "swarm" || tierInput === "hive") {
+          tier = tierInput;
+        }
+      }
+      const swarmPath = resolveSwarmKnowledgePath(directory);
+      const hivePath = resolveHiveKnowledgePath();
+      const [swarmEntries, hiveEntries] = await Promise.all([
+        readKnowledge(swarmPath),
+        readKnowledge(hivePath)
+      ]);
+      let entries = [];
+      if (tier === "all" || tier === "swarm") {
+        entries = entries.concat(swarmEntries);
+      }
+      if (tier === "all" || tier === "hive") {
+        entries = entries.concat(hiveEntries);
+      }
+      if (entries.length === 0) {
+        const result2 = { results: [], total: 0 };
+        return JSON.stringify(result2);
+      }
+      const normalizedQuery = normalize2(queryInput);
+      const queryBigrams = wordBigrams(normalizedQuery);
+      const scoredEntries = entries.map((entry) => {
+        const entryText = `${entry.lesson} ${entry.tags.join(" ")} ${entry.category}`;
+        const entryBigrams = wordBigrams(entryText);
+        const textScore = jaccardBigram(queryBigrams, entryBigrams);
+        const boost = entry.status === "established" ? 0.1 : entry.status === "promoted" ? 0.05 : 0;
+        const finalScore = textScore + boost;
+        return {
+          id: entry.id,
+          confidence: entry.confidence,
+          category: entry.category,
+          lesson: entry.lesson,
+          score: finalScore
+        };
+      });
+      scoredEntries.sort((a, b) => b.score - a.score);
+      const topResults = scoredEntries.slice(0, topN);
+      const result = {
+        results: topResults,
+        total: topResults.length
+      };
+      return JSON.stringify(result);
+    }
+  });
+});
+
 // src/environment/prompt-renderer.ts
 var exports_prompt_renderer = {};
 __export(exports_prompt_renderer, {
@@ -45263,7 +45361,7 @@ ${warnings.map((w) => `  - ${w}`).join(`
 `)}` : "";
   const cautionMessage = `
 
-\u26A0\uFE0F  Caution: Spec drift was acknowledged \u2014 verify that the implementation still matches the spec before proceeding.`;
+\u26A0\uFE0F  Warning: Spec drift was acknowledged \u2014 verify that the implementation still matches the spec before proceeding.`;
   return baseMessage + warningMessage + cautionMessage;
 }
 
@@ -48051,42 +48149,73 @@ init_utils2();
 var DEFAULT_CURATOR_LLM_TIMEOUT_MS = 300000;
 function parseKnowledgeRecommendations(llmOutput) {
   const recommendations = [];
-  const section = llmOutput.match(/OBSERVATIONS:\s*\n([\s\S]*?)(?:\n\n|\n[A-Z_]+:|$)/);
-  if (!section)
-    return recommendations;
-  const lines = section[1].split(`
+  const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  const obsSection = llmOutput.match(/OBSERVATIONS:\s*\n([\s\S]*?)(?:\n\n|\n[A-Z_]+:|$)/);
+  if (obsSection) {
+    const lines = obsSection[1].split(`
 `);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("-"))
-      continue;
-    const match = trimmed.match(/^-\s+entry\s+(\S+)\s+\(([^)]+)\):\s+(.+)$/i);
-    if (!match)
-      continue;
-    const uuid8 = match[1];
-    const parenthetical = match[2];
-    const text = match[3].trim().replace(/\s+\([^)]+\)$/, "");
-    const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    const entryId = uuid8 === "new" || !UUID_V4.test(uuid8) ? undefined : uuid8;
-    let action = "rewrite";
-    const lowerParenthetical = parenthetical.toLowerCase();
-    if (lowerParenthetical.includes("suggests boost confidence") || lowerParenthetical.includes("mark hive_eligible") || lowerParenthetical.includes("appears high-confidence")) {
-      action = "promote";
-    } else if (lowerParenthetical.includes("suggests archive") || lowerParenthetical.includes("appears stale")) {
-      action = "archive";
-    } else if (lowerParenthetical.includes("contradicts project state")) {
-      action = "flag_contradiction";
-    } else if (lowerParenthetical.includes("suggests rewrite") || lowerParenthetical.includes("could be tighter")) {
-      action = "rewrite";
-    } else if (lowerParenthetical.includes("new candidate")) {
-      action = "promote";
-    }
-    recommendations.push({
-      action,
-      entry_id: entryId,
-      lesson: text,
-      reason: text
-    });
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("-"))
+        continue;
+      const match = trimmed.match(/^-\s+entry\s+(\S+)\s+\(([^)]+)\):\s+(.+)$/i);
+      if (!match)
+        continue;
+      const uuid8 = match[1];
+      const parenthetical = match[2];
+      const text = match[3].trim().replace(/\s+\([^)]+\)$/, "");
+      const entryId = uuid8 === "new" || !UUID_V4.test(uuid8) ? undefined : uuid8;
+      let action = "rewrite";
+      const lowerParenthetical = parenthetical.toLowerCase();
+      if (lowerParenthetical.includes("suggests boost confidence") || lowerParenthetical.includes("mark hive_eligible") || lowerParenthetical.includes("appears high-confidence")) {
+        action = "promote";
+      } else if (lowerParenthetical.includes("suggests archive") || lowerParenthetical.includes("appears stale")) {
+        action = "archive";
+      } else if (lowerParenthetical.includes("contradicts project state")) {
+        action = "flag_contradiction";
+      } else if (lowerParenthetical.includes("suggests rewrite") || lowerParenthetical.includes("could be tighter")) {
+        action = "rewrite";
+      } else if (lowerParenthetical.includes("new candidate")) {
+        action = "promote";
+      }
+      recommendations.push({
+        action,
+        entry_id: entryId,
+        lesson: text,
+        reason: text
+      });
+    }
+  }
+  const updatesSection = llmOutput.match(/KNOWLEDGE_UPDATES:\s*\n([\s\S]*?)(?:\n\n|\n[A-Z_]+:|$)/);
+  if (updatesSection) {
+    const validActions = new Set([
+      "promote",
+      "archive",
+      "rewrite",
+      "flag_contradiction"
+    ]);
+    const lines = updatesSection[1].split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("-"))
+        continue;
+      const match = trimmed.match(/^-\s+(\S+)\s+(\S+):\s+(.+)$/);
+      if (!match)
+        continue;
+      const action = match[1].toLowerCase();
+      if (!validActions.has(action))
+        continue;
+      const id = match[2];
+      const text = match[3].trim();
+      const entryId = UUID_V4.test(id) ? id : undefined;
+      recommendations.push({
+        action,
+        entry_id: entryId,
+        lesson: text,
+        reason: text
+      });
+    }
   }
   return recommendations;
 }
@@ -52920,7 +53049,8 @@ Run \`/swarm evidence ${result.task_id ?? "unknown"}\` to view it, or \`/swarm s
 var COMMAND_REGISTRY = {
   "acknowledge-spec-drift": {
     handler: (ctx) => handleAcknowledgeSpecDriftCommand(ctx.directory, ctx.args),
-    description: "Acknowledge that the spec has drifted from the plan and suppress further warnings"
+    description: "Acknowledge that the spec has drifted from the plan and suppress further warnings",
+    args: ""
   },
   status: {
     handler: (ctx) => handleStatusCommand(ctx.directory, ctx.agents),
@@ -52966,112 +53096,156 @@ var COMMAND_REGISTRY = {
   },
   "sync-plan": {
     handler: (ctx) => handleSyncPlanCommand(ctx.directory, ctx.args),
-    description: "Ensure plan.json and plan.md are synced"
+    description: "Ensure plan.json and plan.md are synced",
+    args: ""
   },
   benchmark: {
     handler: (ctx) => handleBenchmarkCommand(ctx.directory, ctx.args),
-    description: "Show performance metrics [--cumulative] [--ci-gate]"
+    description: "Show performance metrics [--cumulative] [--ci-gate]",
+    args: "--cumulative, --ci-gate"
   },
   export: {
     handler: (ctx) => handleExportCommand(ctx.directory, ctx.args),
-    description: "Export plan and context as JSON"
+    description: "Export plan and context as JSON",
+    args: "",
+    details: "Exports the current plan and context as JSON to stdout. Useful for piping to external tools or debugging swarm state."
   },
   evidence: {
     handler: (ctx) => handleEvidenceCommand(ctx.directory, ctx.args),
-    description: "Show evidence bundles [taskId]"
+    description: "Show evidence bundles [taskId]",
+    args: "<taskId>",
+    details: 'Displays review results, test verdicts, and other evidence bundles for the given task ID (e.g., "2.1").'
   },
   "evidence summary": {
     handler: (ctx) => handleEvidenceSummaryCommand(ctx.directory),
     description: "Generate evidence summary with completion ratio and blockers",
-    subcommandOf: "evidence"
+    subcommandOf: "evidence",
+    args: "",
+    details: "Generates a summary showing completion ratio across all tasks, lists blockers, and identifies missing evidence."
   },
   "evidence-summary": {
     handler: (ctx) => handleEvidenceSummaryCommand(ctx.directory),
     description: "Generate evidence summary with completion ratio and blockers",
-    subcommandOf: "evidence"
+    subcommandOf: "evidence",
+    args: "",
+    details: "Generates a summary showing completion ratio across all tasks, lists blockers, and identifies missing evidence."
   },
   archive: {
     handler: (ctx) => handleArchiveCommand(ctx.directory, ctx.args),
-    description: "Archive old evidence bundles [--dry-run]"
+    description: "Archive old evidence bundles [--dry-run]",
+    details: "Archives evidence bundles older than max_age_days (config, default 90) or beyond max_bundles cap (config, default 1000). --dry-run previews which bundles would be archived without deleting them. Applies two-tier retention: age-based first, then count-based on oldest remaining.",
+    args: "--dry-run"
   },
   curate: {
     handler: (ctx) => handleCurateCommand(ctx.directory, ctx.args),
-    description: "Run knowledge curation and hive promotion review"
+    description: "Run knowledge curation and hive promotion review",
+    args: ""
   },
   "dark-matter": {
     handler: (ctx) => handleDarkMatterCommand(ctx.directory, ctx.args),
-    description: "Detect hidden file couplings via co-change NPMI analysis"
+    description: "Detect hidden file couplings via co-change NPMI analysis",
+    args: "--threshold <number>, --min-commits <number>"
   },
   close: {
     handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args),
-    description: "Use /swarm close to close the swarm project and archive evidence"
+    description: "Use /swarm close to close the swarm project and archive evidence",
+    details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs safe git ff-only to main. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation.",
+    args: "--prune-branches"
   },
   simulate: {
     handler: (ctx) => handleSimulateCommand(ctx.directory, ctx.args),
-    description: "Dry-run impact analysis of proposed changes [--target <glob>]"
+    description: "Dry-run hidden coupling analysis with configurable thresholds",
+    args: "--threshold <number>, --min-commits <number>"
   },
   analyze: {
     handler: (ctx) => handleAnalyzeCommand(ctx.directory, ctx.args),
-    description: "Analyze spec.md vs plan.md for requirement coverage gaps"
+    description: "Analyze spec.md vs plan.md for requirement coverage gaps",
+    args: ""
   },
   clarify: {
     handler: (ctx) => handleClarifyCommand(ctx.directory, ctx.args),
-    description: "Clarify and refine an existing feature specification"
+    description: "Clarify and refine an existing feature specification",
+    args: "[description-text]"
   },
   specify: {
     handler: (ctx) => handleSpecifyCommand(ctx.directory, ctx.args),
-    description: "Generate or import a feature specification [description]"
+    description: "Generate or import a feature specification [description]",
+    args: "[description-text]"
   },
   promote: {
     handler: (ctx) => handlePromoteCommand(ctx.directory, ctx.args),
-    description: "Manually promote lesson to hive knowledge"
+    description: "Manually promote lesson to hive knowledge",
+    details: "Promotes a lesson directly to hive knowledge (--category flag sets category) or references an existing swarm lesson by ID (--from-swarm). Validates lesson text before promotion. Either direct text or --from-swarm ID is required.",
+    args: "--category <category>, --from-swarm <lesson-id>, <lesson-text>"
   },
   reset: {
     handler: (ctx) => handleResetCommand(ctx.directory, ctx.args),
-    description: "Clear swarm state files [--confirm]"
+    description: "Clear swarm state files [--confirm]",
+    details: "DELETES plan.md, context.md, and summaries/ directory from .swarm/. Stops background automation and clears in-memory queues. SAFETY: requires --confirm flag \u2014 without it, displays a warning and tips to export first.",
+    args: "--confirm (required)"
   },
   "reset-session": {
     handler: (ctx) => handleResetSessionCommand(ctx.directory, ctx.args),
-    description: "Clear session state while preserving plan, evidence, and knowledge"
+    description: "Clear session state while preserving plan, evidence, and knowledge",
+    details: "Deletes only .swarm/session/state.json and any other session files. Clears in-memory agent sessions and delegation chains. Preserves plan, evidence, and knowledge for cross-session continuity.",
+    args: ""
   },
   rollback: {
     handler: (ctx) => handleRollbackCommand(ctx.directory, ctx.args),
-    description: "Restore swarm state to a checkpoint <phase>"
+    description: "Restore swarm state to a checkpoint <phase>",
+    details: "Restores .swarm/ state by directly overwriting files from a checkpoint directory (checkpoints/phase-<N>). Writes rollback event to events.jsonl. Without phase argument, lists available checkpoints. Partial failures are reported but processing continues.",
+    args: "<phase-number>"
   },
   retrieve: {
     handler: (ctx) => handleRetrieveCommand(ctx.directory, ctx.args),
-    description: "Retrieve full output from a summary <id>"
+    description: "Retrieve full output from a summary <id>",
+    args: "<summary-id>",
+    details: "Loads the full tool output that was previously summarized (referenced by IDs like S1, S2). Use when you need the complete output instead of the truncated summary."
   },
   handoff: {
     handler: (ctx) => handleHandoffCommand(ctx.directory, ctx.args),
-    description: "Prepare state for clean model switch (new session)"
+    description: "Prepare state for clean model switch (new session)",
+    args: "",
+    details: "Generates handoff.md with full session state snapshot, including plan progress, recent decisions, and agent delegation history. Prepended to the next session prompt for seamless model switches."
   },
   turbo: {
     handler: (ctx) => handleTurboCommand(ctx.directory, ctx.args, ctx.sessionID),
-    description: "Toggle Turbo Mode for the active session [on|off]"
+    description: "Toggle Turbo Mode for the active session [on|off]",
+    args: "on, off",
+    details: 'Toggles Turbo Mode which skips non-critical QA gates for faster iteration. When enabled, the architect can proceed without waiting for all automated checks. Session-scoped \u2014 resets on new session. Use "on" or "off" to set explicitly, or toggle with no argument.'
   },
   "full-auto": {
     handler: (ctx) => handleFullAutoCommand(ctx.directory, ctx.args, ctx.sessionID),
-    description: "Toggle Full-Auto Mode for the active session [on|off]"
+    description: "Toggle Full-Auto Mode for the active session [on|off]",
+    args: "on, off",
+    details: 'Toggles Full-Auto Mode which enables autonomous execution without confirmation prompts. When enabled, the architect proceeds through implementation steps automatically. Session-scoped \u2014 resets on new session. Use "on" or "off" to set explicitly, or toggle with no argument.'
   },
   "write-retro": {
     handler: (ctx) => handleWriteRetroCommand(ctx.directory, ctx.args),
-    description: "Write a retrospective evidence bundle for a completed phase <json>"
+    description: "Write a retrospective evidence bundle for a completed phase <json>",
+    details: "Writes retrospective evidence bundle to .swarm/evidence/retro-{phase}/evidence.json. Required JSON: phase, summary, task_count, task_complexity, total_tool_calls, coder_revisions, reviewer_rejections, test_failures, security_findings, integration_issues. Optional: lessons_learned (max 5), top_rejection_reasons, task_id, metadata.",
+    args: "<json: {phase, summary, task_count, task_complexity, ...}>"
   },
   "knowledge migrate": {
     handler: (ctx) => handleKnowledgeMigrateCommand(ctx.directory, ctx.args),
     description: "Migrate knowledge entries to the current format",
-    subcommandOf: "knowledge"
+    subcommandOf: "knowledge",
+    details: "One-time migration from .swarm/context.md SME cache to .swarm/knowledge.jsonl. Skips if sentinel file .swarm/.knowledge-migrated exists, if context.md is absent, or if context.md is empty. Reports entries migrated, dropped (validation/dedup), and total processed.",
+    args: "<directory>"
   },
   "knowledge quarantine": {
     handler: (ctx) => handleKnowledgeQuarantineCommand(ctx.directory, ctx.args),
     description: "Move a knowledge entry to quarantine <id> [reason]",
-    subcommandOf: "knowledge"
+    subcommandOf: "knowledge",
+    details: 'Moves a knowledge entry to quarantine with optional reason string (defaults to "Quarantined via /swarm knowledge quarantine command"). Validates entry ID format (1-64 alphanumeric/hyphen/underscore). Quarantined entries are excluded from knowledge queries.',
+    args: "<entry-id> [reason]"
   },
   "knowledge restore": {
     handler: (ctx) => handleKnowledgeRestoreCommand(ctx.directory, ctx.args),
     description: "Restore a quarantined knowledge entry <id>",
-    subcommandOf: "knowledge"
+    subcommandOf: "knowledge",
+    details: "Restores a quarantined knowledge entry back to the active knowledge store by ID. Validates entry ID format (1-64 alphanumeric/hyphen/underscore). Entry must currently be in quarantine state.",
+    args: "<entry-id>"
   },
   knowledge: {
     handler: (ctx) => handleKnowledgeListCommand(ctx.directory, ctx.args),
@@ -53079,7 +53253,9 @@ var COMMAND_REGISTRY = {
   },
   checkpoint: {
     handler: (ctx) => handleCheckpointCommand(ctx.directory, ctx.args),
-    description: "Manage project checkpoints [save|restore|delete|list] <label>"
+    description: "Manage project checkpoints [save|restore|delete|list] <label>",
+    details: "save: creates named snapshot of current .swarm/ state. restore: soft-resets to checkpoint by overwriting current .swarm/ files. delete: removes named checkpoint. list: shows all checkpoints with timestamps. All subcommands require a label except list.",
+    args: "<save|restore|delete|list> <label>"
   }
 };
 var VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
@@ -53429,8 +53605,8 @@ SECURITY_KEYWORDS: password, secret, token, credential, auth, login, encryption,
 {{AGENT_PREFIX}}designer - UI/UX design specs (scaffold generation for UI components \u2014 runs BEFORE coder on UI tasks)
 
 ## SLASH COMMANDS
-Available commands via /swarm: {{SLASH_COMMANDS}}
-Type /swarm (no arguments) for full help.
+{{SLASH_COMMANDS}}
+Commands above are documented with args and behavioral details. Run commands via /swarm <command> [args].
 Outside OpenCode, invoke any plugin command via: \`bunx opencode-swarm run <command> [args]\` (e.g. \`bunx opencode-swarm run knowledge migrate\`). Do not use \`bun -e\` or look for \`src/commands/\` \u2014 those paths are internal to the plugin source and do not exist in user project directories.
 
 SMEs advise only. Reviewer and critic review only. None of them write code.
@@ -54158,7 +54334,131 @@ function buildAvailableToolsList() {
   }).join(", ");
 }
 function buildSlashCommandsList() {
-  return Object.keys(COMMAND_REGISTRY).sort().join(", ") + ".";
+  const SKIP_ALIASES = new Set(["config-doctor", "evidence-summary"]);
+  const READ_ONLY_OBSERVATION = new Set([
+    "status",
+    "history",
+    "agents",
+    "config",
+    "plan",
+    "benchmark",
+    "export",
+    "retrieve"
+  ]);
+  const CATEGORY_ORDER = [
+    "Session Lifecycle",
+    "Planning",
+    "Execution Modes",
+    "Observation",
+    "Knowledge",
+    "State Management",
+    "Diagnostics"
+  ];
+  const COMMANDS_BY_CATEGORY = {
+    "Session Lifecycle": [
+      "close",
+      "reset",
+      "reset-session",
+      "handoff",
+      "archive"
+    ],
+    Planning: [
+      "specify",
+      "clarify",
+      "analyze",
+      "plan",
+      "sync-plan",
+      "acknowledge-spec-drift"
+    ],
+    "Execution Modes": ["turbo", "full-auto"],
+    Observation: [
+      "status",
+      "history",
+      "agents",
+      "config",
+      "benchmark",
+      "export",
+      "evidence",
+      "evidence summary",
+      "retrieve"
+    ],
+    Knowledge: [
+      "knowledge",
+      "knowledge migrate",
+      "knowledge quarantine",
+      "knowledge restore",
+      "promote",
+      "curate"
+    ],
+    "State Management": ["checkpoint", "rollback", "write-retro"],
+    Diagnostics: [
+      "diagnose",
+      "preflight",
+      "doctor tools",
+      "config doctor",
+      "simulate",
+      "dark-matter"
+    ]
+  };
+  const lines = [];
+  const subcommandMap = {};
+  for (const [cmdName, cmdEntry] of Object.entries(COMMAND_REGISTRY)) {
+    const entry = cmdEntry;
+    if (entry.subcommandOf) {
+      if (!subcommandMap[entry.subcommandOf]) {
+        subcommandMap[entry.subcommandOf] = [];
+      }
+      subcommandMap[entry.subcommandOf].push(cmdName);
+    }
+  }
+  const compoundsInValidCommands = new Set;
+  for (const category of CATEGORY_ORDER) {
+    lines.push(`**${category}**`);
+    const commandNames = COMMANDS_BY_CATEGORY[category];
+    for (const name2 of commandNames) {
+      const entry = COMMAND_REGISTRY[name2];
+      if (!entry)
+        continue;
+      if (SKIP_ALIASES.has(name2))
+        continue;
+      if (entry.subcommandOf && !VALID_COMMANDS.includes(name2))
+        continue;
+      lines.push(`- \`/swarm ${name2}\` \u2014 ${entry.description}`);
+      if (entry.subcommandOf && VALID_COMMANDS.includes(name2)) {
+        compoundsInValidCommands.add(name2);
+      }
+      if (READ_ONLY_OBSERVATION.has(name2))
+        continue;
+      if (entry.details) {
+        lines.push(`  ${entry.details}`);
+      }
+      if (entry.args) {
+        lines.push(`  Args: ${entry.args}`);
+      }
+    }
+    for (const parent of commandNames) {
+      const subs = subcommandMap[parent];
+      if (!subs)
+        continue;
+      for (const subName of subs) {
+        const subEntry = COMMAND_REGISTRY[subName];
+        if (!subEntry)
+          continue;
+        if (compoundsInValidCommands.has(subName) || subEntry.subcommandOf && VALID_COMMANDS.includes(subName) || SKIP_ALIASES.has(subName)) {
+          continue;
+        }
+        lines.push(`  - \`/swarm ${subName}\` \u2014 ${subEntry.description}`);
+        if (subEntry.details) {
+          lines.push(`    ${subEntry.details}`);
+        }
+        if (subEntry.args) {
+          lines.push(`    Args: ${subEntry.args}`);
+        }
+      }
+    }
+  }
+  return lines.join(`
+`);
 }
 function createArchitectAgent(model, customPrompt, customAppendPrompt, adversarialTesting) {
   let prompt = ARCHITECT_PROMPT;
@@ -56198,7 +56498,7 @@ class PlanSyncWorker {
       const planJsonPath = path36.join(swarmDir, "plan.json");
       const markerPath = path36.join(swarmDir, ".plan-write-marker");
       const planStats = fs24.statSync(planJsonPath);
-      const planMtimeMs = planStats.mtimeMs;
+      const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs24.readFileSync(markerPath, "utf8");
       const marker = JSON.parse(markerContent);
       const markerTimestampMs = new Date(marker.timestamp).getTime();
@@ -56229,12 +56529,54 @@ init_status_artifact();
 init_trigger();
 
 // src/commands/index.ts
-var HELP_TEXT = [
-  "## Swarm Commands",
-  "",
-  ...VALID_COMMANDS.filter((cmd) => !cmd.includes(" ")).map((cmd) => `- \`/swarm ${cmd}\` \u2014 ${COMMAND_REGISTRY[cmd].description}`)
-].join(`
+function buildHelpText() {
+  const lines = ["## Swarm Commands", ""];
+  const shownAsSubcommand = new Set;
+  for (const cmd of VALID_COMMANDS) {
+    if (cmd.includes(" ")) {
+      const parent = cmd.split(" ")[0];
+      if (VALID_COMMANDS.includes(parent)) {
+        shownAsSubcommand.add(cmd);
+      }
+      continue;
+    }
+    const entry = COMMAND_REGISTRY[cmd];
+    lines.push(`- \`/swarm ${cmd}\` \u2014 ${entry.description}`);
+    if (entry.args) {
+      lines.push(`  Args: \`${entry.args}\``);
+    }
+    if (entry.details) {
+      lines.push(`  ${entry.details}`);
+    }
+    const subcommands = VALID_COMMANDS.filter((sub) => sub.startsWith(`${cmd} `) && sub !== cmd);
+    for (const sub of subcommands) {
+      const subEntry = COMMAND_REGISTRY[sub];
+      const subName = sub.slice(cmd.length + 1);
+      lines.push(`  - \`${subName}\` \u2014 ${subEntry.description}`);
+      if (subEntry.args) {
+        lines.push(`    Args: \`${subEntry.args}\``);
+      }
+      if (subEntry.details) {
+        lines.push(`    ${subEntry.details}`);
+      }
+    }
+  }
+  for (const cmd of VALID_COMMANDS) {
+    if (!cmd.includes(" ") || shownAsSubcommand.has(cmd))
+      continue;
+    const entry = COMMAND_REGISTRY[cmd];
+    lines.push(`- \`/swarm ${cmd}\` \u2014 ${entry.description}`);
+    if (entry.args) {
+      lines.push(`  Args: \`${entry.args}\``);
+    }
+    if (entry.details) {
+      lines.push(`  ${entry.details}`);
+    }
+  }
+  return lines.join(`
 `);
+}
+var HELP_TEXT = buildHelpText();
 function createSwarmCommandHandler(directory, agents) {
   return async (input, output) => {
     if (input.command !== "swarm" && !input.command.startsWith("swarm-")) {
@@ -57676,6 +58018,54 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3, authorityC
     "pre_check_batch"
   ];
   const requireReviewerAndTestEngineer = cfg.qa_gates?.require_reviewer_test_engineer ?? true;
+  function checkDestructiveCommand(tool3, args2) {
+    if (tool3 !== "bash" && tool3 !== "shell")
+      return;
+    if (cfg.block_destructive_commands === false)
+      return;
+    const toolArgs = args2;
+    const command = typeof toolArgs?.command === "string" ? toolArgs.command.trim() : "";
+    if (!command)
+      return;
+    if (/:\s*\(\s*\)\s*\{[^}]*\|[^}]*:/.test(command)) {
+      throw new Error(`BLOCKED: Potentially destructive shell command detected: fork bomb pattern`);
+    }
+    const rmFlagPattern = /^rm\s+(-r\s+-f|-f\s+-r|-rf|-fr)\s+(.+)$/;
+    const rmMatch = rmFlagPattern.exec(command);
+    if (rmMatch) {
+      const targetPart = rmMatch[2].trim();
+      const targets = targetPart.split(/\s+/);
+      const safeTargets = /^(node_modules|\.git)$/;
+      const allSafe = targets.every((t) => safeTargets.test(t));
+      if (!allSafe) {
+        throw new Error(`BLOCKED: Potentially destructive shell command: rm -rf on unsafe path(s): ${targetPart}`);
+      }
+    }
+    if (/^git\s+push\b.*?(--force|-f)\b/.test(command)) {
+      throw new Error(`BLOCKED: Force push detected \u2014 git push --force is not allowed`);
+    }
+    if (/^git\s+reset\s+--hard/.test(command)) {
+      throw new Error(`BLOCKED: "git reset --hard" detected \u2014 use --soft or --mixed with caution`);
+    }
+    if (/^git\s+reset\s+--mixed\s+\S+/.test(command)) {
+      throw new Error(`BLOCKED: "git reset --mixed" with a target branch/commit is not allowed`);
+    }
+    if (/^kubectl\s+delete\b/.test(command)) {
+      throw new Error(`BLOCKED: "kubectl delete" detected \u2014 destructive cluster operation`);
+    }
+    if (/^docker\s+system\s+prune\b/.test(command)) {
+      throw new Error(`BLOCKED: "docker system prune" detected \u2014 destructive container operation`);
+    }
+    if (/^\s*DROP\s+(TABLE|DATABASE|SCHEMA)\b/i.test(command)) {
+      throw new Error(`BLOCKED: SQL DROP command detected \u2014 destructive database operation`);
+    }
+    if (/^\s*TRUNCATE\s+TABLE\b/i.test(command)) {
+      throw new Error(`BLOCKED: SQL TRUNCATE command detected \u2014 destructive database operation`);
+    }
+    if (/^mkfs[./]/.test(command)) {
+      throw new Error(`BLOCKED: Disk format command (mkfs) detected \u2014 disk formatting operation`);
+    }
+  }
   async function checkGateLimits(params) {
     const { sessionID, window: window2, agentConfig, elapsedMinutes, repetitionCount } = params;
     if (agentConfig.max_tool_calls > 0 && window2.toolCalls >= agentConfig.max_tool_calls) {
@@ -58025,6 +58415,7 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3, authorityC
       handleDelegatedWriteTracking(input.sessionID, input.tool, output.args);
       handleLoopDetection(input.sessionID, input.tool, output.args);
       handleTestSuiteBlocking(input.tool, output.args);
+      checkDestructiveCommand(input.tool, output.args);
       if (isArchitect(input.sessionID) && isWriteTool(input.tool)) {
         handlePlanAndScopeProtection(input.sessionID, input.tool, output.args);
         const toolArgs = output.args;
@@ -58205,18 +58596,18 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3, authorityC
             const fallbackModels = swarmAgents?.[baseAgentName]?.fallback_models;
             session.modelFallbackExhausted = !fallbackModels || session.model_fallback_index > fallbackModels.length;
             const fallbackModel = resolveFallbackModel(baseAgentName, session.model_fallback_index, swarmAgents);
+            const primaryModel = swarmAgents?.[baseAgentName]?.model ?? "default";
             if (fallbackModel) {
-              const primaryModel = swarmAgents?.[baseAgentName]?.model ?? "default";
               if (swarmAgents?.[baseAgentName]) {
                 swarmAgents[baseAgentName].model = fallbackModel;
               }
-              telemetry.modelFallback(input.sessionID, session.agentName, primaryModel, fallbackModel, "transient_model_error");
               session.pendingAdvisoryMessages ??= [];
               session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Applied fallback model "${fallbackModel}" (attempt ${session.model_fallback_index}). ` + `Using /swarm handoff to reset to primary model.`);
             } else {
               session.pendingAdvisoryMessages ??= [];
               session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Transient model error detected (attempt ${session.model_fallback_index}). ` + `No fallback models configured for this agent. Add "fallback_models": ["model-a", "model-b"] ` + `to the agent's config in opencode-swarm.json.`);
             }
+            telemetry.modelFallback(input.sessionID, session.agentName, primaryModel, fallbackModel ?? "none", "transient_model_error");
             swarmState.pendingEvents++;
           }
         }
@@ -58589,17 +58980,22 @@ function normalizePathWithCache(filePath, cwd) {
     return fallback;
   }
 }
-function getGlobMatcher(pattern) {
+function getGlobMatcher(pattern, caseInsensitive = process.platform === "win32" || process.platform === "darwin") {
   const cached3 = globMatcherCache.get(pattern);
   if (cached3 !== undefined) {
     return cached3;
   }
-  const matcher = import_picomatch.default(pattern, {
-    dot: true,
-    nocase: process.platform === "win32"
-  });
-  globMatcherCache.set(pattern, matcher);
-  return matcher;
+  try {
+    const matcher = import_picomatch.default(pattern, {
+      dot: true,
+      nocase: caseInsensitive
+    });
+    globMatcherCache.set(pattern, matcher);
+    return matcher;
+  } catch (err2) {
+    warn(`picomatch error for pattern "${pattern}": ${err2}`);
+    return () => false;
+  }
 }
 var DEFAULT_AGENT_AUTHORITY_RULES = {
   architect: {
@@ -58677,7 +59073,7 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules) {
   const dir = cwd || process.cwd();
   let normalizedPath;
   try {
-    const normalizedWithSymlinks = normalizePathWithCache(filePath, cwd);
+    const normalizedWithSymlinks = normalizePathWithCache(filePath, dir);
     const resolved = path38.resolve(dir, normalizedWithSymlinks);
     normalizedPath = path38.relative(dir, resolved).replace(/\\/g, "/");
   } catch {
@@ -58730,6 +59126,16 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules) {
       return { allowed: true };
     }
   }
+  if (rules.blockedPrefix && rules.blockedPrefix.length > 0) {
+    for (const prefix of rules.blockedPrefix) {
+      if (normalizedPath.startsWith(prefix)) {
+        return {
+          allowed: false,
+          reason: `Path blocked: ${normalizedPath} is under ${prefix}`
+        };
+      }
+    }
+  }
   if (rules.allowedPrefix != null && rules.allowedPrefix.length > 0) {
     const isAllowed = rules.allowedPrefix.some((prefix) => normalizedPath.startsWith(prefix));
     if (!isAllowed) {
@@ -58744,16 +59150,6 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules) {
       reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}`
     };
   }
-  if (rules.blockedPrefix && rules.blockedPrefix.length > 0) {
-    for (const prefix of rules.blockedPrefix) {
-      if (normalizedPath.startsWith(prefix)) {
-        return {
-          allowed: false,
-          reason: `Path blocked: ${normalizedPath} is under ${prefix}`
-        };
-      }
-    }
-  }
   if (rules.blockedZones && rules.blockedZones.length > 0) {
     const { zone } = classifyFile(normalizedPath);
     if (rules.blockedZones.includes(zone)) {
@@ -59526,7 +59922,9 @@ var END_OF_SENTENCE_QUESTION_PATTERN = /\?\s*$/;
 var PHASE_COMPLETION_PATTERNS = [
   /Ready for Phase (?:\d+|\[?N\+1\]?)\??/i,
   /phase.{0,20}(?:complete|finish|done|wrap)/i,
-  /move(?:d?)?\s+(?:on\s+)?to\s+(?:the\s+)?(?:next\s+)?phase/i
+  /move(?:d?)?\s+(?:on\s+)?to\s+(?:the\s+)?(?:next\s+)?phase/i,
+  /(?:proceed|move)\s+to\s+the\s+next\s+phase/i,
+  /what would you like.{0,20}(?:next|do next)/i
 ];
 var QUESTION_ESCALATION_PATTERNS = [
   /escalat/i,
@@ -61431,6 +61829,47 @@ ${handoffBlock}`);
               }
             } catch {}
           }
+          if (baseRole === "coder") {
+            const sessionId_ccp = _input.sessionID ?? "";
+            const ccpSession = swarmState.agentSessions.get(sessionId_ccp);
+            try {
+              const coderScope = ccpSession?.declaredCoderScope;
+              const primaryFile = coderScope?.[0] ?? "";
+              if (primaryFile.length > 0) {
+                const { knowledge_recall: knowledge_recall2 } = await Promise.resolve().then(() => (init_knowledge_recall(), exports_knowledge_recall));
+                const rawResult = await knowledge_recall2.execute({ query: primaryFile }, { directory });
+                if (rawResult && typeof rawResult === "string") {
+                  const parsed = JSON.parse(rawResult);
+                  if (parsed.results.length > 0) {
+                    const lines = parsed.results.map((r) => {
+                      const lesson = r.lesson.length > 200 ? `${r.lesson.slice(0, 200)}...` : r.lesson;
+                      return `- [${r.category}] ${lesson}`;
+                    });
+                    tryInject(`## CONTEXT FROM KNOWLEDGE BASE
+${lines.join(`
+`)}`);
+                  }
+                }
+              }
+            } catch {}
+            try {
+              const taskId_ccp = ccpSession?.currentTaskId;
+              if (taskId_ccp && !taskId_ccp.includes("..") && !taskId_ccp.includes("/") && !taskId_ccp.includes("\\") && !taskId_ccp.includes("\x00")) {
+                const evidencePath = path47.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                if (fs35.existsSync(evidencePath)) {
+                  const evidenceContent = fs35.readFileSync(evidencePath, "utf-8");
+                  const evidenceData = JSON.parse(evidenceContent);
+                  const rejections = (evidenceData.bundle?.entries ?? []).filter((e) => e.type === "gate" && e.gate_type === "reviewer" && e.verdict === "reject");
+                  if (rejections.length > 0) {
+                    const lines = rejections.map((r) => `- ${r.reason ?? "No reason provided"}`);
+                    tryInject(`## PRIOR REJECTIONS
+${lines.join(`
+`)}`);
+                  }
+                }
+              }
+            } catch {}
+          }
           if (baseRole === "coder") {
             const taskText_lang_a = plan2 && plan2.migration_status !== "migration_failed" ? extractCurrentTaskFromPlan(plan2) : null;
             const langConstraints_a = buildLanguageCoderConstraints(taskText_lang_a);
@@ -67760,90 +68199,10 @@ var knowledge_query = createSwarmTool({
 `);
   }
 });
-// src/tools/knowledge-recall.ts
-init_dist();
-init_knowledge_store();
-init_create_tool();
-var knowledge_recall = createSwarmTool({
-  description: "Search the knowledge base for relevant past decisions, patterns, and lessons learned. Returns ranked results by semantic similarity.",
-  args: {
-    query: tool.schema.string().min(3).describe("Natural language search query"),
-    top_n: tool.schema.number().int().min(1).max(20).optional().describe("Maximum results to return (default: 5)"),
-    tier: tool.schema.enum(["all", "swarm", "hive"]).optional().describe("Knowledge tier to search (default: 'all')")
-  },
-  execute: async (args2, directory) => {
-    let queryInput;
-    let topNInput;
-    let tierInput;
-    try {
-      if (args2 && typeof args2 === "object") {
-        const obj = args2;
-        queryInput = obj.query;
-        topNInput = obj.top_n;
-        tierInput = obj.tier;
-      }
-    } catch {}
-    if (typeof queryInput !== "string" || queryInput.length < 3) {
-      return JSON.stringify({
-        results: [],
-        total: 0,
-        error: "query must be a string with at least 3 characters"
-      });
-    }
-    let topN = 5;
-    if (topNInput !== undefined) {
-      if (typeof topNInput === "number" && Number.isInteger(topNInput)) {
-        topN = Math.max(1, Math.min(20, topNInput));
-      }
-    }
-    let tier = "all";
-    if (tierInput !== undefined && typeof tierInput === "string") {
-      if (tierInput === "swarm" || tierInput === "hive") {
-        tier = tierInput;
-      }
-    }
-    const swarmPath = resolveSwarmKnowledgePath(directory);
-    const hivePath = resolveHiveKnowledgePath();
-    const [swarmEntries, hiveEntries] = await Promise.all([
-      readKnowledge(swarmPath),
-      readKnowledge(hivePath)
-    ]);
-    let entries = [];
-    if (tier === "all" || tier === "swarm") {
-      entries = entries.concat(swarmEntries);
-    }
-    if (tier === "all" || tier === "hive") {
-      entries = entries.concat(hiveEntries);
-    }
-    if (entries.length === 0) {
-      const result2 = { results: [], total: 0 };
-      return JSON.stringify(result2);
-    }
-    const normalizedQuery = normalize2(queryInput);
-    const queryBigrams = wordBigrams(normalizedQuery);
-    const scoredEntries = entries.map((entry) => {
-      const entryText = `${entry.lesson} ${entry.tags.join(" ")} ${entry.category}`;
-      const entryBigrams = wordBigrams(entryText);
-      const textScore = jaccardBigram(queryBigrams, entryBigrams);
-      const boost = entry.status === "established" ? 0.1 : entry.status === "promoted" ? 0.05 : 0;
-      const finalScore = textScore + boost;
-      return {
-        id: entry.id,
-        confidence: entry.confidence,
-        category: entry.category,
-        lesson: entry.lesson,
-        score: finalScore
-      };
-    });
-    scoredEntries.sort((a, b) => b.score - a.score);
-    const topResults = scoredEntries.slice(0, topN);
-    const result = {
-      results: topResults,
-      total: topResults.length
-    };
-    return JSON.stringify(result);
-  }
-});
+
+// src/tools/index.ts
+init_knowledge_recall();
+
 // src/tools/knowledge-remove.ts
 init_dist();
 init_knowledge_store();
@@ -76173,7 +76532,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         message: "Invalid working_directory: null bytes are not allowed"
       };
     }
-    if (process.platform === "win32") {
+    {
       const devicePathPattern = /^\\\\|^(NUL|CON|AUX|COM[1-9]|LPT[1-9])(\..*)?$/i;
       if (devicePathPattern.test(args2.working_directory)) {
         return {
@@ -76329,7 +76688,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
       errors: [error93 instanceof Error ? error93.message : String(error93)]
     };
   } finally {
-    if (lockResult && lockResult.acquired && lockResult.lock._release) {
+    if (lockResult?.acquired && lockResult.lock._release) {
       try {
         await lockResult.lock._release();
       } catch (releaseError) {