opencode-swarm 7.3.3 → 7.3.5

package/README.md

@@ -788,6 +788,17 @@ Prefixed agents (e.g., `paid_coder`, `mega_reviewer`, `local_architect`) inherit
 
 In this example, `paid_coder` gets its own explicit rule, while other prefixed coders (e.g., `mega_coder`) fall back to `coder`.
 
+#### Selecting the primary agent in multi-swarm configs (`default_agent`)
+
+The top-level `default_agent` field controls which generated agents OpenCode treats as primary. **It is optional.** Behavior:
+
+- **Omitted** — every architect-role agent is primary. In a multi-swarm config that means each swarm exposes its own architect (`local_architect`, `mega_architect`, `paid_architect`, `modelrelay_architect`, …) as a selectable session default. This is the v7.0.0-compatible behavior and the recommended setup.
+- **Base role** (e.g. `"coder"`) — every generated agent whose canonical base role matches becomes primary (`local_coder`, `mega_coder`, …).
+- **Exact generated name** (e.g. `"local_architect"`) — only that agent is primary.
+- **Unknown / invalid value** — a one-time warning is logged and the resolver falls back to architect-role primaries (or the first generated agent if architects are disabled). The plugin never produces zero primaries when at least one agent exists.
+
+See [`docs/configuration.md`](docs/configuration.md) for the full table.
+
 ### Runtime Enforcement
 
 Architect direct writes are enforced at runtime via `toolBefore` hook. This tracks writes to source code paths outside `.swarm/` and protects `.swarm/plan.md` and `.swarm/plan.json` from direct modification.

package/dist/agents/index.d.ts

