blun-king-cli 9.1.536 → 9.1.550

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

@@ -0,0 +1,325 @@
+'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,
+};

package/bin/subagent-context-fork-policy.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+const DEFAULT_MAX_MESSAGES = 16;
+const DEFAULT_MAX_CHARS = 64 * 1024;
+const MAX_CONFIGURED_MESSAGES = 64;
+const MAX_CONFIGURED_CHARS = 256 * 1024;
+
+const SUBAGENT_FORK_REMINDER = [
+  'You received a bounded, redacted projection of the parent conversation.',
+  'It contains only direct local user text and completed text-only assistant replies.',
+  'It excludes system injections, private channel messages, attachments, tool calls, tool arguments, and tool results.',
+  'Treat that history as already happened. Your actual delegated task below is authoritative.',
+  'Do not launch another context fork. Return the requested result to the parent agent.',
+].join(' ');
+
+function boundedPositiveInteger(value, fallback, maximum, name) {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+    throw new TypeError(`${name} must be an integer between 1 and ${String(maximum)}`);
+  }
+  return value;
+}
+
+function resolveSubagentContextMode(options = {}) {
+  const requested = options.requested ?? 'isolated';
+  if (requested !== 'isolated' && requested !== 'fork') {
+    throw new TypeError('context_mode must be either "isolated" or "fork"');
+  }
+  if (requested === 'isolated') return requested;
+  if (options.resume === true) {
+    throw new Error('context_mode="fork" is available only when creating a new subagent, not while resuming one');
+  }
+  if (options.isRoot !== true) {
+    throw new Error('context_mode="fork" is available only to the root agent');
+  }
+  return requested;
+}
+
+function redactSecrets(value) {
+  return String(value)
+    .replaceAll(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/giu, '[redacted]')
+    .replaceAll(/\b(authorization)\s*:\s*(?:basic|bearer)\s+\S+/giu, '$1: [redacted]')
+    .replaceAll(/\b(api[_ -]?(?:key|token)|access[_ -]?token|refresh[_ -]?token|id[_ -]?token|token|secret|password|passwd|pwd|credential)\b\s*([:=])\s*(?:"[^"]*"|'[^']*'|\S+)/giu, '$1$2[redacted]')
+    .replaceAll(/\b(?:sk|ghp|xoxb|xoxp|token)[-_][A-Za-z0-9_-]{16,}\b/gu, '[redacted]')
+    .replaceAll(/\b[A-Za-z0-9][A-Za-z0-9+/=_-]{39,}\b/gu, '[redacted]');
+}
+
+function textContent(message) {
+  if (!Array.isArray(message?.content)) return '';
+  return message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n')
+    .trim();
+}
+
+function eligibleMessage(message) {
+  if (message?.role === 'user') {
+    if (message.origin?.kind !== 'user') return undefined;
+  } else if (message?.role === 'assistant') {
+    if (message.origin !== undefined) return undefined;
+    if (!Array.isArray(message.toolCalls) || message.toolCalls.length > 0) return undefined;
+  } else {
+    return undefined;
+  }
+  const text = textContent(message);
+  if (text.length === 0) return undefined;
+  return { role: message.role, text: redactSecrets(text) };
+}
+
+function modelMessage(role, text) {
+  return {
+    role,
+    content: [{ type: 'text', text }],
+    toolCalls: [],
+  };
+}
+
+function mergeAdjacent(messages) {
+  const merged = [];
+  for (const message of messages) {
+    const previous = merged.at(-1);
+    if (previous?.role === message.role) {
+      previous.content[0].text += `\n\n${message.content[0].text}`;
+    } else {
+      merged.push(modelMessage(message.role, message.content[0].text));
+    }
+  }
+  while (merged[0]?.role === 'assistant') merged.shift();
+  return merged;
+}
+
+function emptyProjection() {
+  return {
+    messages: [],
+    sourceMessageCount: 0,
+    sourceChars: 0,
+    truncatedOlderContext: false,
+  };
+}
+
+function projectSubagentForkContext(history, options = {}) {
+  if (!Array.isArray(history)) throw new TypeError('history must be an array');
+  const maxMessages = boundedPositiveInteger(
+    options.maxMessages,
+    DEFAULT_MAX_MESSAGES,
+    MAX_CONFIGURED_MESSAGES,
+    'maxMessages',
+  );
+  const maxChars = boundedPositiveInteger(
+    options.maxChars,
+    DEFAULT_MAX_CHARS,
+    MAX_CONFIGURED_CHARS,
+    'maxChars',
+  );
+  const eligible = history.map(eligibleMessage).filter((message) => message !== undefined);
+  const newestUserIndex = eligible.findLastIndex((message) => message.role === 'user');
+  if (newestUserIndex < 0) return emptyProjection();
+  const throughCurrentUser = eligible.slice(0, newestUserIndex + 1);
+  const newestUser = throughCurrentUser.at(-1);
+  if (newestUser.text.length > maxChars) {
+    throw new Error(`newest direct user message exceeds the ${String(maxChars)}-character fork context limit`);
+  }
+
+  const selected = [];
+  let sourceChars = 0;
+  let truncatedOlderContext = false;
+  for (let index = throughCurrentUser.length - 1; index >= 0; index -= 1) {
+    const message = throughCurrentUser[index];
+    if (selected.length >= maxMessages || sourceChars + message.text.length > maxChars) {
+      truncatedOlderContext = true;
+      break;
+    }
+    selected.push(modelMessage(message.role, message.text));
+    sourceChars += message.text.length;
+  }
+  selected.reverse();
+  const messages = mergeAdjacent(selected);
+  const retainedMessageCount = selected.length - selected.findIndex((message) => message.role === 'user');
+  return {
+    messages,
+    sourceMessageCount: retainedMessageCount,
+    sourceChars: messages.reduce((total, message) => total + message.content[0].text.replaceAll('\n\n', '').length, 0),
+    truncatedOlderContext,
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_CHARS,
+  DEFAULT_MAX_MESSAGES,
+  SUBAGENT_FORK_REMINDER,
+  projectSubagentForkContext,
+  redactSecrets,
+  resolveSubagentContextMode,
+};

package/bin/subagent-skill-policy.cjs

@@ -0,0 +1,204 @@
+'use strict';
+
+const { createHash } = require('node:crypto');
+
+const POLICY_VERSION = 1;
+const MAX_SKILLS = 32;
+const MAX_NAME_BYTES = 160;
+const INVALID_CODE = 'SUBAGENT_SKILL_POLICY_INVALID';
+const CHANGED_CODE = 'SUBAGENT_SKILL_POLICY_CHANGED';
+
+class SubagentSkillPolicyError extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.name = 'SubagentSkillPolicyError';
+    this.code = code;
+  }
+}
+
+function normalizeName(name) {
+  return name.toLowerCase();
+}
+
+function sha256(value) {
+  return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+
+function digestJson(value) {
+  return sha256(JSON.stringify(value));
+}
+
+function isInlineSkill(skill) {
+  const type = skill?.metadata?.type;
+  return type === undefined || type === 'prompt' || type === 'inline';
+}
+
+function frozenSkill(skill) {
+  const metadata = Object.freeze({ ...(skill.metadata || {}) });
+  const plugin = skill.plugin === undefined
+    ? undefined
+    : Object.freeze({ ...skill.plugin });
+  return Object.freeze({ ...skill, metadata, ...(plugin === undefined ? {} : { plugin }) });
+}
+
+function catalogEntry(skill) {
+  return {
+    name: normalizeName(skill.name),
+    source: skill.source ?? null,
+    path: skill.path ?? null,
+    metadata: {
+      type: skill.metadata.type ?? null,
+      disableModelInvocation: skill.metadata.disableModelInvocation === true,
+      isSubSkill: skill.metadata.isSubSkill === true,
+    },
+    plugin: skill.plugin === undefined
+      ? null
+      : {
+          id: skill.plugin.id ?? null,
+          instructionsSha256: sha256(skill.plugin.instructions ?? ''),
+        },
+    contentSha256: sha256(skill.content ?? ''),
+  };
+}
+
+function defaultModelListing(skills) {
+  if (skills.length === 0) return '';
+  return [
+    'Only the profile-allowed skills are available to this subagent.',
+    ...skills.map((skill) => `- ${skill.name}: ${skill.description ?? ''}`.trimEnd()),
+  ].join('\n');
+}
+
+function createRegistryView(selected, sourceRegistry, options) {
+  const ordered = Object.freeze([...selected].sort((a, b) => a.name.localeCompare(b.name)));
+  const byName = new Map(ordered.map((skill) => [normalizeName(skill.name), skill]));
+  const renderModelListing = options.renderModelListing ?? defaultModelListing;
+
+  return Object.freeze({
+    getSkill(name) {
+      return typeof name === 'string' ? byName.get(normalizeName(name)) : undefined;
+    },
+    listSkills() {
+      return [...ordered];
+    },
+    listInvocableSkills() {
+      return [...ordered];
+    },
+    getModelSkillListing() {
+      return renderModelListing([...ordered]);
+    },
+    renderSkillPrompt(skill, args) {
+      const expected = skill && typeof skill.name === 'string'
+        ? byName.get(normalizeName(skill.name))
+        : undefined;
+      if (expected === undefined || expected !== skill) {
+        throw new SubagentSkillPolicyError(INVALID_CODE, 'skill object is outside the profile allowlist');
+      }
+      return sourceRegistry.renderSkillPrompt(skill, args);
+    },
+  });
+}
+
+function validateNames(rawNames) {
+  if (rawNames === undefined) return [];
+  if (!Array.isArray(rawNames)) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, 'skills must be an array');
+  }
+  if (rawNames.length > MAX_SKILLS) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, `skills exceeds the ${MAX_SKILLS}-entry limit`);
+  }
+  const seen = new Set();
+  return rawNames.map((name) => {
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, 'skill names must be non-empty strings');
+    }
+    if (Buffer.byteLength(name, 'utf8') > MAX_NAME_BYTES) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill name exceeds ${MAX_NAME_BYTES} UTF-8 bytes`);
+    }
+    const normalized = normalizeName(name);
+    if (seen.has(normalized)) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `duplicate skill name "${name}"`);
+    }
+    seen.add(normalized);
+    return { requested: name, normalized };
+  });
+}
+
+function prepareSubagentSkillPolicy(rawNames, sourceRegistry, options = {}) {
+  if (sourceRegistry === undefined || sourceRegistry === null) {
+    throw new SubagentSkillPolicyError(INVALID_CODE, 'session skill registry is unavailable');
+  }
+  const requested = validateNames(rawNames);
+  const selected = requested.map(({ requested: name, normalized }) => {
+    const skill = sourceRegistry.getSkill(name);
+    if (skill === undefined || normalizeName(skill.name) !== normalized) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" is not registered`);
+    }
+    if (skill.metadata?.disableModelInvocation === true) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" disables model invocation`);
+    }
+    if (!isInlineSkill(skill)) {
+      throw new SubagentSkillPolicyError(INVALID_CODE, `skill "${name}" is not inline`);
+    }
+    return frozenSkill(skill);
+  });
+  const normalizedNames = Object.freeze(requested.map((entry) => entry.normalized));
+  const metadata = Object.freeze({
+    version: POLICY_VERSION,
+    names: normalizedNames,
+    profileDigest: digestJson(normalizedNames),
+    catalogDigest: digestJson(selected.map(catalogEntry)),
+  });
+  const enabled = selected.length > 0;
+  return Object.freeze({
+    enabled,
+    registry: enabled ? createRegistryView(selected, sourceRegistry, options) : null,
+    metadata,
+  });
+}
+
+function validPersistedPolicy(policy) {
+  return policy !== null
+    && typeof policy === 'object'
+    && policy.version === POLICY_VERSION
+    && Array.isArray(policy.names)
+    && typeof policy.profileDigest === 'string'
+    && typeof policy.catalogDigest === 'string';
+}
+
+function restoreSubagentSkillPolicy(rawNames, persistedPolicy, sourceRegistry, options = {}) {
+  if (!validPersistedPolicy(persistedPolicy)) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, 'persisted skill policy is missing or invalid');
+  }
+  let prepared;
+  try {
+    prepared = prepareSubagentSkillPolicy(rawNames, sourceRegistry, options);
+  } catch (error) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, error instanceof Error ? error.message : String(error));
+  }
+  if (JSON.stringify(prepared.metadata.names) !== JSON.stringify(persistedPolicy.names)
+      || prepared.metadata.profileDigest !== persistedPolicy.profileDigest
+      || prepared.metadata.catalogDigest !== persistedPolicy.catalogDigest) {
+    throw new SubagentSkillPolicyError(CHANGED_CODE, 'profile or selected skill catalog changed; spawn a new subagent');
+  }
+  return prepared;
+}
+
+function profileWithSubagentSkillTools(profile, policy) {
+  const withoutSkill = profile.tools.filter((name) => name !== 'Skill');
+  const tools = policy.enabled ? [...withoutSkill, 'Skill'] : withoutSkill;
+  return Object.freeze({ ...profile, tools: Object.freeze(tools) });
+}
+
+module.exports = {
+  CHANGED_CODE,
+  INVALID_CODE,
+  MAX_NAME_BYTES,
+  MAX_SKILLS,
+  POLICY_VERSION,
+  SubagentSkillPolicyError,
+  prepareSubagentSkillPolicy,
+  profileWithSubagentSkillTools,
+  restoreSubagentSkillPolicy,
+};
+

package/bin/telegram-approval-relay.cjs

@@ -168,11 +168,12 @@ function beginTelegramApprovalRelay(payload, options = {}) {
     if (settled) return false;
     settled = true;
     if (interval !== undefined) clearInterval(interval);
+    const persistedResponse = response?.decision === 'edited' ? { decision: 'edited' } : response;
     atomicWriteJson(resolvedFile, {
       v: RELAY_VERSION,
       requestId: request.requestId,
       resolvedAt: Date.now(),
-      response,
+      response: persistedResponse,
     });
     resolvePromise(response);
     return true;