opencode-swarm 7.82.2 → 7.84.0

package/dist/cli/knowledge-store-n4x6zyk7.js

@@ -0,0 +1,73 @@
+// @bun
+import {
+  OUTCOME_SIGNAL_SMOOTHING,
+  _internals,
+  appendKnowledge,
+  appendKnowledgeWithCapEnforcement,
+  appendRejectedLesson,
+  appendRetractionRecord,
+  bumpKnowledgeConfidenceBatch,
+  computeConfidence,
+  computeOutcomeSignal,
+  enforceKnowledgeCap,
+  findNearDuplicate,
+  getPlatformConfigDir,
+  inferTags,
+  jaccardBigram,
+  normalize,
+  normalizeEntry,
+  readKnowledge,
+  readRejectedLessons,
+  readRetractionRecords,
+  resolveHiveEventsPath,
+  resolveHiveKnowledgePath,
+  resolveHiveRejectedPath,
+  resolveSwarmKnowledgePath,
+  resolveSwarmRejectedPath,
+  resolveSwarmRetractionsPath,
+  rewriteKnowledge,
+  sweepAgedEntries,
+  sweepStaleTodos,
+  transactFile,
+  transactKnowledge,
+  wordBigrams
+} from "./index-e8pk68cc.js";
+import"./index-fjwwrwr5.js";
+import"./index-jtqkh8jf.js";
+import"./index-bcp79s17.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  wordBigrams,
+  transactKnowledge,
+  transactFile,
+  sweepStaleTodos,
+  sweepAgedEntries,
+  rewriteKnowledge,
+  resolveSwarmRetractionsPath,
+  resolveSwarmRejectedPath,
+  resolveSwarmKnowledgePath,
+  resolveHiveRejectedPath,
+  resolveHiveKnowledgePath,
+  resolveHiveEventsPath,
+  readRetractionRecords,
+  readRejectedLessons,
+  readKnowledge,
+  normalizeEntry,
+  normalize,
+  jaccardBigram,
+  inferTags,
+  getPlatformConfigDir,
+  findNearDuplicate,
+  enforceKnowledgeCap,
+  computeOutcomeSignal,
+  computeConfidence,
+  bumpKnowledgeConfidenceBatch,
+  appendRetractionRecord,
+  appendRejectedLesson,
+  appendKnowledgeWithCapEnforcement,
+  appendKnowledge,
+  _internals,
+  OUTCOME_SIGNAL_SMOOTHING
+};

package/dist/cli/pending-delegations-pz61mrsz.js

