opencode-swarm-plugin 0.14.0 → 0.15.0

package/dist/plugin.js

@@ -28536,6 +28536,7 @@ var require_gray_matter = __commonJS((exports, module) => {
 // src/skills.ts
 var exports_skills = {};
 __export(exports_skills, {
+  validateCSOCompliance: () => validateCSOCompliance,
   skills_use: () => skills_use,
   skills_update: () => skills_update,
   skills_read: () => skills_read,
@@ -28708,6 +28709,90 @@ async function listSkills() {
 function invalidateSkillsCache() {
   skillsCache = null;
 }
+function validateCSOCompliance(name, description) {
+  const warnings = {
+    critical: [],
+    suggestions: []
+  };
+  const hasUseWhen = /\buse when\b/i.test(description);
+  if (!hasUseWhen) {
+    warnings.critical.push("Description should include 'Use when...' to focus on triggering conditions");
+  }
+  if (description.length > 1024) {
+    warnings.critical.push(`Description is ${description.length} chars (max 1024) - will be rejected`);
+  } else if (description.length > 500) {
+    warnings.suggestions.push(`Description is ${description.length} chars (aim for <500 for optimal discoverability)`);
+  }
+  const firstPersonPattern = /\b(I|I'm|I'll|my|mine|myself)\b/i;
+  const secondPersonPattern = /\b(you|you're|you'll|your|yours|yourself)\b/i;
+  if (firstPersonPattern.test(description)) {
+    warnings.critical.push("Description uses first-person ('I', 'my') - skills are injected into system prompt, use third-person only");
+  }
+  if (secondPersonPattern.test(description)) {
+    warnings.critical.push("Description uses second-person ('you', 'your') - use third-person voice (e.g., 'Handles X' not 'You can handle X')");
+  }
+  const nameWords = name.split("-");
+  const firstWord = nameWords[0];
+  const isGerund = /ing$/.test(firstWord);
+  const isVerbForm = /(ing|ize|ify|ate)$/.test(firstWord);
+  if (!isGerund && !isVerbForm) {
+    const actionVerbs = [
+      "test",
+      "debug",
+      "fix",
+      "scan",
+      "check",
+      "validate",
+      "create",
+      "build",
+      "deploy",
+      "run",
+      "load",
+      "fetch",
+      "parse"
+    ];
+    const startsWithAction = actionVerbs.includes(firstWord);
+    if (!startsWithAction) {
+      warnings.suggestions.push(`Name '${name}' doesn't follow verb-first pattern. Consider gerunds (e.g., 'testing-skills' not 'test-skill') or action verbs for better clarity`);
+    }
+  }
+  if (name.length > 64) {
+    warnings.critical.push(`Name exceeds 64 character limit (${name.length} chars)`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    warnings.critical.push("Name must be lowercase letters, numbers, and hyphens only");
+  }
+  return warnings;
+}
+function formatCSOWarnings(warnings) {
+  if (warnings.critical.length === 0 && warnings.suggestions.length === 0) {
+    return null;
+  }
+  const parts = [];
+  if (warnings.critical.length > 0) {
+    parts.push("**CSO Critical Issues:**");
+    for (const warning of warnings.critical) {
+      parts.push(`  ⚠️  ${warning}`);
+    }
+  }
+  if (warnings.suggestions.length > 0) {
+    parts.push(`
+**CSO Suggestions:**`);
+    for (const suggestion of warnings.suggestions) {
+      parts.push(`  \uD83D\uDCA1 ${suggestion}`);
+    }
+  }
+  parts.push(`
+**CSO Guide:**`);
+  parts.push("  • Start description with 'Use when...' (focus on triggering conditions)");
+  parts.push("  • Keep description <500 chars (max 1024)");
+  parts.push("  • Use third-person voice only (injected into system prompt)");
+  parts.push("  • Name: verb-first or gerunds (e.g., 'testing-async' not 'async-test')");
+  parts.push(`
+  Example: 'Use when tests have race conditions - replaces arbitrary timeouts with condition polling'`);
+  return parts.join(`
+`);
+}
 function quoteYamlScalar(value) {
   const needsQuoting = /[:\n\r#"'`\[\]{}|>&*!?@]/.test(value) || value.startsWith(" ") || value.endsWith(" ") || value === "" || /^[0-9]/.test(value) || ["true", "false", "null", "yes", "no", "on", "off"].includes(value.toLowerCase());
   if (!needsQuoting) {
@@ -29059,6 +29144,7 @@ Good skills have:
       if (existing) {
         return `Skill '${args.name}' already exists at ${existing.path}. Use skills_update to modify it.`;
       }
+      const csoWarnings = validateCSOCompliance(args.name, args.description);
       let skillDir;
       if (args.directory === "global") {
         skillDir = join5(getGlobalSkillsDir(), args.name);
@@ -29074,7 +29160,7 @@ Good skills have:
         const content = generateSkillContent(args.name, args.description, args.body, { tags: args.tags, tools: args.tools });
         await writeFile(skillPath, content, "utf-8");
         invalidateSkillsCache();
-        return JSON.stringify({
+        const response = {
           success: true,
           skill: args.name,
           path: skillPath,
@@ -29084,7 +29170,12 @@ Good skills have:
             "Add examples.md or reference.md for supplementary content",
             "Add scripts/ directory for executable helpers"
           ]
-        }, null, 2);
+        };
+        const warningsMessage = formatCSOWarnings(csoWarnings);
+        if (warningsMessage) {
+          response.cso_warnings = warningsMessage;
+        }
+        return JSON.stringify(response, null, 2);
       } catch (error45) {
         return `Failed to create skill: ${error45 instanceof Error ? error45.message : String(error45)}`;
       }
@@ -32229,6 +32320,90 @@ function outcomeToFeedback(outcome, criterion) {
     raw_value: outcome.decayed_value
   };
 }
+var StrikeRecordSchema = exports_external.object({
+  bead_id: exports_external.string(),
+  strike_count: exports_external.number().int().min(0).max(3),
+  failures: exports_external.array(exports_external.object({
+    attempt: exports_external.string(),
+    reason: exports_external.string(),
+    timestamp: exports_external.string()
+  })),
+  first_strike_at: exports_external.string().optional(),
+  last_strike_at: exports_external.string().optional()
+});
+
+class InMemoryStrikeStorage {
+  strikes = new Map;
+  async store(record2) {
+    this.strikes.set(record2.bead_id, record2);
+  }
+  async get(beadId) {
+    return this.strikes.get(beadId) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.strikes.values());
+  }
+  async clear(beadId) {
+    this.strikes.delete(beadId);
+  }
+}
+async function addStrike(beadId, attempt, reason, storage = new InMemoryStrikeStorage) {
+  const existing = await storage.get(beadId);
+  const now = new Date().toISOString();
+  const record2 = existing ?? {
+    bead_id: beadId,
+    strike_count: 0,
+    failures: []
+  };
+  record2.strike_count = Math.min(3, record2.strike_count + 1);
+  record2.failures.push({ attempt, reason, timestamp: now });
+  record2.last_strike_at = now;
+  if (!record2.first_strike_at) {
+    record2.first_strike_at = now;
+  }
+  await storage.store(record2);
+  return record2;
+}
+async function getStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  return record2?.strike_count ?? 0;
+}
+async function isStrikedOut(beadId, storage = new InMemoryStrikeStorage) {
+  const count = await getStrikes(beadId, storage);
+  return count >= 3;
+}
+async function getArchitecturePrompt(beadId, storage = new InMemoryStrikeStorage) {
+  const record2 = await storage.get(beadId);
+  if (!record2 || record2.strike_count < 3) {
+    return "";
+  }
+  const failuresList = record2.failures.map((f, i) => `${i + 1}. **${f.attempt}** - Failed: ${f.reason}`).join(`
+`);
+  return `## Architecture Review Required
+
+This bead (\`${beadId}\`) has failed 3 consecutive fix attempts:
+
+${failuresList}
+
+This pattern suggests an **architectural problem**, not a bug.
+
+**Questions to consider:**
+- Is the current approach fundamentally sound?
+- Should we refactor the architecture instead?
+- Are we fixing symptoms instead of root cause?
+
+**Options:**
+1. **Refactor architecture** (describe new approach)
+2. **Continue with Fix #4** (explain why this time is different)
+3. **Abandon this approach entirely**
+
+**DO NOT attempt Fix #4 without answering these questions.**
+`;
+}
+async function clearStrikes(beadId, storage = new InMemoryStrikeStorage) {
+  await storage.clear(beadId);
+}
+
 class InMemoryErrorStorage {
   errors = [];
   async store(entry) {
@@ -32747,7 +32922,7 @@ You MUST keep your bead updated as you work:
 
 **Never work silently.** Your bead status is how the swarm tracks progress.
 
-## MANDATORY: Agent Mail Communication
+## MANDATORY: Swarm Mail Communication
 
 You MUST communicate with other agents:
 
@@ -32756,9 +32931,9 @@ You MUST communicate with other agents:
 3. **Announce blockers** immediately - don't spin trying to fix alone
 4. **Coordinate on shared concerns** - if you see something affecting other agents, say so
 
-Use Agent Mail for all communication:
+Use Swarm Mail for all communication:
 \`\`\`
-agentmail_send(
+swarmmail_send(
   to: ["coordinator" or specific agent],
   subject: "Brief subject",
   body: "Message content",
@@ -32770,7 +32945,7 @@ agentmail_send(
 
 1. **Start**: Your bead is already marked in_progress
 2. **Progress**: Use swarm_progress to report status updates
-3. **Blocked**: Report immediately via Agent Mail - don't spin
+3. **Blocked**: Report immediately via Swarm Mail - don't spin
 4. **Complete**: Use swarm_complete when done - it handles:
    - Closing your bead with a summary
    - Releasing file reservations
@@ -32792,7 +32967,7 @@ Before writing code:
 1. **Read the files** you're assigned to understand current state
 2. **Plan your approach** - what changes, in what order?
 3. **Identify risks** - what could go wrong? What dependencies?
-4. **Communicate your plan** via Agent Mail if non-trivial
+4. **Communicate your plan** via Swarm Mail if non-trivial
 
 Begin work on your subtask now.`;
 var SUBTASK_PROMPT_V2 = `You are a swarm agent working on: **{subtask_title}**
@@ -33495,6 +33670,139 @@ var swarm_progress = tool({
     return `Progress reported: ${args.status}${args.progress_percent !== undefined ? ` (${args.progress_percent}%)` : ""}`;
   }
 });
+async function runTypecheckVerification() {
+  const step = {
+    name: "typecheck",
+    command: "tsc --noEmit",
+    passed: false,
+    exitCode: -1
+  };
+  try {
+    const tsconfigExists = await Bun.file("tsconfig.json").exists();
+    if (!tsconfigExists) {
+      step.skipped = true;
+      step.skipReason = "No tsconfig.json found";
+      step.passed = true;
+      return step;
+    }
+    const result = await Bun.$`tsc --noEmit`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `tsc not available: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runTestVerification(filesTouched) {
+  const step = {
+    name: "tests",
+    command: "bun test <related-files>",
+    passed: false,
+    exitCode: -1
+  };
+  if (filesTouched.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No files touched";
+    step.passed = true;
+    return step;
+  }
+  const testPatterns = [];
+  for (const file2 of filesTouched) {
+    if (file2.includes(".test.") || file2.includes(".spec.")) {
+      testPatterns.push(file2);
+      continue;
+    }
+    const baseName = file2.replace(/\.(ts|tsx|js|jsx)$/, "");
+    testPatterns.push(`${baseName}.test.ts`);
+    testPatterns.push(`${baseName}.test.tsx`);
+    testPatterns.push(`${baseName}.spec.ts`);
+  }
+  const existingTests = [];
+  for (const pattern of testPatterns) {
+    try {
+      const exists = await Bun.file(pattern).exists();
+      if (exists) {
+        existingTests.push(pattern);
+      }
+    } catch {}
+  }
+  if (existingTests.length === 0) {
+    step.skipped = true;
+    step.skipReason = "No related test files found";
+    step.passed = true;
+    return step;
+  }
+  try {
+    step.command = `bun test ${existingTests.join(" ")}`;
+    const result = await Bun.$`bun test ${existingTests}`.quiet().nothrow();
+    step.exitCode = result.exitCode;
+    step.passed = result.exitCode === 0;
+    if (!step.passed) {
+      step.error = result.stderr.toString().slice(0, 1000);
+      step.output = result.stdout.toString().slice(0, 1000);
+    }
+  } catch (error45) {
+    step.skipped = true;
+    step.skipReason = `Test runner failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    step.passed = true;
+  }
+  return step;
+}
+async function runVerificationGate(filesTouched, skipUbs = false) {
+  const steps = [];
+  const blockers = [];
+  if (!skipUbs && filesTouched.length > 0) {
+    const ubsResult = await runUbsScan(filesTouched);
+    if (ubsResult) {
+      const ubsStep = {
+        name: "ubs_scan",
+        command: `ubs scan ${filesTouched.join(" ")}`,
+        passed: ubsResult.summary.critical === 0,
+        exitCode: ubsResult.exitCode
+      };
+      if (!ubsStep.passed) {
+        ubsStep.error = `Found ${ubsResult.summary.critical} critical bugs`;
+        blockers.push(`UBS: ${ubsResult.summary.critical} critical bugs found`);
+      }
+      steps.push(ubsStep);
+    } else {
+      steps.push({
+        name: "ubs_scan",
+        command: "ubs scan",
+        passed: true,
+        exitCode: 0,
+        skipped: true,
+        skipReason: "UBS not available"
+      });
+    }
+  }
+  const typecheckStep = await runTypecheckVerification();
+  steps.push(typecheckStep);
+  if (!typecheckStep.passed && !typecheckStep.skipped) {
+    blockers.push(`Typecheck: ${typecheckStep.error?.slice(0, 100) || "failed"}`);
+  }
+  const testStep = await runTestVerification(filesTouched);
+  steps.push(testStep);
+  if (!testStep.passed && !testStep.skipped) {
+    blockers.push(`Tests: ${testStep.error?.slice(0, 100) || "failed"}`);
+  }
+  const passedCount = steps.filter((s) => s.passed).length;
+  const skippedCount = steps.filter((s) => s.skipped).length;
+  const failedCount = steps.filter((s) => !s.passed && !s.skipped).length;
+  const summary = failedCount === 0 ? `Verification passed: ${passedCount} checks passed, ${skippedCount} skipped` : `Verification FAILED: ${failedCount} checks failed, ${passedCount} passed, ${skippedCount} skipped`;
+  return {
+    passed: failedCount === 0,
+    steps,
+    summary,
+    blockers
+  };
+}
 async function runUbsScan(files) {
   if (files.length === 0) {
     return null;
@@ -33597,19 +33905,44 @@ ${args.files_affected.map((f) => `- \`${f}\``).join(`
   }
 });
 var swarm_complete = tool({
-  description: "Mark subtask complete, release reservations, notify coordinator. Runs UBS bug scan if files_touched provided.",
+  description: "Mark subtask complete with Verification Gate. Runs UBS scan, typecheck, and tests before allowing completion.",
   args: {
     project_key: tool.schema.string().describe("Project path"),
     agent_name: tool.schema.string().describe("Your Agent Mail name"),
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     summary: tool.schema.string().describe("Brief summary of work done"),
     evaluation: tool.schema.string().optional().describe("Self-evaluation JSON (Evaluation schema)"),
-    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be scanned by UBS for bugs"),
-    skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)")
+    files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (UBS, typecheck, tests)"),
+    skip_ubs_scan: tool.schema.boolean().optional().describe("Skip UBS bug scan (default: false)"),
+    skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (UBS, typecheck, tests). Use sparingly! (default: false)")
   },
   async execute(args) {
+    let verificationResult = null;
+    if (!args.skip_verification && args.files_touched?.length) {
+      verificationResult = await runVerificationGate(args.files_touched, args.skip_ubs_scan ?? false);
+      if (!verificationResult.passed) {
+        return JSON.stringify({
+          success: false,
+          error: "Verification Gate FAILED - fix issues before completing",
+          verification: {
+            passed: false,
+            summary: verificationResult.summary,
+            blockers: verificationResult.blockers,
+            steps: verificationResult.steps.map((s) => ({
+              name: s.name,
+              passed: s.passed,
+              skipped: s.skipped,
+              skipReason: s.skipReason,
+              error: s.error?.slice(0, 200)
+            }))
+          },
+          hint: "Fix the failing checks and try again. Use skip_verification=true only as last resort.",
+          gate_function: "IDENTIFY → RUN → READ → VERIFY → CLAIM (you are at VERIFY, claim blocked)"
+        }, null, 2);
+      }
+    }
     let ubsResult = null;
-    if (args.files_touched && args.files_touched.length > 0 && !args.skip_ubs_scan) {
+    if (!args.skip_verification && !verificationResult && args.files_touched?.length && !args.skip_ubs_scan) {
       ubsResult = await runUbsScan(args.files_touched);
       if (ubsResult && ubsResult.summary.critical > 0) {
         return JSON.stringify({
@@ -33680,12 +34013,22 @@ var swarm_complete = tool({
       closed: true,
       reservations_released: true,
       message_sent: true,
+      verification_gate: verificationResult ? {
+        passed: true,
+        summary: verificationResult.summary,
+        steps: verificationResult.steps.map((s) => ({
+          name: s.name,
+          passed: s.passed,
+          skipped: s.skipped,
+          skipReason: s.skipReason
+        }))
+      } : args.skip_verification ? { skipped: true, reason: "skip_verification=true" } : { skipped: true, reason: "no files_touched provided" },
       ubs_scan: ubsResult ? {
         ran: true,
         bugs_found: ubsResult.summary.total,
         summary: ubsResult.summary,
         warnings: ubsResult.bugs.filter((b) => b.severity !== "critical")
-      } : {
+      } : verificationResult ? { ran: true, included_in_verification_gate: true } : {
         ran: false,
         reason: args.skip_ubs_scan ? "skipped" : "no files or ubs unavailable"
       },
@@ -34253,6 +34596,77 @@ var swarmTools = {
   swarm_get_error_context,
   swarm_resolve_error
 };
+var globalStrikeStorage = new InMemoryStrikeStorage;
+var swarm_check_strikes = tool({
+  description: "Check 3-strike status for a bead. Records failures, detects architectural problems, generates architecture review prompts.",
+  args: {
+    bead_id: tool.schema.string().describe("Bead ID to check"),
+    action: tool.schema.enum(["check", "add_strike", "clear", "get_prompt"]).describe("Action: check count, add strike, clear strikes, or get prompt"),
+    attempt: tool.schema.string().optional().describe("Description of fix attempt (required for add_strike)"),
+    reason: tool.schema.string().optional().describe("Why the fix failed (required for add_strike)")
+  },
+  async execute(args) {
+    switch (args.action) {
+      case "check": {
+        const count = await getStrikes(args.bead_id, globalStrikeStorage);
+        const strikedOut = await isStrikedOut(args.bead_id, globalStrikeStorage);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: count,
+          is_striked_out: strikedOut,
+          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. Use get_prompt action for architecture review." : count === 0 ? "No strikes. Clear to proceed." : `${count} strike${count > 1 ? "s" : ""}. ${3 - count} remaining before architecture review required.`,
+          next_action: strikedOut ? "Call with action=get_prompt to get architecture review questions" : "Continue with fix attempt"
+        }, null, 2);
+      }
+      case "add_strike": {
+        if (!args.attempt || !args.reason) {
+          return JSON.stringify({
+            error: "add_strike requires 'attempt' and 'reason' parameters"
+          }, null, 2);
+        }
+        const record2 = await addStrike(args.bead_id, args.attempt, args.reason, globalStrikeStorage);
+        const strikedOut = record2.strike_count >= 3;
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: record2.strike_count,
+          is_striked_out: strikedOut,
+          failures: record2.failures,
+          message: strikedOut ? "⚠️ STRUCK OUT: 3 strikes reached. STOP and question the architecture." : `Strike ${record2.strike_count} recorded. ${3 - record2.strike_count} remaining.`,
+          warning: strikedOut ? "DO NOT attempt Fix #4. Call with action=get_prompt for architecture review." : undefined
+        }, null, 2);
+      }
+      case "clear": {
+        await clearStrikes(args.bead_id, globalStrikeStorage);
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          strike_count: 0,
+          is_striked_out: false,
+          message: "Strikes cleared. Fresh start."
+        }, null, 2);
+      }
+      case "get_prompt": {
+        const prompt = await getArchitecturePrompt(args.bead_id, globalStrikeStorage);
+        if (!prompt) {
+          return JSON.stringify({
+            bead_id: args.bead_id,
+            has_prompt: false,
+            message: "No architecture prompt (not struck out yet)"
+          }, null, 2);
+        }
+        return JSON.stringify({
+          bead_id: args.bead_id,
+          has_prompt: true,
+          architecture_review_prompt: prompt,
+          message: "Architecture review required. Present this prompt to the human partner."
+        }, null, 2);
+      }
+      default:
+        return JSON.stringify({
+          error: `Unknown action: ${args.action}`
+        }, null, 2);
+    }
+  }
+});
 
 // src/repo-crawl.ts
 init_dist();