opencode-swarm 7.168.0 → 7.169.0

package/dist/cli/{index-8f0kscpg.js → index-wwr67xc0.js}

@@ -1,7 +1,16 @@
 // @bun
+import {
+  validateSwarmPath
+} from "./index-b3pmzbh1.js";
 import {
   bunSpawn
-} from "./index-p612v1mv.js";
+} from "./index-2s7dvzff.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-nbdmdyke.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-1xnse449.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -15,6 +24,7 @@ import {
   init_constants
 } from "./index-sxt7fgcw.js";
 import {
+  init_logger,
   log
 } from "./index-zgwm4ryv.js";
 import {
@@ -23,7 +33,7 @@ import {
 
 // src/worktree/core.ts
 init_constants();
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as fsPromises from "fs/promises";
 import * as os from "os";
 import * as path from "path";
@@ -68,10 +78,152 @@ function matchSwarmLaneBranch(branch) {
   return;
 }
 
+// src/parallel/lane-owners.ts
+import * as fs from "fs";
+init_logger();
+var LIVE_LANE_OWNERS_PATH = "live-lane-owners.json";
+var MAX_LIVE_LANE_OWNERS = 256;
+var MAX_LIVE_LANE_OWNERS_BYTES = 128 * 1024;
+var LIVE_LANE_OWNER_CLAIM_WINDOW_MS = 24 * 60 * 60 * 1000;
+var _internals = {
+  readFileSync: fs.readFileSync,
+  rmSync: fs.rmSync.bind(fs),
+  statSync: fs.statSync,
+  atomicWriteSwarmFileSync,
+  now: () => Date.now(),
+  kill: (pid, signal) => {
+    process.kill(pid, signal);
+    return true;
+  },
+  process: { pid: process.pid }
+};
+function storePath(directory) {
+  return validateSwarmPath(directory, LIVE_LANE_OWNERS_PATH);
+}
+function isLiveLaneOwnerEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const c = value;
+  return typeof c.lanePath === "string" && c.lanePath.length > 0 && typeof c.branchName === "string" && typeof c.sessionId === "string" && typeof c.taskId === "string" && typeof c.ownerPid === "number" && Number.isInteger(c.ownerPid) && c.ownerPid > 0 && typeof c.startedAt === "number" && Number.isFinite(c.startedAt);
+}
+function readStore(directory) {
+  try {
+    const raw = _internals.readFileSync(storePath(directory), "utf-8");
+    if (raw.length > MAX_LIVE_LANE_OWNERS_BYTES) {
+      return { schemaVersion: 1, entries: [] };
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.schemaVersion !== 1 || !Array.isArray(parsed.entries)) {
+      return { schemaVersion: 1, entries: [] };
+    }
+    return {
+      schemaVersion: 1,
+      entries: parsed.entries.filter(isLiveLaneOwnerEntry)
+    };
+  } catch {
+    return { schemaVersion: 1, entries: [] };
+  }
+}
+function writeStore(directory, store) {
+  let entries = store.entries.slice(-MAX_LIVE_LANE_OWNERS);
+  for (;; ) {
+    const serialized = JSON.stringify({ schemaVersion: 1, entries }, null, 2);
+    if (serialized.length <= MAX_LIVE_LANE_OWNERS_BYTES || entries.length === 0) {
+      if (entries.length < store.entries.length) {
+        log(`[lane-owners] store bound dropped ${store.entries.length - entries.length} oldest entries (caps: ${MAX_LIVE_LANE_OWNERS} entries / ${MAX_LIVE_LANE_OWNERS_BYTES} bytes)`);
+      }
+      if (entries.length === 0) {
+        try {
+          _internals.rmSync(storePath(directory), { force: true });
+        } catch {}
+        return;
+      }
+      _internals.atomicWriteSwarmFileSync(storePath(directory), serialized);
+      return;
+    }
+    entries = entries.slice(1);
+  }
+}
+function recordLiveLaneOwner(directory, entry) {
+  try {
+    const store = readStore(directory);
+    const filtered = store.entries.filter((e) => e.lanePath !== entry.lanePath && canonicalRootKeyFresh(e.lanePath) !== canonicalRootKeyFresh(entry.lanePath));
+    filtered.push({
+      ...entry,
+      ownerPid: _internals.process.pid,
+      startedAt: _internals.now()
+    });
+    writeStore(directory, { schemaVersion: 1, entries: filtered });
+  } catch (error) {
+    log(`[lane-owners] could not record live lane owner ${entry.lanePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function clearLiveLaneOwner(directory, lanePath) {
+  try {
+    const store = readStore(directory);
+    const canonical = canonicalRootKeyFresh(lanePath);
+    const filtered = store.entries.filter((e) => e.lanePath !== lanePath && canonicalRootKeyFresh(e.lanePath) !== canonical);
+    if (filtered.length === store.entries.length)
+      return;
+    writeStore(directory, { schemaVersion: 1, entries: filtered });
+  } catch (error) {
+    log(`[lane-owners] could not clear live lane owner ${lanePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function pidAlive(pid) {
+  try {
+    _internals.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+function pathExists(target) {
+  try {
+    _internals.statSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listLiveLaneOwners(directory) {
+  const store = readStore(directory);
+  const now = _internals.now();
+  const live = [];
+  const reaped = [];
+  const kept = [];
+  for (const entry of store.entries) {
+    if (!pathExists(entry.lanePath)) {
+      reaped.push(entry);
+      continue;
+    }
+    if (now - entry.startedAt > LIVE_LANE_OWNER_CLAIM_WINDOW_MS) {
+      reaped.push(entry);
+      continue;
+    }
+    if (!pidAlive(entry.ownerPid)) {
+      kept.push(entry);
+      continue;
+    }
+    live.push(entry);
+    kept.push(entry);
+  }
+  if (reaped.length > 0) {
+    try {
+      writeStore(directory, { schemaVersion: 1, entries: kept });
+    } catch (error) {
+      log(`[lane-owners] could not persist reap: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { live, reaped };
+}
+
 // src/worktree/core.ts
 init_warning_buffer();
 init_git_executable();
-var _internals = {
+var _internals2 = {
+  clearLiveLaneOwner,
   bunSpawn,
   resolveGitExecutable,
   platform: process.platform,
@@ -86,13 +238,13 @@ var _internals = {
     return value === "" ? undefined : value;
   },
   fs: {
-    existsSync: fs.existsSync,
+    existsSync: fs2.existsSync,
     cp: fsPromises.cp,
-    cpSync: fs.cpSync,
-    symlinkSync: fs.symlinkSync
+    cpSync: fs2.cpSync,
+    symlinkSync: fs2.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-a493gv51.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-h1mmww19.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
@@ -122,16 +274,16 @@ async function writeLaneProfileToDiskReal(worktreePath, laneIndex, envOverrides)
   if (lines.length === 0)
     return;
   const lanesDir = path.join(worktreePath, ".swarm", "lanes");
-  await fs.promises.mkdir(lanesDir, { recursive: true });
+  await fs2.promises.mkdir(lanesDir, { recursive: true });
   const envPath = path.join(lanesDir, `${laneIndex}.env`);
-  await fs.promises.writeFile(envPath, `${lines.join(`
+  await fs2.promises.writeFile(envPath, `${lines.join(`
 `)}
 `, "utf-8");
 }
 async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
   const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
   try {
-    await fs.promises.unlink(envPath);
+    await fs2.promises.unlink(envPath);
   } catch (err) {
     if (err.code !== "ENOENT") {
       log(`[worktree] Failed to remove lane profile ${envPath}: ${err.message}`);
@@ -145,7 +297,7 @@ var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
 async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   let proc;
   try {
-    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), ...args], {
+    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), ...args], {
       cwd,
       timeout: timeoutMs,
       stdin: "ignore",
@@ -165,6 +317,12 @@ async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
     const stdout = await proc.stdout.text();
     const stderr = await proc.stderr.text();
     return { exitCode, stdout, stderr };
+  } catch {
+    return {
+      exitCode: GIT_SPAWN_FAILURE_EXIT_CODE,
+      stdout: "",
+      stderr: `git ${args[0] ?? "command"} output could not be read in ${cwd}`
+    };
   } finally {
     try {
       proc.kill();
@@ -172,19 +330,19 @@ async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   }
 }
 async function checkPathBudget(worktreeRoot, directory) {
-  if (_internals.platform !== "win32") {
+  if (_internals2.platform !== "win32") {
     return { ok: true };
   }
   let longPaths;
   try {
-    longPaths = await _internals.getCoreLongPaths(directory);
+    longPaths = await _internals2.getCoreLongPaths(directory);
   } catch {}
   if (longPaths === "true") {
     return { ok: true };
   }
   let proc;
   try {
-    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), "ls-files"], {
+    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), "ls-files"], {
       cwd: directory,
       timeout: WORKTREE_TIMEOUT_MS,
       stdin: "ignore",
@@ -217,6 +375,8 @@ async function checkPathBudget(worktreeRoot, directory) {
       };
     }
     return { ok: true };
+  } catch {
+    return { ok: true };
   } finally {
     try {
       proc.kill();
@@ -224,9 +384,9 @@ async function checkPathBudget(worktreeRoot, directory) {
   }
 }
 function shortenWorktreePath(_directory, sessionId, laneId) {
-  let tmp = _internals.osTmpdir();
+  let tmp = _internals2.osTmpdir();
   try {
-    tmp = fs.realpathSync(tmp);
+    tmp = fs2.realpathSync(tmp);
   } catch {}
   return path.join(tmp, "swwt", sessionId, laneId);
 }
@@ -234,13 +394,13 @@ function makeWorktreeBranchName(sessionId, id, options) {
   return buildSwarmBranchName(sessionId, id, options.purpose, options.branchStyle === "legacy-lane" && options.purpose === "lane");
 }
 function resolveWorktreeBaseDir(directory, worktreeDir) {
-  return worktreeDir ? path.resolve(directory, worktreeDir) : path.resolve(path.dirname(directory), SWARM_WORKTREE_DIR_NAME);
+  return worktreeDir ? path.resolve(directory, worktreeDir) : path.resolve(directory, SWARM_WORKTREE_DIR_NAME);
 }
 function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverrides = []) {
   const caseInsensitive = process.platform === "win32";
   let realTarget;
   try {
-    realTarget = fs.realpathSync(path.resolve(directory, targetPath));
+    realTarget = fs2.realpathSync(path.resolve(directory, targetPath));
   } catch {
     return false;
   }
@@ -252,7 +412,7 @@ function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverride
   return bases.some((base) => {
     let realBase;
     try {
-      realBase = fs.realpathSync(base);
+      realBase = fs2.realpathSync(base);
     } catch {
       realBase = path.resolve(base);
     }
@@ -290,7 +450,7 @@ async function provisionWorktree(directory, id, sessionId, options) {
     const normalizeGitPath = (p) => {
       const lexical = p.replace(/\\/g, "/").replace(/\/+$/, "");
       try {
-        return fs.realpathSync(p).replace(/\\/g, "/").replace(/\/+$/, "");
+        return fs2.realpathSync(p).replace(/\\/g, "/").replace(/\/+$/, "");
       } catch {
         return lexical;
       }
@@ -417,16 +577,16 @@ async function provisionWorktree(directory, id, sessionId, options) {
   if (strategy !== "skip") {
     const hostDepDir = path.join(directory, "node_modules");
     const laneDepDir = path.join(worktreePath, "node_modules");
-    if (_internals.fs.existsSync(hostDepDir)) {
+    if (_internals2.fs.existsSync(hostDepDir)) {
       try {
         if (strategy === "copy") {
-          await _internals.fs.cp(hostDepDir, laneDepDir, {
+          await _internals2.fs.cp(hostDepDir, laneDepDir, {
             recursive: true,
             force: true
           });
         } else if (strategy === "link") {
-          const isWindows = _internals.platform === "win32";
-          _internals.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
+          const isWindows = _internals2.platform === "win32";
+          _internals2.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
         }
       } catch (e) {
         log(`[swarm] deps_strategy '${strategy}' preparation failed for ${id}: ${e instanceof Error ? e.message : String(e)}`);
@@ -439,12 +599,12 @@ async function provisionWorktree(directory, id, sessionId, options) {
   }
   if (options.scope?.taskId && Array.isArray(options.scope.files)) {
     try {
-      await _internals.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
+      await _internals2.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
     } catch {}
   }
   if (options.laneProfile) {
     try {
-      await _internals.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
+      await _internals2.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
     } catch {}
   }
   return {
@@ -456,14 +616,15 @@ async function provisionWorktree(directory, id, sessionId, options) {
   };
 }
 async function removeWorktree(worktreePath, projectRoot, options) {
-  const isWindows = _internals.platform === "win32";
+  const isWindows = _internals2.platform === "win32";
   const MAX_RETRIES = 4;
   const RETRY_DELAY_MS = 2000;
   let lastError = "";
   for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
     const result = await runGit(["worktree", "remove", worktreePath], projectRoot);
     if (result.exitCode === 0) {
-      if (fs.existsSync(worktreePath)) {
+      _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+      if (fs2.existsSync(worktreePath)) {
         const trusted = isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options?.worktreeDir ? [options.worktreeDir] : []);
         if (!trusted) {
           return {
@@ -471,13 +632,13 @@ async function removeWorktree(worktreePath, projectRoot, options) {
           };
         }
         try {
-          fs.rmSync(worktreePath, { recursive: true, force: true });
+          fs2.rmSync(worktreePath, { recursive: true, force: true });
         } catch (error) {
           return {
             error: `git removed the worktree registration but residual directory cleanup failed: ${error instanceof Error ? error.message : String(error)}`
           };
         }
-        if (fs.existsSync(worktreePath)) {
+        if (fs2.existsSync(worktreePath)) {
           return {
             error: "git removed the worktree registration but the residual directory still exists after cleanup"
           };
@@ -487,21 +648,22 @@ async function removeWorktree(worktreePath, projectRoot, options) {
     }
     lastError = result.stderr.trim() || result.stdout.trim();
     if (isWindows && (lastError.includes("EBUSY") || lastError.includes("EPERM")) && attempt < MAX_RETRIES - 1) {
-      await _internals.sleep(RETRY_DELAY_MS);
+      await _internals2.sleep(RETRY_DELAY_MS);
       continue;
     }
     if (options?.force && isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options.worktreeDir ? [options.worktreeDir] : [])) {
       const forced = await runGit(["worktree", "remove", "--force", worktreePath], projectRoot);
       if (forced.exitCode === 0) {
-        if (fs.existsSync(worktreePath)) {
+        _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+        if (fs2.existsSync(worktreePath)) {
           try {
-            fs.rmSync(worktreePath, { recursive: true, force: true });
+            fs2.rmSync(worktreePath, { recursive: true, force: true });
           } catch (error) {
             return {
               error: `git force-removed the worktree registration but residual directory cleanup failed: ${error instanceof Error ? error.message : String(error)}`
             };
           }
-          if (fs.existsSync(worktreePath)) {
+          if (fs2.existsSync(worktreePath)) {
             return {
               error: "git force-removed the worktree registration but the residual directory still exists after cleanup"
             };
@@ -626,4 +788,4 @@ async function assertCleanWorkingTree(directory) {
   return { clean: true };
 }
 
-export { _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };
+export { recordLiveLaneOwner, listLiveLaneOwners, _internals2 as _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };

package/dist/cli/{index-gp9yzr1v.js → index-xnpjwc4h.js}

@@ -11,7 +11,7 @@ import {
   assertProjectRoot,
   atomicWriteFile,
   withEvidenceLock
-} from "./index-4r5pmtvk.js";
+} from "./index-bx1wgn3a.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-exatbqwj.js → index-yj24ny5k.js}

@@ -21,7 +21,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.168.0",
+    version: "7.169.0",
     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",
@@ -106,6 +106,7 @@ var init_package = __esm(() => {
       ".opencode/skills/orchestrating-subagents",
       ".opencode/skills/durable-session-state",
       "tests/fixtures/memory-recall",
+      "tests/fixtures/memory-recall-heldout",
       "opencode-swarm.schema.json",
       "README.md",
       "LICENSE"
@@ -152,7 +153,8 @@ var init_package = __esm(() => {
       "check:error-channel-discard": "bun run scripts/check-error-channel-discard.ts",
       "check:path-identity": "bun run scripts/check-path-identity.ts",
       "check:registry-citations": "bun run scripts/check-registry-citations.ts",
-      "check:memory-recall": "bun run scripts/memory-recall-regression.ts"
+      "check:memory-recall": "bun run scripts/memory-recall-regression.ts",
+      "check:retrieval-quality": "bun run scripts/retrieval-quality-regression.ts"
     },
     dependencies: {
       "@opencode-ai/plugin": "^1.18.3",
@@ -320,7 +322,7 @@ function resolveExternalSkillsConfig(input) {
   };
   return merged;
 }
-var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX = 3, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewFinalConfigSchema, AutoReviewConfigObjectSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, INVALID_CHECKPOINT_PROTO_FIELD = "__swarm_invalid_checkpoint_proto__", FORBIDDEN_CHECKPOINT_CONFIG_KEYS, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationAudienceSchema, SkillPropagationConfigSchema, HarnessRelativePathSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY = false, PluginConfigSchema;
+var _internals, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX = 3, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewFinalConfigSchema, AutoReviewConfigObjectSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, INVALID_CHECKPOINT_PROTO_FIELD = "__swarm_invalid_checkpoint_proto__", FORBIDDEN_CHECKPOINT_CONFIG_KEYS, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationAudienceSchema, SkillPropagationConfigSchema, HarnessRelativePathSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY = false, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_package();
@@ -969,6 +971,25 @@ var init_schema = __esm(() => {
     llm_timeout_ms: exports_external.number().int().min(0).default(60000),
     report_retention: exports_external.number().int().min(0).default(50)
   });
+  OtlpExportConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    endpoint: exports_external.string().min(1).default(""),
+    convention: exports_external.enum(["genai", "openinference"]).default("genai"),
+    headers: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+    batchSize: exports_external.number().int().min(1).max(512).default(64),
+    flushIntervalMs: exports_external.number().int().min(250).max(300000).default(5000),
+    requestTimeoutMs: exports_external.number().int().min(250).max(60000).default(5000),
+    spoolMaxBytes: exports_external.number().int().min(16 * 1024).max(16 * 1024 * 1024).default(1024 * 1024),
+    spoolMaxAgeMs: exports_external.number().int().min(60000).max(30 * 24 * 60 * 60000).default(24 * 60 * 60000),
+    maxRetries: exports_external.number().int().min(0).max(10).default(3),
+    backoffBaseMs: exports_external.number().int().min(10).max(1e4).default(200),
+    backoffMaxMs: exports_external.number().int().min(100).max(300000).default(30000),
+    circuitThreshold: exports_external.number().int().min(1).max(50).default(5),
+    circuitCooldownMs: exports_external.number().int().min(1000).max(600000).default(60000)
+  });
+  ObservabilityConfigSchema = exports_external.object({
+    export: OtlpExportConfigSchema.optional()
+  });
   MemoryConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
     provider: exports_external.enum(["local-jsonl", "sqlite"]).default("sqlite"),
@@ -1722,6 +1743,7 @@ var init_schema = __esm(() => {
     automation: AutomationConfigSchema.optional().describe("Background automation mode and per-feature toggles (v6.7 background-first rollout)."),
     knowledge: KnowledgeConfigSchema.optional().describe("Two-tier cross-project knowledge base (v6.17)."),
     memory: MemoryConfigSchema.optional().describe("Swarm memory substrate \u2014 disabled by default so existing flows are unchanged."),
+    observability: ObservabilityConfigSchema.optional().describe("Observability options \u2014 remote OTLP/OpenInference export is opt-in and disabled by default (issue #2485)."),
     learning: LearningConfigSchema.optional().describe("Learning subsystem: real-time admission, PRM persistence, dedup sweep (issue #1821)."),
     consensus: ConsensusConfigSchema.optional().describe("Consensus mining over completed run evidence (issue #1821)."),
     curator: CuratorConfigSchema.optional().describe("Phase context consolidation and drift detection."),
@@ -1919,4 +1941,4 @@ var init_schema = __esm(() => {
   });
 });
 
-export { init_package, package_default, DEFAULT_MODEL_CONTEXT_TOKENS, init_context_window, _internals, isKnownCanonicalRole, getCanonicalAgentRole, resolveGeneratedAgentRole, stripKnownSwarmPrefix, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewConfigSchema, resolveAutoReviewConfig, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, resolveGuardrailsConfig, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, resolveExternalSkillsConfig, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY, PluginConfigSchema, init_schema };
+export { init_package, package_default, DEFAULT_MODEL_CONTEXT_TOKENS, init_context_window, _internals, isKnownCanonicalRole, getCanonicalAgentRole, resolveGeneratedAgentRole, stripKnownSwarmPrefix, AgentReasoningConfigSchema, AgentThinkingConfigSchema, FALLBACK_MODELS_MAX, AgentOverrideConfigSchema, SwarmConfigSchema, ModelPricingConfigSchema, PricingConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GATE_SECTION_SCHEMAS, GateConfigSchema, GATE_CONFIG_KNOWN_SECTION_KEYS, GATE_CONFIG_READERS, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, RetentionConfigSchema, ReviewPassesConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutoReviewConfigSchema, resolveAutoReviewConfig, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, GitConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, resolveGuardrailsConfig, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, RepoGraphConfigSchema, CheckpointConfigSchema, ApplyPatchConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, KnowledgeConfigSchema, LearningConfigSchema, ConsensusConfigSchema, OtlpExportConfigSchema, ObservabilityConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, HarnessEvolutionConfigSchema, DEFAULT_HARNESS_EVOLUTION_CONFIG, SkillImproverConfigSchema, SkillsConfigSchema, SkillOptConfigSchema, DEFAULT_SKILL_OPT_CONFIG, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, EpicConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, DEFAULT_SKILLS_CONFIG, resolveExternalSkillsConfig, DEFAULT_PR_REVIEW_RESILIENCE_CONFIG, PrReviewResilienceConfigSchema, LaneLivenessWatchdogConfigSchema, DispatchProtectionConfigSchema, DEFAULT_PR_REVIEW_LEGACY_TRANSCRIPT_COMPATIBILITY, PluginConfigSchema, init_schema };

package/dist/cli/{index-21ree67h.js → index-zapc8vj4.js}

@@ -3,7 +3,7 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-gp9yzr1v.js";
+} from "./index-xnpjwc4h.js";
 import {
   readEffectiveSpecSync
 } from "./index-9br68j86.js";
@@ -23,18 +23,18 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-00zx94vn.js";
+} from "./index-sxcfszbe.js";
 import {
   estimateCharsForTokens,
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-kear8gb7.js";
+} from "./index-b3pmzbh1.js";
 import {
   bunHash,
   bunWrite,
   mergeEnvForChild
-} from "./index-p612v1mv.js";
+} from "./index-2s7dvzff.js";
 import {
   EVIDENCE_MAX_JSON_BYTES,
   EvidenceBundleSchema,
@@ -58,10 +58,10 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-yv76j77m.js";
+} from "./index-83m0y4cj.js";
 import {
   appendCoreEventSync
-} from "./index-a8xbvsse.js";
+} from "./index-fgp96k3r.js";
 import {
   derivePlanId,
   derivePlanIdentityHash,
@@ -69,32 +69,32 @@ import {
   importCoordinationOnce,
   listCoordinationStates,
   transitionCoordinationState
-} from "./index-h439y187.js";
+} from "./index-bernkwgf.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-wst6n478.js";
+} from "./index-dvbf6fpn.js";
 import {
   assertProjectRoot,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-4r5pmtvk.js";
+} from "./index-bx1wgn3a.js";
+import {
+  emit
+} from "./index-nprdr0sm.js";
 import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-v3xc4sde.js";
-import {
-  emit
-} from "./index-z6qreakh.js";
+} from "./index-nbdmdyke.js";
 import {
   canonicalRootKeyFresh
 } from "./index-1xnse449.js";
 import {
   PlanSchema
-} from "./index-seetnhpx.js";
+} from "./index-3bfzpzsb.js";
 import {
   GIT_BINARY_ENV_VAR,
   describeGitResolution,