@@ -34,6 +34,34 @@ export declare function getSwarmAgents(): Record<string, {
  * Create all agent definitions with configuration applied
  */
 export declare function createAgents(config?: PluginConfig): AgentDefinition[];
+/**
+ * Resolve the set of generated agent names that should be marked as primary
+ * for OpenCode's session-default-agent resolution.
+ *
+ * Resolution rules (see schema.ts default_agent comment for full semantics):
+ *   - default_agent omitted ⇒ every architect-role agent is primary
+ *     (canonical base role === "architect"). This restores v7.0.0 behavior in
+ *     multi-swarm configs where there is no unprefixed `architect` agent.
+ *   - default_agent exactly matches a generated agent name ⇒ only that agent.
+ *     Exact match wins over base-role match — `local_architect` resolves to
+ *     just `local_architect`, never the entire architect role.
+ *   - default_agent is a base role in ALL_AGENT_NAMES ⇒ every generated agent
+ *     whose canonical base role matches that role.
+ *   - default_agent is invalid (matches nothing) ⇒ fall back to architect-role
+ *     primaries; if no architect roles exist (architects disabled), fall back
+ *     to the first generated agent. Always warns. Never returns empty when
+ *     `agentNames` is non-empty.
+ *
+ * Important matching detail: a value like "not_an_architect" is NOT treated
+ * as a base-role request even though stripKnownSwarmPrefix() returns
+ * "architect" for it. Base-role matching only fires when the user-supplied
+ * value is itself one of ALL_AGENT_NAMES.
+ */
+export declare function resolvePrimaryAgentNames(agentNames: string[], defaultAgent?: string): {
+    primaryNames: Set<string>;
+    reason: 'implicit-architects' | 'exact' | 'base-role' | 'fallback-architects' | 'fallback-first';
+    warning?: string;
+};
 /**
  * Get agent configurations formatted for the OpenCode SDK.
  */

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.3.3",
+    version: "7.3.5",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -16915,7 +16915,12 @@ var init_schema = __esm(() => {
   });
   PluginConfigSchema = exports_external.object({
     agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
-    default_agent: exports_external.enum(ALL_AGENT_NAMES).default("architect").optional(),
+    default_agent: exports_external.string().optional().transform((v) => {
+      if (v === undefined)
+        return;
+      const trimmed = v.trim();
+      return trimmed === "" ? undefined : trimmed;
+    }),
     swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
     max_iterations: exports_external.number().min(1).max(10).default(5),
     pipeline: PipelineConfigSchema.optional(),

package/dist/config/schema.d.ts

@@ -643,26 +643,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         disabled: z.ZodOptional<z.ZodBoolean>;
         fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
-    default_agent: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
-        architect: "architect";
-        sme: "sme";
-        docs: "docs";
-        designer: "designer";
-        critic_sounding_board: "critic_sounding_board";
-        critic_drift_verifier: "critic_drift_verifier";
-        critic_hallucination_verifier: "critic_hallucination_verifier";
-        curator_init: "curator_init";
-        curator_phase: "curator_phase";
-        council_generalist: "council_generalist";
-        council_skeptic: "council_skeptic";
-        council_domain_expert: "council_domain_expert";
-        reviewer: "reviewer";
-        critic: "critic";
-        critic_oversight: "critic_oversight";
-        explorer: "explorer";
-        coder: "coder";
-        test_engineer: "test_engineer";
-    }>>>;
+    default_agent: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     swarms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/hooks/diff-scope.d.ts

@@ -4,6 +4,16 @@
  * were modified, or null if in-scope, no scope declared, or git unavailable.
  * Never throws.
  */
+import { bunSpawn } from '../utils/bun-compat';
+/**
+ * Test-only dependency-injection seam — see `gitignore-warning.ts:_internals`
+ * for the rationale (`mock.module` from `bun:test` leaks across files in
+ * Bun's shared test-runner process). Mutating this local object is
+ * file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+};
 /**
  * Validate that git-changed files match the declared scope for a task.
  * Returns a warning string if undeclared files were modified, null otherwise.

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.3.3",
+    version: "7.3.5",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -15352,7 +15352,12 @@ var init_schema = __esm(() => {
   });
   PluginConfigSchema = exports_external.object({
     agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
-    default_agent: exports_external.enum(ALL_AGENT_NAMES).default("architect").optional(),
+    default_agent: exports_external.string().optional().transform((v) => {
+      if (v === undefined)
+        return;
+      const trimmed = v.trim();
+      return trimmed === "" ? undefined : trimmed;
+    }),
     swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
     max_iterations: exports_external.number().min(1).max(10).default(5),
     pipeline: PipelineConfigSchema.optional(),
@@ -59986,6 +59991,52 @@ function createAgents(config3) {
   }
   return allAgents;
 }
+function resolvePrimaryAgentNames(agentNames, defaultAgent) {
+  const collectArchitectRole = () => agentNames.filter((n) => stripKnownSwarmPrefix(n) === "architect");
+  const trimmed = typeof defaultAgent === "string" ? defaultAgent.trim() : undefined;
+  const value = trimmed === "" ? undefined : trimmed;
+  if (agentNames.length === 0) {
+    return { primaryNames: new Set, reason: "implicit-architects" };
+  }
+  if (value === undefined) {
+    const architects2 = collectArchitectRole();
+    if (architects2.length > 0) {
+      return {
+        primaryNames: new Set(architects2),
+        reason: "implicit-architects"
+      };
+    }
+    const first2 = agentNames[0];
+    return {
+      primaryNames: new Set([first2]),
+      reason: "fallback-first",
+      warning: `[swarm] No architect-role agents are registered and default_agent is unset; falling back to '${first2}' as primary. Re-enable an architect agent or set default_agent to silence this warning.`
+    };
+  }
+  if (ALL_AGENT_NAMES.includes(value)) {
+    const matching = agentNames.filter((n) => stripKnownSwarmPrefix(n) === value);
+    if (matching.length > 0) {
+      return { primaryNames: new Set(matching), reason: "base-role" };
+    }
+  }
+  if (agentNames.includes(value)) {
+    return { primaryNames: new Set([value]), reason: "exact" };
+  }
+  const architects = collectArchitectRole();
+  if (architects.length > 0) {
+    return {
+      primaryNames: new Set(architects),
+      reason: "fallback-architects",
+      warning: `[swarm] default_agent '${value}' did not match any registered agent; falling back to architect-role primaries: ${architects.join(", ")}.`
+    };
+  }
+  const first = agentNames[0];
+  return {
+    primaryNames: new Set([first]),
+    reason: "fallback-first",
+    warning: `[swarm] default_agent '${value}' did not match any registered agent and no architect-role agents are registered; falling back to '${first}' as primary.`
+  };
+}
 function getAgentConfigs(config3, directory, sessionId) {
   const agents = createAgents(config3);
   const toolFilterEnabled = config3?.tool_filter?.enabled ?? true;
@@ -59993,21 +60044,29 @@ function getAgentConfigs(config3, directory, sessionId) {
   const quiet = config3?.quiet ?? true;
   const warnedMissingWhitelist = new Set;
   const agentToolSnapshot = {};
+  const resolution = resolvePrimaryAgentNames(agents.map((a) => a.name), config3?.default_agent);
+  if (resolution.warning) {
+    if (!quiet) {
+      console.warn(resolution.warning);
+    } else {
+      addDeferredWarning(resolution.warning);
+    }
+  }
+  if (agents.length > 0 && resolution.primaryNames.size === 0) {
+    const generated = agents.map((a) => a.name).join(", ");
+    const diagnostic = `[swarm] DIAGNOSTIC: ${agents.length} generated agents but zero primaries. Likely cause: a regression in resolvePrimaryAgentNames. Generated: ${generated}.`;
+    if (!quiet) {
+      console.warn(diagnostic);
+    } else {
+      addDeferredWarning(diagnostic);
+    }
+  }
   const result = Object.fromEntries(agents.map((agent) => {
     const sdkConfig = {
       ...agent.config,
       description: agent.description
     };
-    let defaultAgent = config3?.default_agent ?? "architect";
-    if (defaultAgent !== "architect" && !ALL_AGENT_NAMES.includes(defaultAgent)) {
-      if (!quiet) {
-        console.warn(`[swarm] Invalid default_agent '${defaultAgent}' — falling back to 'architect'. Valid values: ${ALL_AGENT_NAMES.join(", ")}`);
-      } else {
-        addDeferredWarning(`[swarm] Invalid default_agent '${defaultAgent}' — falling back to 'architect'. Valid values: ${ALL_AGENT_NAMES.join(", ")}`);
-      }
-      defaultAgent = "architect";
-    }
-    const isPrimaryAgent = agent.name === defaultAgent;
+    const isPrimaryAgent = resolution.primaryNames.has(agent.name);
     if (isPrimaryAgent) {
       sdkConfig.mode = "primary";
       sdkConfig.permission = { task: "allow" };
@@ -89610,19 +89669,141 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
+import * as fs86 from "node:fs";
+import * as path106 from "node:path";
+
+// src/hooks/diff-scope.ts
+init_bun_compat();
 import * as fs85 from "node:fs";
 import * as path105 from "node:path";
 
-// src/hooks/diff-scope.ts
+// src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs84 from "node:fs";
 import * as path104 from "node:path";
+var _internals = { bunSpawn };
+var _swarmGitExcludedChecked = false;
+function fileCoversSwarm(content) {
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (line.startsWith("#") || line.length === 0)
+      continue;
+    if (line === ".swarm" || line === ".swarm/")
+      return true;
+  }
+  return false;
+}
+var ENSURE_SWARM_GIT_EXCLUDED_OUTER_TIMEOUT_MS = 3000;
+var ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS = 1500;
+var GIT_SPAWN_OPTIONS = {
+  timeout: ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS,
+  stdin: "ignore",
+  stdout: "pipe",
+  stderr: "pipe"
+};
+async function ensureSwarmGitExcluded(directory, options = {}) {
+  if (_swarmGitExcludedChecked)
+    return;
+  _swarmGitExcludedChecked = true;
+  const { quiet = false } = options;
+  try {
+    const gitRootProc = _internals.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+    let gitRootExitCode;
+    let gitRootOutput;
+    try {
+      [gitRootExitCode, gitRootOutput] = await Promise.all([
+        gitRootProc.exited,
+        gitRootProc.stdout.text()
+      ]);
+    } finally {
+      try {
+        gitRootProc.kill();
+      } catch {}
+    }
+    if (gitRootExitCode !== 0)
+      return;
+    const gitRoot = gitRootOutput.trim();
+    if (!gitRoot)
+      return;
+    const excludePathProc = _internals.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+    let excludePathExitCode;
+    let excludePathRaw;
+    try {
+      [excludePathExitCode, excludePathRaw] = await Promise.all([
+        excludePathProc.exited,
+        excludePathProc.stdout.text()
+      ]);
+    } finally {
+      try {
+        excludePathProc.kill();
+      } catch {}
+    }
+    if (excludePathExitCode !== 0)
+      return;
+    const excludeRelPath = excludePathRaw.trim();
+    if (!excludeRelPath)
+      return;
+    const excludePath = path104.isAbsolute(excludeRelPath) ? excludeRelPath : path104.join(directory, excludeRelPath);
+    const checkIgnoreProc = _internals.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+    let checkIgnoreExitCode;
+    try {
+      checkIgnoreExitCode = await checkIgnoreProc.exited;
+    } finally {
+      try {
+        checkIgnoreProc.kill();
+      } catch {}
+    }
+    if (checkIgnoreExitCode !== 0) {
+      try {
+        fs84.mkdirSync(path104.dirname(excludePath), { recursive: true });
+        let existing = "";
+        try {
+          existing = fs84.readFileSync(excludePath, "utf8");
+        } catch {}
+        if (!fileCoversSwarm(existing)) {
+          fs84.appendFileSync(excludePath, `
+# opencode-swarm local runtime state
+.swarm/
+`, "utf8");
+          if (!quiet) {
+            console.warn("[opencode-swarm] Added .swarm/ to .git/info/exclude to prevent runtime state from appearing in git status.");
+          }
+        }
+      } catch {}
+    }
+    const trackedProc = _internals.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    let trackedExitCode;
+    let trackedOutput;
+    try {
+      [trackedExitCode, trackedOutput] = await Promise.all([
+        trackedProc.exited,
+        trackedProc.stdout.text()
+      ]);
+    } finally {
+      try {
+        trackedProc.kill();
+      } catch {}
+    }
+    if (trackedExitCode === 0 && trackedOutput.trim().length > 0) {
+      console.warn(`[opencode-swarm] WARNING: .swarm/ files are tracked by Git.
+` + `.swarm/ contains local runtime state and may contain sensitive session data.
+` + `Ignoring will not affect already-tracked files. To stop tracking them, run:
+` + `  git rm -r --cached .swarm
+` + `  echo ".swarm/" >> .gitignore
+` + '  git commit -m "Stop tracking opencode-swarm runtime state"');
+    }
+  } catch {}
+}
+
+// src/hooks/diff-scope.ts
+var _internals2 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path104.join(directory, ".swarm", "plan.json");
-    if (!fs84.existsSync(planPath))
+    const planPath = path105.join(directory, ".swarm", "plan.json");
+    if (!fs85.existsSync(planPath))
       return null;
-    const raw = fs84.readFileSync(planPath, "utf-8");
+    const raw = fs85.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -89643,30 +89824,47 @@ function getDeclaredScope(taskId, directory) {
     return null;
   }
 }
+var GIT_DIFF_SPAWN_OPTIONS = {
+  timeout: ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS,
+  stdin: "ignore",
+  stdout: "pipe",
+  stderr: "pipe"
+};
 async function getChangedFiles(directory) {
   try {
-    const proc = bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals2.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
-      stdout: "pipe",
-      stderr: "pipe"
+      ...GIT_DIFF_SPAWN_OPTIONS
     });
-    const [exitCode, stdout] = await Promise.all([
-      proc.exited,
-      proc.stdout.text()
-    ]);
+    let exitCode;
+    let stdout;
+    try {
+      [exitCode, stdout] = await Promise.all([proc.exited, proc.stdout.text()]);
+    } finally {
+      try {
+        proc.kill();
+      } catch {}
+    }
     if (exitCode === 0) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals2.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
-      stdout: "pipe",
-      stderr: "pipe"
+      ...GIT_DIFF_SPAWN_OPTIONS
     });
-    const [exitCode2, stdout2] = await Promise.all([
-      proc2.exited,
-      proc2.stdout.text()
-    ]);
+    let exitCode2;
+    let stdout2;
+    try {
+      [exitCode2, stdout2] = await Promise.all([
+        proc2.exited,
+        proc2.stdout.text()
+      ]);
+    } finally {
+      try {
+        proc2.kill();
+      } catch {}
+    }
     if (exitCode2 === 0) {
       return stdout2.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
@@ -89739,7 +89937,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path105.basename(file3);
+    const fileName = path106.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -89753,8 +89951,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path105.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs85.readFileSync(planPath, "utf-8");
+        const planPath = path106.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs86.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -89823,8 +90021,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path105.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs85.readFileSync(planPath, "utf-8");
+      const planPath = path106.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs86.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -90013,8 +90211,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path105.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path105.sep);
+    normalizedDir = path106.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path106.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -90024,11 +90222,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path105.resolve(normalizedDir);
+    const resolvedDir = path106.resolve(normalizedDir);
     try {
-      const realPath = fs85.realpathSync(resolvedDir);
-      const planPath = path105.join(realPath, ".swarm", "plan.json");
-      if (!fs85.existsSync(planPath)) {
+      const realPath = fs86.realpathSync(resolvedDir);
+      const planPath = path106.join(realPath, ".swarm", "plan.json");
+      if (!fs86.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -90059,22 +90257,22 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path105.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs85.mkdirSync(path105.dirname(evidencePath), { recursive: true });
-      const fd = fs85.openSync(evidencePath, "wx");
+      const evidencePath = path106.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs86.mkdirSync(path106.dirname(evidencePath), { recursive: true });
+      const fd = fs86.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs85.writeSync(fd, JSON.stringify({
+        fs86.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: ["reviewer", "test_engineer"],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs85.closeSync(fd);
+        fs86.closeSync(fd);
         if (!writeOk) {
           try {
-            fs85.unlinkSync(evidencePath);
+            fs86.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -90084,8 +90282,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path105.join(directory, ".swarm", "plan.json");
-      const planRaw = fs85.readFileSync(planPath, "utf-8");
+      const planPath = path106.join(directory, ".swarm", "plan.json");
+      const planRaw = fs86.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
       if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
@@ -90395,8 +90593,8 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs86 from "node:fs";
-import path106 from "node:path";
+import fs87 from "node:fs";
+import path107 from "node:path";
 function derivePlanId5(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -90447,7 +90645,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path106.join("evidence", String(phase), filename);
+  const relativePath = path107.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -90458,12 +90656,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path106.dirname(validatedPath);
+  const evidenceDir = path107.dirname(validatedPath);
   try {
-    await fs86.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path106.join(evidenceDir, `.${filename}.tmp`);
-    await fs86.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs86.promises.rename(tempPath, validatedPath);
+    await fs87.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path107.join(evidenceDir, `.${filename}.tmp`);
+    await fs87.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs87.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -90557,8 +90755,8 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs87 from "node:fs";
-import path107 from "node:path";
+import fs88 from "node:fs";
+import path108 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -90606,7 +90804,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path107.join("evidence", String(phase), filename);
+  const relativePath = path108.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -90617,12 +90815,12 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path107.dirname(validatedPath);
+  const evidenceDir = path108.dirname(validatedPath);
   try {
-    await fs87.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path107.join(evidenceDir, `.${filename}.tmp`);
-    await fs87.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs87.promises.rename(tempPath, validatedPath);
+    await fs88.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path108.join(evidenceDir, `.${filename}.tmp`);
+    await fs88.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs88.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -90668,8 +90866,8 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs88 from "node:fs";
-import path108 from "node:path";
+import fs89 from "node:fs";
+import path109 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -90743,7 +90941,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path108.join("evidence", String(phase), filename);
+  const relativePath = path109.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -90754,12 +90952,12 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path108.dirname(validatedPath);
+  const evidenceDir = path109.dirname(validatedPath);
   try {
-    await fs88.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path108.join(evidenceDir, `.${filename}.tmp`);
-    await fs88.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs88.promises.rename(tempPath, validatedPath);
+    await fs89.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path109.join(evidenceDir, `.${filename}.tmp`);
+    await fs89.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs89.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -90812,85 +91010,6 @@ init_write_retro();
 // src/index.ts
 init_utils();
 
-// src/utils/gitignore-warning.ts
-init_bun_compat();
-import * as fs89 from "node:fs";
-import * as path109 from "node:path";
-var _swarmGitExcludedChecked = false;
-function fileCoversSwarm(content) {
-  for (const rawLine of content.split(`
-`)) {
-    const line = rawLine.trim();
-    if (line.startsWith("#") || line.length === 0)
-      continue;
-    if (line === ".swarm" || line === ".swarm/")
-      return true;
-  }
-  return false;
-}
-async function ensureSwarmGitExcluded(directory, options = {}) {
-  if (_swarmGitExcludedChecked)
-    return;
-  _swarmGitExcludedChecked = true;
-  const { quiet = false } = options;
-  try {
-    const gitRootProc = bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], { stdout: "pipe", stderr: "pipe" });
-    const [gitRootExitCode, gitRootOutput] = await Promise.all([
-      gitRootProc.exited,
-      gitRootProc.stdout.text()
-    ]);
-    if (gitRootExitCode !== 0)
-      return;
-    const gitRoot = gitRootOutput.trim();
-    if (!gitRoot)
-      return;
-    const excludePathProc = bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], { stdout: "pipe", stderr: "pipe" });
-    const [excludePathExitCode, excludePathRaw] = await Promise.all([
-      excludePathProc.exited,
-      excludePathProc.stdout.text()
-    ]);
-    if (excludePathExitCode !== 0)
-      return;
-    const excludeRelPath = excludePathRaw.trim();
-    if (!excludeRelPath)
-      return;
-    const excludePath = path109.isAbsolute(excludeRelPath) ? excludeRelPath : path109.join(directory, excludeRelPath);
-    const checkIgnoreProc = bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], { stdout: "pipe", stderr: "pipe" });
-    const checkIgnoreExitCode = await checkIgnoreProc.exited;
-    if (checkIgnoreExitCode !== 0) {
-      try {
-        fs89.mkdirSync(path109.dirname(excludePath), { recursive: true });
-        let existing = "";
-        try {
-          existing = fs89.readFileSync(excludePath, "utf8");
-        } catch {}
-        if (!fileCoversSwarm(existing)) {
-          fs89.appendFileSync(excludePath, `
-# opencode-swarm local runtime state
-.swarm/
-`, "utf8");
-          if (!quiet) {
-            console.warn("[opencode-swarm] Added .swarm/ to .git/info/exclude to prevent runtime state from appearing in git status.");
-          }
-        }
-      } catch {}
-    }
-    const trackedProc = bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], { stdout: "pipe", stderr: "pipe" });
-    const [trackedExitCode, trackedOutput] = await Promise.all([
-      trackedProc.exited,
-      trackedProc.stdout.text()
-    ]);
-    if (trackedExitCode === 0 && trackedOutput.trim().length > 0) {
-      console.warn(`[opencode-swarm] WARNING: .swarm/ files are tracked by Git.
-` + `.swarm/ contains local runtime state and may contain sensitive session data.
-` + `Ignoring will not affect already-tracked files. To stop tracking them, run:
-` + `  git rm -r --cached .swarm
-` + `  echo ".swarm/" >> .gitignore
-` + '  git commit -m "Stop tracking opencode-swarm runtime state"');
-    }
-  } catch {}
-}
-
 // src/utils/tool-output.ts
 function truncateToolOutput(output, maxLines, toolName, tailLines = 10) {
   if (!output) {
@@ -90994,7 +91113,12 @@ async function initializeOpenCodeSwarm(ctx) {
     }
     repoGraphHook.init().catch(() => {}).finally(() => clearTimeout(watchdog));
   });
-  await ensureSwarmGitExcluded(ctx.directory, { quiet: config3.quiet });
+  await withTimeout(ensureSwarmGitExcluded(ctx.directory, { quiet: config3.quiet }), ENSURE_SWARM_GIT_EXCLUDED_OUTER_TIMEOUT_MS, new Error(`ensureSwarmGitExcluded exceeded ${ENSURE_SWARM_GIT_EXCLUDED_OUTER_TIMEOUT_MS}ms budget; continuing without git-hygiene check`)).catch((err3) => {
+    const msg = err3 instanceof Error ? err3.message : String(err3);
+    log("ensureSwarmGitExcluded timed out or failed (non-fatal)", {
+      error: msg
+    });
+  });
   initTelemetry(ctx.directory);
   writeSwarmConfigExampleIfNew(ctx.directory);
   writeProjectConfigIfNew(ctx.directory, config3.quiet);

package/dist/utils/gitignore-warning.d.ts

@@ -1,3 +1,15 @@
+import { bunSpawn } from './bun-compat';
+/**
+ * Test-only dependency-injection seam. Production code calls
+ * `_internals.bunSpawn(...)` so tests can replace the function on this object
+ * without touching the real `./bun-compat` module — `mock.module` from
+ * `bun:test` leaks across files in Bun's shared test-runner process, which
+ * would corrupt unrelated suites that import `bun-compat`. Mutating this
+ * local object is file-scoped and trivially restorable via `afterEach`.
+ */
+export declare const _internals: {
+    bunSpawn: typeof bunSpawn;
+};
 /**
  * Module-level flag so the warning fires at most once per process.
  * Exported for test reset purposes only — do not use in production code.
@@ -30,6 +42,31 @@ export declare function warnIfSwarmNotGitignored(directory: string, quiet?: bool
 export interface EnsureSwarmGitExcludedOptions {
     quiet?: boolean;
 }
+/**
+ * Hard upper bound on the entire `ensureSwarmGitExcluded` operation when
+ * called from plugin init. The plugin host (OpenCode TUI / Desktop) will
+ * silently drop a plugin whose entry never resolves (issue #704); every
+ * awaited call on the init path therefore has an obligation to be bounded.
+ *
+ * 3_000 ms is ~30× the realistic worst-case duration on a healthy host (all
+ * four `git` calls land in well under 200 ms in aggregate) and ~6× the
+ * per-call budget below. Slower-than-3 s hosts are pathological (NFS-stalled
+ * `.git`, antivirus quarantine) and we deliberately fail-open: a debug log
+ * is emitted and the plugin continues to load without the hygiene exclude.
+ */
+export declare const ENSURE_SWARM_GIT_EXCLUDED_OUTER_TIMEOUT_MS = 3000;
+/**
+ * Hard upper bound on each individual `git` subprocess invoked by
+ * `ensureSwarmGitExcluded` (and reused by `validateDiffScope`). Both Bun's
+ * `Bun.spawn` and the Node fallback in `bunSpawn` honor this `timeout`
+ * option and kill the child on expiry (`bun-compat.ts` Node fallback calls
+ * `proc.kill('SIGKILL')`; Bun kills via `killSignal`).
+ *
+ * 1_500 ms gives a ~30× margin over the realistic worst case and is well
+ * below the outer wrapper budget so the inner kills fire first on a
+ * pathological host.
+ */
+export declare const ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS = 1500;
 /**
  * Automatically protect `.swarm/` from Git pollution before any `.swarm/` write.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.3.3",
+	"version": "7.3.5",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",