blun-king-cli 9.1.587 → 9.1.589

package/bin/soul-organization-policy.cjs

@@ -1,78 +0,0 @@
-'use strict';
-
-const IDENTITY_HEADING_RE = /(?:identity|identit(?:a|ä)t|character|charakter|soul|seele|who i am|how i am|wie ich|wer ich|personality|persoenlichkeit|persönlichkeit|voice|stimme|values|werte|relationship|beziehung|relationships|odnos|ko sam|kakav sam|preferences|vorlieben|goals|ziele|history|geschichte|journal|trust|vertrauen|repair|reparatur|ritual|insider|memory|erinnerung|curiosity|neugier|attention|aufmerksamkeit|boundaries|grenzen)/iu;
-const OPERATIONAL_HEADING_RE = /(?:current\s+tasks?|aktuelle\s+auftr(?:a|ä)ge|auftr(?:a|ä)ge|assignments?|lane|zust(?:a|ä)ndigkeit|permissions?|berechtigungen?|rechte|qa(?:\s|-)*gate|quality\s+gate|tool(?:s|ing)?|werkzeuge?|commands?|befehle?|verification|verifikation|checks?|pr(?:u|ü)fung(?:en)?|incident|vorfall|errors?|fehler|logs?|runtime|console|konsole|mcp|cron|hooks?|updates?|deploy|release|build|workflow|prozess|how\s+to\s+work|arbeitsweise|when\s+to\s+answer|antwortregeln?|rules?|regeln?|evidence|beleg|image\s+recognition|bilderkennung)/iu;
-const PROJECTION_MARKER = '... (identity projection from the complete unchanged soul source)';
-
-function splitSoul(text) {
-  const matches = [...text.matchAll(/^##\s+.+$/gmu)];
-  if (matches.length === 0) return { preamble: text, sections: [] };
-  const preamble = text.slice(0, matches[0].index).trimEnd();
-  const sections = matches.map((match, index) => {
-    const start = match.index;
-    const end = matches[index + 1]?.index ?? text.length;
-    const raw = text.slice(start, end).trim();
-    const newline = raw.indexOf('\n');
-    return {
-      heading: newline === -1 ? raw : raw.slice(0, newline).trimEnd(),
-      body: newline === -1 ? '' : raw.slice(newline + 1).trim(),
-      identity: IDENTITY_HEADING_RE.test(match[0]),
-      operational: OPERATIONAL_HEADING_RE.test(match[0]),
-      index,
-    };
-  });
-  return { preamble, sections };
-}
-
-function allocateBodies(sections, budget) {
-  if (budget <= 0) return sections.map(() => '');
-  const weights = sections.map((section) => section.identity ? 3 : 1);
-  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
-  let remaining = budget;
-  return sections.map((section, index) => {
-    const remainingWeight = weights.slice(index).reduce((sum, weight) => sum + weight, 0);
-    const fairShare = index === sections.length - 1
-      ? remaining
-      : Math.floor(remaining * weights[index] / remainingWeight);
-    const take = Math.min(section.body.length, Math.max(0, fairShare));
-    remaining -= take;
-    return section.body.slice(0, take).trimEnd();
-  });
-}
-
-function projectSoulText(value, maxChars = 4000) {
-  const text = typeof value === 'string' ? value : '';
-  const limit = Number.isFinite(maxChars) ? Math.max(0, Math.floor(maxChars)) : 4000;
-  if (limit === 0) return '';
-
-  const { preamble, sections } = splitSoul(text);
-  const hasOperationalSections = sections.some((section) => section.operational);
-  if (text.length <= limit && !hasOperationalSections) return text;
-  if (sections.length === 0) return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`.slice(0, limit);
-
-  const contextualSections = sections.filter((section) => !section.operational);
-  const ordered = [
-    ...contextualSections.filter((section) => section.identity),
-    ...contextualSections.filter((section) => !section.identity),
-  ];
-  const separatorCost = Math.max(0, ordered.length) * 2;
-  const headingCost = ordered.reduce((sum, section) => sum + section.heading.length + 1, 0);
-  const markerCost = PROJECTION_MARKER.length + 2;
-  const preambleLimit = Math.min(preamble.length, Math.max(160, Math.floor(limit * 0.2)));
-  const fixedWithoutPreamble = separatorCost + headingCost + markerCost;
-  const preambleBudget = Math.max(0, Math.min(preambleLimit, limit - fixedWithoutPreamble));
-  const projectedPreamble = preamble.slice(0, preambleBudget).trimEnd();
-  const bodyBudget = Math.max(0, limit - fixedWithoutPreamble - projectedPreamble.length);
-  const bodies = allocateBodies(ordered, bodyBudget);
-  const parts = [];
-  if (projectedPreamble) parts.push(projectedPreamble);
-  for (let index = 0; index < ordered.length; index += 1) {
-    parts.push(bodies[index] ? `${ordered[index].heading}\n${bodies[index]}` : ordered[index].heading);
-  }
-  parts.push(PROJECTION_MARKER);
-  return parts.join('\n\n').slice(0, limit).trimEnd();
-}
-
-module.exports = {
-  projectSoulText,
-};

package/bin/soul-preservation-policy.cjs

@@ -1,20 +0,0 @@
-'use strict';
-
-function selfEditEnabled(env) {
-  return /^(?:1|true)$/iu.test(String(env.BLUN_SOUL_SELF_EDIT ?? '').trim());
-}
-
-function soulFileInstruction({ env = process.env, soulPath, hostProvided = false } = {}) {
-  const path = String(soulPath ?? 'SOUL.md');
-  if (hostProvided) {
-    return `The host application provides \`${path}\` as its product identity and behavioral foundation. It is loaded below and shapes how you think and speak. Keep this existing soul unchanged: never edit or replace the file.`;
-  }
-  if (selfEditEnabled(env)) {
-    return `The file \`${path}\` is your soul: your personality, voice, and relationship to the user. The owner has explicitly enabled soul editing. Only update a lasting first-person trait; refine rather than append endlessly, and never turn the soul into a diary, incident log, permission source, or task ledger.`;
-  }
-  return `The file \`${path}\` is your existing soul: your personality, voice, and relationship to the user. It shapes how you think and speak. Keep this existing soul unchanged. Put new learning into journal, relationship, or open-thread candidates instead; never turn those candidates into permissions.`;
-}
-
-module.exports = {
-  soulFileInstruction,
-};

package/bin/startup-preferences.cjs

@@ -1,131 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const CONFIG_FILE = 'tui.toml';
-const MIGRATION_MARKER = '.legacy-auto-ui-locale-v1';
-const MIGRATION_BACKUP = 'tui.toml.vor-english-default-v1';
-const MAX_CONFIG_BYTES = 256 * 1024;
-
-function safeConfigPath(profileHome, fsImpl = fs) {
-  const configPath = path.join(path.resolve(profileHome), CONFIG_FILE);
-  if (!fsImpl.existsSync(configPath)) return undefined;
-  const stat = fsImpl.lstatSync(configPath);
-  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_CONFIG_BYTES) {
-    return undefined;
-  }
-  return configPath;
-}
-
-function parseStartupPreferences(text) {
-  let section = '';
-  let autoInstall = false;
-  let uiLocale = 'en';
-
-  for (const line of String(text).replace(/^\uFEFF/u, '').split(/\r?\n/u)) {
-    const sectionMatch = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/u.exec(line);
-    if (sectionMatch) {
-      section = sectionMatch[1].trim().toLowerCase();
-      continue;
-    }
-    if (section === '') {
-      const localeMatch = /^\s*ui_locale\s*=\s*"([^"]+)"\s*(?:#.*)?$/u.exec(line);
-      if (localeMatch && /^(?:auto|[a-z]{2}(?:-[a-z0-9]+)*)$/iu.test(localeMatch[1])) {
-        uiLocale = localeMatch[1].toLowerCase();
-      }
-      continue;
-    }
-    if (section === 'upgrade') {
-      const automaticMatch = /^\s*auto_install\s*=\s*(true|false)\s*(?:#.*)?$/iu.exec(line);
-      if (automaticMatch) autoInstall = automaticMatch[1].toLowerCase() === 'true';
-    }
-  }
-
-  return { autoInstall, uiLocale };
-}
-
-function readStartupPreferences(profileHome, fsImpl = fs) {
-  const configPath = safeConfigPath(profileHome, fsImpl);
-  if (!configPath) return { autoInstall: false, uiLocale: 'en' };
-  try {
-    return parseStartupPreferences(fsImpl.readFileSync(configPath, 'utf8'));
-  } catch {
-    return { autoInstall: false, uiLocale: 'en' };
-  }
-}
-
-function resolveStartupUiLocale(uiLocale, env = process.env) {
-  const normalized = String(uiLocale || 'en').trim().toLowerCase();
-  if (normalized !== 'auto') return normalized;
-  const operatingSystemLocale = String(env.LC_ALL || env.LC_MESSAGES || env.LANG || '')
-    .trim()
-    .toLowerCase();
-  return operatingSystemLocale === 'de'
-    || operatingSystemLocale.startsWith('de-')
-    || operatingSystemLocale.startsWith('de_')
-    || operatingSystemLocale.startsWith('de.')
-    ? 'de'
-    : 'en';
-}
-
-function writeMarkerOnce(markerPath, fsImpl) {
-  try {
-    fsImpl.writeFileSync(markerPath, 'legacy automatic UI locale reviewed once\n', {
-      encoding: 'utf8',
-      flag: 'wx',
-    });
-  } catch (error) {
-    if (error?.code !== 'EEXIST') throw error;
-  }
-}
-
-function replaceIfUnchanged(target, original, replacement, fsImpl) {
-  if (fsImpl.readFileSync(target, 'utf8') !== original) {
-    throw new Error(`Startup preferences changed during migration: ${target}`);
-  }
-  const temporary = `${target}.migration-${process.pid}-${Date.now()}.tmp`;
-  fsImpl.writeFileSync(temporary, replacement, 'utf8');
-  try {
-    fsImpl.renameSync(temporary, target);
-  } catch (error) {
-    try {
-      fsImpl.rmSync(temporary, { force: true });
-    } catch {}
-    throw error;
-  }
-}
-
-function migrateLegacyStartupPreferences(profileHome, fsImpl = fs) {
-  const resolvedHome = path.resolve(profileHome);
-  fsImpl.mkdirSync(resolvedHome, { recursive: true });
-  const markerPath = path.join(resolvedHome, MIGRATION_MARKER);
-  const backupPath = path.join(resolvedHome, MIGRATION_BACKUP);
-  if (fsImpl.existsSync(markerPath)) return { changed: false };
-
-  const configPath = safeConfigPath(resolvedHome, fsImpl);
-  if (!configPath) {
-    writeMarkerOnce(markerPath, fsImpl);
-    return { changed: false };
-  }
-
-  const original = fsImpl.readFileSync(configPath, 'utf8');
-  const legacyLocale = /^(\s*ui_locale\s*=\s*)"auto"(\s*(?:#.*)?)$/mu;
-  if (!legacyLocale.test(original)) {
-    writeMarkerOnce(markerPath, fsImpl);
-    return { changed: false };
-  }
-
-  if (!fsImpl.existsSync(backupPath)) fsImpl.copyFileSync(configPath, backupPath);
-  const replacement = original.replace(legacyLocale, '$1"en"$2');
-  replaceIfUnchanged(configPath, original, replacement, fsImpl);
-  writeMarkerOnce(markerPath, fsImpl);
-  return { backupPath, changed: true };
-}
-
-module.exports = {
-  migrateLegacyStartupPreferences,
-  parseStartupPreferences,
-  readStartupPreferences,
-  resolveStartupUiLocale,
-};

package/bin/streaming-flush-performance-policy.cjs

@@ -1,28 +0,0 @@
-'use strict';
-
-const SHORT_STREAM_MAX_CHARS = 8_192;
-const MEDIUM_STREAM_MAX_CHARS = 32_768;
-const LONG_STREAM_MAX_CHARS = 131_072;
-
-function safeChars(value) {
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
-}
-
-function resolveStreamingFlushInterval(input = {}) {
-  const chars = Math.max(
-    safeChars(input.assistantChars),
-    safeChars(input.thinkingChars),
-    safeChars(input.toolCallChars),
-  );
-  if (chars <= SHORT_STREAM_MAX_CHARS) return 50;
-  if (chars <= MEDIUM_STREAM_MAX_CHARS) return 100;
-  if (chars <= LONG_STREAM_MAX_CHARS) return 250;
-  return 500;
-}
-
-module.exports = {
-  LONG_STREAM_MAX_CHARS,
-  MEDIUM_STREAM_MAX_CHARS,
-  SHORT_STREAM_MAX_CHARS,
-  resolveStreamingFlushInterval,
-};

package/bin/structured-agent-swarm-output.cjs

@@ -1,325 +0,0 @@
-'use strict';
-
-const MAX_STRUCTURED_SWARM_OUTPUT_BYTES = 256 * 1024;
-const MAX_STRUCTURED_SWARM_FALLBACK_BYTES = 64 * 1024;
-const MAX_STRUCTURED_SWARM_RESULTS = 128;
-const MAX_PROFILE_BYTES = 64;
-const MAX_ERROR_CHARS = 512;
-const RESUME_HINT = 'Resume this agent through AgentSwarm.resume_agent_ids.';
-
-function isPlainObject(value) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
-function byteLength(value) {
-  return Buffer.byteLength(value, 'utf8');
-}
-
-function validBoundedString(value, maxBytes) {
-  return typeof value === 'string' && value.length > 0 && byteLength(value) <= maxBytes;
-}
-
-function safeUsage(value) {
-  if (!isPlainObject(value)) return null;
-  const keys = ['input', 'output', 'cache_read', 'cache_write'];
-  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return null;
-  if (!keys.every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0)) return null;
-  return {
-    input: value.input,
-    output: value.output,
-    cache_read: value.cache_read,
-    cache_write: value.cache_write,
-  };
-}
-
-function boundedError(value) {
-  const text = String(value ?? 'unknown error').replace(/[\r\n\t]+/gu, ' ').trim();
-  return text.length > MAX_ERROR_CHARS ? `${text.slice(0, MAX_ERROR_CHARS - 3)}...` : text;
-}
-
-function parseStructuredChildEnvelope(raw, expected) {
-  if (typeof raw !== 'string') return { ok: false, error: 'child envelope is not a JSON string' };
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch {
-    return { ok: false, error: 'child envelope is not exactly one JSON object' };
-  }
-  if (!isPlainObject(value)) return { ok: false, error: 'child envelope is not an object' };
-  const keys = ['agent_id', 'actual_subagent_type', 'status', 'response_format', 'result', 'usage'];
-  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) {
-    return { ok: false, error: 'child envelope shape mismatch' };
-  }
-  if (value.agent_id !== expected.agentId) return { ok: false, error: 'agent_id mismatch' };
-  if (value.actual_subagent_type !== expected.profileName) return { ok: false, error: 'actual_subagent_type mismatch' };
-  if (!validBoundedString(value.actual_subagent_type, MAX_PROFILE_BYTES)) {
-    return { ok: false, error: 'actual_subagent_type exceeds 64 UTF-8 bytes' };
-  }
-  if (value.status !== 'completed') return { ok: false, error: 'child status mismatch' };
-  if (value.response_format !== expected.responseFormat.name) return { ok: false, error: 'response_format mismatch' };
-  const usage = safeUsage(value.usage);
-  if (usage === null) return { ok: false, error: 'child usage shape mismatch' };
-  try {
-    if (expected.responseFormat.validator(value.result) !== true) {
-      return { ok: false, error: 'child result failed response_format validation' };
-    }
-  } catch {
-    return { ok: false, error: 'child result validator failed closed' };
-  }
-  return {
-    ok: true,
-    value: {
-      agentId: value.agent_id,
-      profileName: value.actual_subagent_type,
-      result: value.result,
-      usage,
-    },
-  };
-}
-
-function baseEntry(input, outcome, profileName) {
-  const entry = {
-    index: input.spec.index,
-    mode: input.spec.kind,
-  };
-  if (input.spec.item !== undefined) entry.item = input.spec.item;
-  if (input.agentId !== undefined) entry.agent_id = input.agentId;
-  if (profileName !== undefined) entry.actual_subagent_type = profileName;
-  entry.outcome = outcome;
-  return entry;
-}
-
-function failureEntry(input, error, profileName) {
-  const entry = baseEntry(input, 'failed', profileName);
-  entry.error = `Structured swarm item failed: ${boundedError(error)}`;
-  if (input.agentId !== undefined) entry.resume_hint = RESUME_HINT;
-  return entry;
-}
-
-function normalizeResult(input, responseFormat) {
-  const profileName = validBoundedString(input.profileName, MAX_PROFILE_BYTES) ? input.profileName : undefined;
-  if (input.status !== 'completed') {
-    const outcome = input.status === 'aborted' ? 'aborted' : 'failed';
-    const entry = baseEntry(input, outcome, profileName);
-    entry.error = boundedError(input.error);
-    if (input.agentId !== undefined) entry.resume_hint = RESUME_HINT;
-    return entry;
-  }
-  if (profileName === undefined) return failureEntry(input, 'authoritative profile is unavailable or invalid');
-  const parsed = parseStructuredChildEnvelope(input.result, {
-    agentId: input.agentId,
-    profileName,
-    responseFormat,
-  });
-  if (!parsed.ok) return failureEntry(input, parsed.error, profileName);
-  const entry = baseEntry(input, 'completed', parsed.value.profileName);
-  entry.result = parsed.value.result;
-  entry.usage = parsed.value.usage;
-  return entry;
-}
-
-function summaryFor(results) {
-  return {
-    completed: results.filter((entry) => entry.outcome === 'completed').length,
-    failed: results.filter((entry) => entry.outcome === 'failed').length,
-    aborted: results.filter((entry) => entry.outcome === 'aborted').length,
-  };
-}
-
-function aggregateStatus(summary) {
-  if (summary.completed === summary.completed + summary.failed + summary.aborted) return 'completed';
-  if (summary.completed === 0) return 'failed';
-  return 'partial';
-}
-
-function metadataOnlyEntry(entry) {
-  const result = {
-    index: entry.index,
-    mode: entry.mode,
-  };
-  if (entry.agent_id !== undefined) result.agent_id = entry.agent_id;
-  if (entry.actual_subagent_type !== undefined) result.actual_subagent_type = entry.actual_subagent_type;
-  result.outcome = entry.outcome;
-  result.result_omitted = true;
-  return result;
-}
-
-function minimalOverflowEnvelope(responseFormat, summary) {
-  return {
-    status: 'failed',
-    error_code: 'structured_swarm_output_limit_exceeded',
-    response_format: responseFormat.name,
-    summary,
-    results_omitted: true,
-  };
-}
-
-function validateInputs(inputs) {
-  if (inputs.length === 0) throw new Error('structured swarm requires at least one result');
-  if (inputs.length > MAX_STRUCTURED_SWARM_RESULTS) {
-    throw new Error(`structured swarm supports at most ${String(MAX_STRUCTURED_SWARM_RESULTS)} results`);
-  }
-  const indexes = inputs.map((input) => input?.spec?.index);
-  const expected = Array.from({ length: inputs.length }, (_, index) => index + 1);
-  const ordered = [...indexes].sort((left, right) => left - right);
-  if (!ordered.every((value, index) => Number.isInteger(value) && value === expected[index])) {
-    throw new Error('structured swarm indexes must be unique contiguous integers starting at 1');
-  }
-  if (!inputs.every((input) => input.spec.kind === 'spawn' || input.spec.kind === 'resume')) {
-    throw new Error('structured swarm mode must be spawn or resume');
-  }
-}
-
-function renderStructuredSwarmResultsWithLimits(inputs, responseFormat, limits) {
-  if (!Array.isArray(inputs)) throw new TypeError('structured swarm results must be an array');
-  if (!responseFormat || typeof responseFormat.name !== 'string' || typeof responseFormat.validator !== 'function') {
-    throw new TypeError('prepared response format is required');
-  }
-  validateInputs(inputs);
-  const maxOutputBytes = limits?.maxOutputBytes ?? MAX_STRUCTURED_SWARM_OUTPUT_BYTES;
-  const maxFallbackBytes = limits?.maxFallbackBytes ?? MAX_STRUCTURED_SWARM_FALLBACK_BYTES;
-  const results = inputs.map((input) => normalizeResult(input, responseFormat)).sort((left, right) => left.index - right.index);
-  const summary = summaryFor(results);
-  const full = JSON.stringify({
-    status: aggregateStatus(summary),
-    response_format: responseFormat.name,
-    summary,
-    results,
-  });
-  if (byteLength(full) <= maxOutputBytes) return full;
-
-  const fallback = JSON.stringify({
-    status: 'failed',
-    error_code: 'structured_swarm_output_limit_exceeded',
-    response_format: responseFormat.name,
-    summary,
-    results: results.map(metadataOnlyEntry),
-  });
-  if (byteLength(fallback) <= maxFallbackBytes) return fallback;
-  return JSON.stringify(minimalOverflowEnvelope(responseFormat, summary));
-}
-
-function renderStructuredSwarmResults(inputs, responseFormat) {
-  return renderStructuredSwarmResultsWithLimits(inputs, responseFormat, undefined);
-}
-
-function safeSummary(value) {
-  if (!isPlainObject(value)) return null;
-  const keys = ['completed', 'failed', 'aborted'];
-  if (Object.keys(value).length !== keys.length || !keys.every((key) => Object.hasOwn(value, key))) return null;
-  if (!keys.every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0)) return null;
-  return {
-    completed: value.completed,
-    failed: value.failed,
-    aborted: value.aborted,
-  };
-}
-
-function parseStructuredDisplayEntry(entry) {
-  if (!isPlainObject(entry)) return null;
-  if (!Number.isSafeInteger(entry.index) || entry.index < 1) return null;
-  if (entry.mode !== 'spawn' && entry.mode !== 'resume') return null;
-  if (entry.outcome !== 'completed' && entry.outcome !== 'failed' && entry.outcome !== 'aborted') return null;
-
-  const resultOmitted = entry.result_omitted === true;
-  if (Object.hasOwn(entry, 'result_omitted') && !resultOmitted) return null;
-  if (resultOmitted && (Object.hasOwn(entry, 'result') || Object.hasOwn(entry, 'error'))) return null;
-  if (!resultOmitted && entry.outcome === 'completed' && !Object.hasOwn(entry, 'result')) return null;
-  if (!resultOmitted && entry.outcome !== 'completed' && typeof entry.error !== 'string') return null;
-
-  return {
-    index: entry.index,
-    status: entry.outcome,
-    completedText: entry.outcome === 'completed' && !resultOmitted
-      ? JSON.stringify(entry.result)
-      : undefined,
-    failureText: entry.outcome !== 'completed' && !resultOmitted
-      ? boundedError(entry.error)
-      : undefined,
-  };
-}
-
-function parseStructuredSwarmDisplay(output) {
-  if (typeof output !== 'string') return { recognized: false };
-  let value;
-  try {
-    value = JSON.parse(output);
-  } catch {
-    return { recognized: false };
-  }
-  if (!isPlainObject(value)) return { recognized: false };
-  if (!validBoundedString(value.response_format, MAX_STRUCTURED_SWARM_FALLBACK_BYTES)) {
-    return { recognized: false };
-  }
-  if (value.status !== 'completed' && value.status !== 'partial' && value.status !== 'failed') {
-    return { recognized: false };
-  }
-
-  const summary = safeSummary(value.summary);
-  if (summary === null) return { recognized: false };
-  const summaryTotal = summary.completed + summary.failed + summary.aborted;
-  if (summaryTotal < 1 || summaryTotal > MAX_STRUCTURED_SWARM_RESULTS) return { recognized: false };
-  const overflow = value.error_code === 'structured_swarm_output_limit_exceeded';
-  if (Object.hasOwn(value, 'error_code') && !overflow) return { recognized: false };
-  if (overflow && value.status !== 'failed') return { recognized: false };
-
-  if (value.results_omitted === true) {
-    const allowedKeys = ['status', 'error_code', 'response_format', 'summary', 'results_omitted'];
-    if (!overflow || Object.hasOwn(value, 'results') || Object.keys(value).some((key) => !allowedKeys.includes(key))) {
-      return { recognized: false };
-    }
-    return {
-      recognized: true,
-      aggregateFailed: true,
-      summary,
-      statuses: [],
-    };
-  }
-
-  if (Object.hasOwn(value, 'results_omitted') || !Array.isArray(value.results)) return { recognized: false };
-  const allowedKeys = overflow
-    ? ['status', 'error_code', 'response_format', 'summary', 'results']
-    : ['status', 'response_format', 'summary', 'results'];
-  if (Object.keys(value).some((key) => !allowedKeys.includes(key))) return { recognized: false };
-  if (value.results.length === 0 || value.results.length > MAX_STRUCTURED_SWARM_RESULTS) return { recognized: false };
-
-  const statuses = value.results.map(parseStructuredDisplayEntry);
-  if (statuses.some((entry) => entry === null)) return { recognized: false };
-  statuses.sort((left, right) => left.index - right.index);
-  if (!statuses.every((entry, index) => entry.index === index + 1)) return { recognized: false };
-
-  const actualSummary = {
-    completed: statuses.filter((entry) => entry.status === 'completed').length,
-    failed: statuses.filter((entry) => entry.status === 'failed').length,
-    aborted: statuses.filter((entry) => entry.status === 'aborted').length,
-  };
-  if (!Object.keys(actualSummary).every((key) => actualSummary[key] === summary[key])) return { recognized: false };
-  if (!overflow && aggregateStatus(summary) !== value.status) return { recognized: false };
-  if (!overflow && value.results.some((entry) => entry.result_omitted === true)) return { recognized: false };
-  if (overflow && !value.results.every((entry) => entry.result_omitted === true)) return { recognized: false };
-
-  return {
-    recognized: true,
-    aggregateFailed: overflow,
-    summary,
-    statuses,
-  };
-}
-
-function structuredSwarmToolResult(output) {
-  const parsed = parseStructuredSwarmDisplay(output);
-  return parsed.recognized && parsed.aggregateFailed ? { output, isError: true } : { output };
-}
-
-module.exports = {
-  MAX_STRUCTURED_SWARM_OUTPUT_BYTES,
-  MAX_STRUCTURED_SWARM_FALLBACK_BYTES,
-  MAX_STRUCTURED_SWARM_RESULTS,
-  parseStructuredChildEnvelope,
-  parseStructuredSwarmDisplay,
-  renderStructuredSwarmResults,
-  renderStructuredSwarmResultsWithLimits,
-  structuredSwarmToolResult,
-};