@@ -0,0 +1,255 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-ckntc5gf.js";
+import"./index-jtqkh8jf.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import {
+  init_logger,
+  warn
+} from "./index-yx44zd0p.js";
+import {
+  withEvidenceLock
+} from "./index-bcp79s17.js";
+import {
+  exports_external
+} from "./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+
+// src/background/pending-delegations.ts
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
+var STORE_LOCK_AGENT = "background";
+var STORE_LOCK_TASK = "background-delegations";
+var ResultSchema = exports_external.object({
+  text: exports_external.string().optional(),
+  error: exports_external.string().optional(),
+  chars: exports_external.number(),
+  truncated: exports_external.boolean(),
+  digest: exports_external.string()
+}).strict();
+var WorkspaceSchema = exports_external.object({
+  directory: exports_external.string(),
+  gitHead: exports_external.string().nullable(),
+  dirtyHash: exports_external.string().nullable(),
+  prHeadSha: exports_external.string().nullable(),
+  scope: exports_external.string().nullable()
+}).strict();
+var PromptSchema = exports_external.object({
+  text: exports_external.string(),
+  chars: exports_external.number(),
+  truncated: exports_external.boolean(),
+  digest: exports_external.string()
+}).strict();
+var RecordSchema = exports_external.object({
+  schemaVersion: exports_external.union([exports_external.literal(1), exports_external.literal(2)]),
+  correlationId: exports_external.string().min(1),
+  jobId: exports_external.string().nullable(),
+  subagentSessionId: exports_external.string().min(1),
+  parentSessionId: exports_external.string().min(1),
+  callID: exports_external.string(),
+  normalizedAgent: exports_external.string(),
+  swarmPrefixedAgent: exports_external.string(),
+  planTaskId: exports_external.string().nullable(),
+  evidenceTaskId: exports_external.string().nullable(),
+  status: exports_external.enum([
+    "pending",
+    "running",
+    "ingestion_error",
+    "completed",
+    "error",
+    "cancelled",
+    "stale",
+    "consumed"
+  ]),
+  createdAt: exports_external.number(),
+  updatedAt: exports_external.number(),
+  batchId: exports_external.string().optional(),
+  laneId: exports_external.string().optional(),
+  mode: exports_external.string().optional(),
+  promptHash: exports_external.string().optional(),
+  workspace: WorkspaceSchema.optional(),
+  prompt: PromptSchema.optional(),
+  generation: exports_external.number().optional(),
+  result: ResultSchema.optional(),
+  completedAt: exports_external.number().optional()
+}).strict();
+function storePath(directory) {
+  return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_FILE);
+}
+function ensureSwarmDir(directory) {
+  fs.mkdirSync(path.resolve(directory, ".swarm"), { recursive: true });
+}
+function readDelegations(directory) {
+  let raw;
+  try {
+    raw = fs.readFileSync(storePath(directory), "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    warn(`[background] readDelegations failed: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+  const folded = new Map;
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    let parsedJson;
+    try {
+      parsedJson = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const result = RecordSchema.safeParse(parsedJson);
+    if (!result.success)
+      continue;
+    folded.set(result.data.correlationId, result.data);
+  }
+  return [...folded.values()];
+}
+function findByCorrelationId(directory, correlationId) {
+  if (!correlationId)
+    return null;
+  for (const record of readDelegations(directory)) {
+    if (record.correlationId === correlationId)
+      return record;
+  }
+  return null;
+}
+function appendRecord(directory, record) {
+  ensureSwarmDir(directory);
+  fs.appendFileSync(storePath(directory), `${JSON.stringify(record)}
+`, "utf-8");
+}
+async function recordPendingDelegation(directory, input, options = {}) {
+  const now = Date.now();
+  const record = {
+    schemaVersion: input.batchId ? 2 : 1,
+    correlationId: input.correlationId,
+    jobId: input.jobId,
+    subagentSessionId: input.subagentSessionId,
+    parentSessionId: input.parentSessionId,
+    callID: input.callID,
+    normalizedAgent: input.normalizedAgent,
+    swarmPrefixedAgent: input.swarmPrefixedAgent,
+    planTaskId: input.planTaskId,
+    evidenceTaskId: input.evidenceTaskId,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now,
+    ...input.batchId ? { batchId: input.batchId } : {},
+    ...input.laneId ? { laneId: input.laneId } : {},
+    ...input.mode ? { mode: input.mode } : {},
+    ...input.promptHash ? { promptHash: input.promptHash } : {},
+    ...input.workspace ? { workspace: input.workspace } : {},
+    ...input.prompt ? { prompt: input.prompt } : {},
+    ...input.generation !== undefined ? { generation: input.generation } : {}
+  };
+  try {
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      if (options.staleTimeoutMs && options.staleTimeoutMs > 0) {
+        sweepStaleLocked(directory, options.staleTimeoutMs, now);
+      }
+      appendRecord(directory, record);
+    });
+    return record;
+  } catch (err) {
+    warn(`[background] recordPendingDelegation failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function buildPromptSnapshot(text, maxChars) {
+  const boundedMax = Math.max(0, Math.min(maxChars, 20000));
+  const truncated = text.length > boundedMax;
+  const bounded = truncated ? text.slice(0, boundedMax) : text;
+  return {
+    text: bounded,
+    chars: text.length,
+    truncated,
+    digest: createHash("sha256").update(text).digest("hex")
+  };
+}
+async function appendDelegationTransition(directory, correlationId, transition) {
+  const now = Date.now();
+  try {
+    let next = null;
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const current = findByCorrelationId(directory, correlationId);
+      if (!current)
+        return;
+      if (isTerminal(current.status) && transition.status !== "consumed" && transition.status !== "ingestion_error") {
+        next = current;
+        return;
+      }
+      next = {
+        ...current,
+        schemaVersion: current.schemaVersion === 1 ? 2 : current.schemaVersion,
+        status: transition.status,
+        updatedAt: now,
+        ...transition.completedAt !== undefined ? { completedAt: transition.completedAt } : transition.status === "completed" || transition.status === "error" ? { completedAt: now } : {},
+        ...transition.result ? { result: transition.result } : {}
+      };
+      appendRecord(directory, next);
+    });
+    return next;
+  } catch (err) {
+    warn(`[background] appendDelegationTransition failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function findByBatchId(directory, batchId, opts) {
+  if (!batchId)
+    return [];
+  return readDelegations(directory).filter((record) => record.batchId === batchId && (opts?.parentSessionId === undefined || record.parentSessionId === opts.parentSessionId));
+}
+function findOpenAsyncLaneBatches(directory) {
+  return readDelegations(directory).filter((record) => record.batchId !== undefined && (record.status === "pending" || record.status === "running"));
+}
+function isTerminal(status) {
+  return status === "completed" || status === "error" || status === "cancelled" || status === "stale" || status === "consumed";
+}
+function sweepStaleLocked(directory, timeoutMs, now) {
+  let swept = 0;
+  for (const record of readDelegations(directory)) {
+    if (record.status !== "pending" && record.status !== "running" && record.status !== "ingestion_error")
+      continue;
+    if (now - record.updatedAt <= timeoutMs)
+      continue;
+    appendRecord(directory, {
+      ...record,
+      status: "stale",
+      updatedAt: now
+    });
+    swept += 1;
+  }
+  return swept;
+}
+async function sweepStaleDelegations(directory, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0)
+    return 0;
+  try {
+    return await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => sweepStaleLocked(directory, timeoutMs, Date.now()));
+  } catch (err) {
+    warn(`[background] sweepStaleDelegations failed: ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
+export {
+  sweepStaleDelegations,
+  recordPendingDelegation,
+  readDelegations,
+  findOpenAsyncLaneBatches,
+  findByCorrelationId,
+  findByBatchId,
+  buildPromptSnapshot,
+  appendDelegationTransition,
+  BACKGROUND_DELEGATIONS_FILE
+};

package/dist/cli/pr-subscriptions-y1nn36e5.js

@@ -0,0 +1,33 @@
+// @bun
+import {
+  PR_SUBSCRIPTIONS_FILE,
+  buildCorrelationId,
+  listActive,
+  lookupByPr,
+  setOnSubscriptionCreated,
+  subscribe,
+  sweepStale,
+  unsubscribe,
+  updateSnapshot
+} from "./index-eb85wtx9.js";
+import"./index-ckntc5gf.js";
+import"./index-jtqkh8jf.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-bcp79s17.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  updateSnapshot,
+  unsubscribe,
+  sweepStale,
+  subscribe,
+  setOnSubscriptionCreated,
+  lookupByPr,
+  listActive,
+  buildCorrelationId,
+  PR_SUBSCRIPTIONS_FILE
+};

package/dist/cli/schema-c2dbzhm8.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  AdversarialDetectionConfigSchema,
+  AdversarialTestingConfigSchema,
+  AgentAuthorityRuleSchema,
+  AgentOverrideConfigSchema,
+  AgentReasoningConfigSchema,
+  AgentThinkingConfigSchema,
+  ArchitecturalSupervisionConfigSchema,
+  AuthorityConfigSchema,
+  AutoReviewConfigSchema,
+  AutomationCapabilitiesSchema,
+  AutomationConfigSchema,
+  AutomationModeSchema,
+  CheckpointConfigSchema,
+  CompactionAdvisoryConfigSchema,
+  CompactionConfigSchema,
+  ContextBudgetConfigSchema,
+  ContextMapConfigSchema,
+  CouncilConfigSchema,
+  CuratorConfigSchema,
+  DEFAULT_AGENT_PROFILES,
+  DEFAULT_ARCHITECT_PROFILE,
+  DEFAULT_EXTERNAL_SKILLS_CONFIG,
+  DecisionDecaySchema,
+  DesignDocsConfigSchema,
+  DiscoverySourceSchema,
+  DocsConfigSchema,
+  EvidenceConfigSchema,
+  ExternalSkillCandidateEvaluationVerdictSchema,
+  ExternalSkillCandidateSchema,
+  ExternalSkillCandidateSourceTypeSchema,
+  ExternalSkillsConfigSchema,
+  GateConfigSchema,
+  GateFeatureSchema,
+  GeneralCouncilConfigSchema,
+  GuardrailsConfigSchema,
+  GuardrailsProfileSchema,
+  HooksConfigSchema,
+  IncrementalVerifyConfigSchema,
+  IntegrationAnalysisConfigSchema,
+  KnowledgeApplicationConfigSchema,
+  KnowledgeConfigSchema,
+  LeanTurboConfigSchema,
+  LeanTurboStrategyConfigSchema,
+  LintConfigSchema,
+  MemoryConfigSchema,
+  ParallelizationConfigSchema,
+  PhaseCompleteConfigSchema,
+  PipelineConfigSchema,
+  PlaceholderScanConfigSchema,
+  PlanCursorConfigSchema,
+  PluginConfigSchema,
+  PrMonitorConfigSchema,
+  PrmConfigSchema,
+  QualityBudgetConfigSchema,
+  RepoGraphConfigSchema,
+  ReviewPassesConfigSchema,
+  ScoringConfigSchema,
+  ScoringWeightsSchema,
+  SecretscanConfigSchema,
+  SelfReviewConfigSchema,
+  SkillImproverConfigSchema,
+  SkillPropagationConfigSchema,
+  SlopDetectorConfigSchema,
+  SpecWriterConfigSchema,
+  StandardTurboConfigSchema,
+  SummaryConfigSchema,
+  SwarmConfigSchema,
+  TokenRatiosSchema,
+  ToolFilterConfigSchema,
+  TurboConfigSchema,
+  UIReviewConfigSchema,
+  WatchdogConfigSchema,
+  WorktreeIsolationConfigSchema,
+  _internals,
+  getCanonicalAgentRole,
+  isKnownCanonicalRole,
+  resolveExternalSkillsConfig,
+  resolveGeneratedAgentRole,
+  resolveGuardrailsConfig,
+  stripKnownSwarmPrefix
+} from "./index-wg3r6acj.js";
+import"./index-p0arc26j.js";
+import"./index-293f68mj.js";
+import"./index-a76rekgs.js";
+export {
+  stripKnownSwarmPrefix,
+  resolveGuardrailsConfig,
+  resolveGeneratedAgentRole,
+  resolveExternalSkillsConfig,
+  isKnownCanonicalRole,
+  getCanonicalAgentRole,
+  _internals,
+  WorktreeIsolationConfigSchema,
+  WatchdogConfigSchema,
+  UIReviewConfigSchema,
+  TurboConfigSchema,
+  ToolFilterConfigSchema,
+  TokenRatiosSchema,
+  SwarmConfigSchema,
+  SummaryConfigSchema,
+  StandardTurboConfigSchema,
+  SpecWriterConfigSchema,
+  SlopDetectorConfigSchema,
+  SkillPropagationConfigSchema,
+  SkillImproverConfigSchema,
+  SelfReviewConfigSchema,
+  SecretscanConfigSchema,
+  ScoringWeightsSchema,
+  ScoringConfigSchema,
+  ReviewPassesConfigSchema,
+  RepoGraphConfigSchema,
+  QualityBudgetConfigSchema,
+  PrmConfigSchema,
+  PrMonitorConfigSchema,
+  PluginConfigSchema,
+  PlanCursorConfigSchema,
+  PlaceholderScanConfigSchema,
+  PipelineConfigSchema,
+  PhaseCompleteConfigSchema,
+  ParallelizationConfigSchema,
+  MemoryConfigSchema,
+  LintConfigSchema,
+  LeanTurboStrategyConfigSchema,
+  LeanTurboConfigSchema,
+  KnowledgeConfigSchema,
+  KnowledgeApplicationConfigSchema,
+  IntegrationAnalysisConfigSchema,
+  IncrementalVerifyConfigSchema,
+  HooksConfigSchema,
+  GuardrailsProfileSchema,
+  GuardrailsConfigSchema,
+  GeneralCouncilConfigSchema,
+  GateFeatureSchema,
+  GateConfigSchema,
+  ExternalSkillsConfigSchema,
+  ExternalSkillCandidateSourceTypeSchema,
+  ExternalSkillCandidateSchema,
+  ExternalSkillCandidateEvaluationVerdictSchema,
+  EvidenceConfigSchema,
+  DocsConfigSchema,
+  DiscoverySourceSchema,
+  DesignDocsConfigSchema,
+  DecisionDecaySchema,
+  DEFAULT_EXTERNAL_SKILLS_CONFIG,
+  DEFAULT_ARCHITECT_PROFILE,
+  DEFAULT_AGENT_PROFILES,
+  CuratorConfigSchema,
+  CouncilConfigSchema,
+  ContextMapConfigSchema,
+  ContextBudgetConfigSchema,
+  CompactionConfigSchema,
+  CompactionAdvisoryConfigSchema,
+  CheckpointConfigSchema,
+  AutomationModeSchema,
+  AutomationConfigSchema,
+  AutomationCapabilitiesSchema,
+  AutoReviewConfigSchema,
+  AuthorityConfigSchema,
+  ArchitecturalSupervisionConfigSchema,
+  AgentThinkingConfigSchema,
+  AgentReasoningConfigSchema,
+  AgentOverrideConfigSchema,
+  AgentAuthorityRuleSchema,
+  AdversarialTestingConfigSchema,
+  AdversarialDetectionConfigSchema
+};

package/dist/cli/skill-generator-a5ehggyg.js

@@ -0,0 +1,55 @@
+// @bun
+import {
+  DEFAULT_SKILL_MIN_CONFIDENCE,
+  DEFAULT_SKILL_MIN_CONFIRMATIONS,
+  STRONG_SKILL_OUTCOME_COUNT,
+  _internals,
+  activateProposal,
+  activePath,
+  activeRepoRelativePath,
+  autoApplyProposals,
+  clusterEntries,
+  generateSkills,
+  inspectSkill,
+  isSkillMaturityEligible,
+  isValidSlug,
+  listSkills,
+  parseDraftFrontmatter,
+  proposalPath,
+  regenerateSkill,
+  renderSkillMarkdown,
+  retireSkill,
+  sanitizeSlug,
+  selectCandidateEntries
+} from "./index-d9fbxaqd.js";
+import"./index-e8pk68cc.js";
+import"./index-fjwwrwr5.js";
+import"./index-jtqkh8jf.js";
+import"./index-yx44zd0p.js";
+import"./index-bcp79s17.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  selectCandidateEntries,
+  sanitizeSlug,
+  retireSkill,
+  renderSkillMarkdown,
+  regenerateSkill,
+  proposalPath,
+  parseDraftFrontmatter,
+  listSkills,
+  isValidSlug,
+  isSkillMaturityEligible,
+  inspectSkill,
+  generateSkills,
+  clusterEntries,
+  autoApplyProposals,
+  activeRepoRelativePath,
+  activePath,
+  activateProposal,
+  _internals,
+  STRONG_SKILL_OUTCOME_COUNT,
+  DEFAULT_SKILL_MIN_CONFIRMATIONS,
+  DEFAULT_SKILL_MIN_CONFIDENCE
+};

package/dist/cli/task-envelope-qn0qtnh0.js

@@ -0,0 +1,90 @@
+// @bun
+import"./index-a76rekgs.js";
+
+// src/background/task-envelope.ts
+var TASK_ENVELOPE_RE = /<task\s+id="([^"]+)"\s+state="(running|completed|error)"\s*>/;
+var MAX_TASK_ENVELOPE_TEXT_CHARS = 20000;
+function parseTaskEnvelope(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return null;
+  const match = text.match(TASK_ENVELOPE_RE);
+  if (!match)
+    return null;
+  const sessionId = match[1];
+  const state = match[2];
+  if (!sessionId)
+    return null;
+  const summary = extractTagText(text, "summary");
+  const resultRaw = state === "error" ? extractTagText(text, "task_error") : extractTagText(text, "task_result");
+  const bounded = boundEnvelopeText(resultRaw);
+  return {
+    sessionId,
+    state,
+    ...summary !== undefined ? { summary } : {},
+    ...state === "error" && bounded ? {
+      errorText: bounded.text,
+      resultChars: bounded.chars,
+      resultTruncated: bounded.truncated
+    } : {},
+    ...state !== "error" && bounded ? {
+      resultText: bounded.text,
+      resultChars: bounded.chars,
+      resultTruncated: bounded.truncated
+    } : {}
+  };
+}
+function extractTagText(text, tag) {
+  const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`);
+  const match = text.match(re);
+  if (!match)
+    return;
+  return match[1];
+}
+function boundEnvelopeText(text) {
+  if (text === undefined)
+    return;
+  if (text.length <= MAX_TASK_ENVELOPE_TEXT_CHARS) {
+    return { text, chars: text.length, truncated: false };
+  }
+  const omitted = text.length - MAX_TASK_ENVELOPE_TEXT_CHARS;
+  const suffix = `
+[... ${omitted} chars truncated by task-envelope ...]`;
+  const maxContent = Math.max(0, MAX_TASK_ENVELOPE_TEXT_CHARS - suffix.length);
+  return {
+    text: `${text.slice(0, maxContent)}${suffix}`,
+    chars: text.length,
+    truncated: true
+  };
+}
+function extractDispatchIds(output) {
+  let subagentSessionId = null;
+  let jobId = null;
+  if (typeof output === "object" && output !== null) {
+    const o = output;
+    const metadata = o.metadata;
+    if (typeof metadata === "object" && metadata !== null) {
+      const rawJobId = metadata.jobId;
+      if (typeof rawJobId === "string" && rawJobId.length > 0) {
+        jobId = rawJobId;
+      }
+    }
+    const rendered = o.output;
+    const envelope = parseTaskEnvelope(typeof rendered === "string" ? rendered : undefined);
+    if (envelope && envelope.state === "running") {
+      subagentSessionId = envelope.sessionId;
+    }
+  } else if (typeof output === "string") {
+    const envelope = parseTaskEnvelope(output);
+    if (envelope && envelope.state === "running") {
+      subagentSessionId = envelope.sessionId;
+    }
+  }
+  if (!subagentSessionId && jobId) {
+    subagentSessionId = jobId;
+  }
+  return { subagentSessionId, jobId };
+}
+export {
+  parseTaskEnvelope,
+  extractDispatchIds
+};

package/dist/cli/telemetry-9bbyxrvn.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  _internals,
+  addTelemetryListener,
+  emit,
+  initTelemetry,
+  resetTelemetryForTesting,
+  rotateTelemetryIfNeeded,
+  telemetry
+} from "./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  telemetry,
+  rotateTelemetryIfNeeded,
+  resetTelemetryForTesting,
+  initTelemetry,
+  emit,
+  addTelemetryListener,
+  _internals
+};