blun-king-cli 9.1.424 → 9.1.426

package/bin/cognitive-cross-portal-acceptance.cjs

@@ -0,0 +1,443 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
+const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
+
+const PACKAGE_VERSION = require('../package.json').version;
+const SCHEMA = 'blun.cognitive-cross-portal-acceptance/v1';
+const FIXED_TIME = '2031-04-05T09:00:00.000Z';
+const TENANT_ID = 'tenant-v7';
+const AGENT_ID = 'nova';
+const USER_ID = 'mayk';
+const PRIVATE_SCOPE = `relationship:${USER_ID}:private`;
+
+function digest(value) {
+  return crypto.createHash('sha256').update(String(value)).digest('hex');
+}
+
+function requireCondition(condition, code) {
+  if (!condition) {
+    const error = new Error(code);
+    error.code = code;
+    throw error;
+  }
+}
+
+function addCheck(checks, id, detail, evidence) {
+  checks.push({
+    id,
+    status: 'PASS',
+    detail,
+    receipt: digest(`${SCHEMA}\0${id}\0${JSON.stringify(evidence)}`),
+  });
+}
+
+function identityLink({ portalId, actorId, method, authority, receiptId }) {
+  return {
+    version: 1,
+    tenantId: TENANT_ID,
+    canonicalUserId: USER_ID,
+    sourcePortal: portalId,
+    sourceSubjectId: actorId,
+    method,
+    status: 'active',
+    confirmedAt: FIXED_TIME,
+    authority,
+    receiptId,
+  };
+}
+
+function linkedAccess({ portalId, actorId, channelId, conversationId, method, authority, receiptId }) {
+  return {
+    tenantId: TENANT_ID,
+    userId: USER_ID,
+    actorId,
+    agentId: AGENT_ID,
+    portalId,
+    channelId,
+    conversationId,
+    requestedScope: PRIVATE_SCOPE,
+    permissionContext: {
+      authority: 'runtime_user_prompt_hook',
+      decision: 'passed',
+      receiptId: `operation-${receiptId}`,
+      identityReceiptId: receiptId,
+    },
+    identityLink: identityLink({ portalId, actorId, method, authority, receiptId }),
+  };
+}
+
+function directAccess({ agentId = AGENT_ID, userId, portalId, channelId, conversationId, requestedScope }) {
+  return {
+    tenantId: TENANT_ID,
+    userId,
+    actorId: userId,
+    agentId,
+    portalId,
+    channelId,
+    conversationId,
+    requestedScope,
+    permissionContext: {
+      authority: 'runtime_user_prompt_hook',
+      decision: 'passed',
+      receiptId: `operation-${conversationId}`,
+    },
+  };
+}
+
+function event({
+  agentId = AGENT_ID,
+  eventId,
+  expectedVersion,
+  occurredAt,
+  source,
+  observationId,
+  domain = 'open_thread',
+  key,
+  value,
+  scope,
+  supersedes,
+  withdraws,
+  retentionClass = 'relationship',
+}) {
+  return {
+    tenantId: TENANT_ID,
+    agentId,
+    eventId,
+    expectedVersion,
+    occurredAt,
+    receivedAt: occurredAt,
+    retentionClass,
+    source,
+    observations: [{
+      observation_id: observationId,
+      domain,
+      key,
+      value,
+      confidence: 1,
+      epistemic_state: 'verified',
+      scope,
+      ...(supersedes ? { supersedes } : {}),
+      ...(withdraws ? { withdraws } : {}),
+    }],
+  };
+}
+
+function effectiveObservation(items, key, scope) {
+  const entries = items
+    .filter((item) => item.key === key && item.scope === scope)
+    .map((item, index) => ({
+      ...item,
+      observationId: item.observation_id,
+      occurredAt: Date.parse(item.occurred_at),
+      index,
+    }));
+  return resolveCognitiveEvidenceGroup(entries);
+}
+
+function sourceHashes(root, files) {
+  return Object.fromEntries(files.map((name) => [
+    name,
+    digest(fs.readFileSync(path.join(root, name))),
+  ]));
+}
+
+function renderCognitiveCrossPortalAcceptance(report) {
+  const lines = [`/memory acceptance ${report.ok ? 'PASS' : 'FAIL'} ${report.passed}/${report.total}`];
+  for (const check of report.checks) {
+    lines.push(`${check.id} ${check.status} receipt=${check.receipt.slice(0, 16)}`);
+  }
+  lines.push(`receipt=${report.receiptDigest}`);
+  lines.push('synthetic temporary state; evidence only; grants no authority');
+  return lines.join('\n');
+}
+
+function runCognitiveCrossPortalAcceptance() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-v7-cross-portal-'));
+  const protectedFiles = ['SOUL.md', 'identity/manifest.json'];
+  let adapter;
+  try {
+    fs.mkdirSync(path.join(root, 'identity'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'SOUL.md'), '# Nova\n\nWarm, precise, and honest.\n', 'utf8');
+    fs.writeFileSync(path.join(root, 'identity', 'manifest.json'), `${JSON.stringify({
+      version: 1,
+      tenant_id: TENANT_ID,
+      active_agent_id: AGENT_ID,
+    })}\n`, 'utf8');
+    const before = sourceHashes(root, protectedFiles);
+    adapter = openCognitiveMemoryAdapter({ home: root });
+    const checks = [];
+
+    const telegram = linkedAccess({
+      portalId: 'telegram',
+      actorId: 'telegram-42',
+      channelId: 'direct',
+      conversationId: 'dm-42',
+      method: 'explicit_confirmed',
+      authority: 'identity_confirmation_service',
+      receiptId: 'identity-telegram-42',
+    });
+    const web = linkedAccess({
+      portalId: 'web',
+      actorId: 'oauth-77',
+      channelId: 'chat',
+      conversationId: 'web-chat-77',
+      method: 'verified_oauth',
+      authority: 'oauth_verifier',
+      receiptId: 'identity-oauth-77',
+    });
+    const cli = linkedAccess({
+      portalId: 'cli',
+      actorId: 'cli-profile-7',
+      channelId: 'terminal',
+      conversationId: 'cli-session-7',
+      method: 'secure_account_link',
+      authority: 'account_link_service',
+      receiptId: 'identity-cli-profile-7',
+    });
+    const initialEvent = event({
+      eventId: 'event-telegram-topic',
+      expectedVersion: 0,
+      occurredAt: '2031-04-05T09:01:00.000Z',
+      source: {
+        provider: 'telegram',
+        channel_id: 'direct',
+        actor_id: 'telegram-42',
+        context_id: 'dm-42',
+        message_id: 'telegram-message-1',
+      },
+      observationId: 'observation-shared-topic-v1',
+      key: 'shared-topic',
+      value: 'continue after the measured result',
+      scope: PRIVATE_SCOPE,
+    });
+    const firstCommit = adapter.commit(initialEvent, telegram);
+    const fromWeb = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    const webTopic = fromWeb.observations.find((item) => item.observation_id === 'observation-shared-topic-v1');
+    requireCondition(webTopic?.source?.provider === 'telegram'
+      && webTopic.source.channel_id === 'direct', 'ACCEPTANCE_PORTAL_PROVENANCE_FAILED');
+    addCheck(checks, 'portal-provenance', 'Telegram provenance remains visible after a Web read.', [
+      webTopic.source.provider,
+      webTopic.source.channel_id,
+      webTopic.source.message_id,
+    ]);
+
+    const fromCli = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, cli);
+    requireCondition(fromWeb.observations.length === 1 && fromCli.observations.length === 1,
+      'ACCEPTANCE_LINKED_IDENTITY_FAILED');
+    addCheck(checks, 'linked-identity', 'One confirmed identity reads the same memory in Web and CLI.', [
+      fromWeb.observations[0].observation_id,
+      fromCli.observations[0].observation_id,
+    ]);
+
+    const unlinkedWeb = directAccess({
+      userId: 'oauth-77',
+      portalId: 'web',
+      channelId: 'chat',
+      conversationId: 'web-chat-unlinked',
+      requestedScope: 'relationship:oauth-77:private',
+    });
+    const unlinked = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, unlinkedWeb);
+    requireCondition(unlinked.observations.length === 0, 'ACCEPTANCE_UNLINKED_ISOLATION_FAILED');
+    addCheck(checks, 'unlinked-isolation', 'A similarly named but unlinked Web identity sees no private memory.', 0);
+
+    const atlasAccess = directAccess({
+      agentId: 'atlas',
+      userId: 'atlas-user',
+      portalId: 'cli',
+      channelId: 'terminal',
+      conversationId: 'atlas-session',
+      requestedScope: 'user:atlas-user:private',
+    });
+    adapter.commit(event({
+      agentId: 'atlas',
+      eventId: 'event-atlas-only',
+      expectedVersion: 0,
+      occurredAt: '2031-04-05T09:02:00.000Z',
+      source: {
+        provider: 'cli',
+        channel_id: 'terminal',
+        actor_id: 'atlas-user',
+        context_id: 'atlas-session',
+        message_id: 'atlas-message-1',
+      },
+      observationId: 'observation-atlas-only',
+      key: 'agent-only',
+      value: 'atlas private state',
+      scope: 'user:atlas-user:private',
+    }), atlasAccess);
+    requireCondition(adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web)
+      .observations.every((item) => item.observation_id !== 'observation-atlas-only'),
+    'ACCEPTANCE_AGENT_ISOLATION_FAILED');
+    addCheck(checks, 'agent-isolation', 'A second agent stream remains outside Nova private reads.', 'atlas');
+
+    const nordAccess = directAccess({
+      userId: 'nord-member',
+      portalId: 'web',
+      channelId: 'group',
+      conversationId: 'group-nord',
+      requestedScope: 'team:nord',
+    });
+    const solAccess = directAccess({
+      userId: 'sol-member',
+      portalId: 'web',
+      channelId: 'group',
+      conversationId: 'group-sol',
+      requestedScope: 'team:sol',
+    });
+    adapter.commit(event({
+      eventId: 'event-nord-blocker',
+      expectedVersion: 1,
+      occurredAt: '2031-04-05T09:03:00.000Z',
+      source: {
+        provider: 'web',
+        channel_id: 'group',
+        actor_id: 'nord-member',
+        context_id: 'group-nord',
+        message_id: 'nord-message-1',
+      },
+      observationId: 'observation-nord-blocker',
+      domain: 'team',
+      key: 'group-blocker',
+      value: 'nord synthetic blocker',
+      scope: 'team:nord',
+      retentionClass: 'operational',
+    }), nordAccess);
+    const nord = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, nordAccess);
+    const sol = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, solAccess);
+    requireCondition(nord.observations.length === 1 && sol.observations.length === 0,
+      'ACCEPTANCE_GROUP_ISOLATION_FAILED');
+    addCheck(checks, 'group-isolation', 'The Nord scope receives its blocker while the Sol scope remains empty.', [
+      nord.observations[0].observation_id,
+      sol.observations.length,
+    ]);
+
+    const replay = adapter.commit(initialEvent, telegram);
+    requireCondition(replay.idempotent === true && replay.version === firstCommit.version,
+      'ACCEPTANCE_DEDUPLICATION_FAILED');
+    addCheck(checks, 'deduplication', 'Replaying the same portal event creates no second memory event.', [
+      replay.version,
+      replay.idempotent,
+    ]);
+
+    adapter.commit(event({
+      eventId: 'event-web-correction',
+      expectedVersion: 2,
+      occurredAt: '2031-04-05T09:04:00.000Z',
+      source: {
+        provider: 'web',
+        channel_id: 'chat',
+        actor_id: 'oauth-77',
+        context_id: 'web-chat-77',
+        message_id: 'web-message-2',
+      },
+      observationId: 'observation-shared-topic-v2',
+      key: 'shared-topic',
+      value: 'continue after the verified result',
+      scope: PRIVATE_SCOPE,
+      supersedes: 'observation-shared-topic-v1',
+    }), web);
+    const correctedCli = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, cli);
+    const corrected = effectiveObservation(correctedCli.observations, 'shared-topic', PRIVATE_SCOPE);
+    requireCondition(corrected?.value === 'continue after the verified result'
+      && corrected.supersedes === 'observation-shared-topic-v1', 'ACCEPTANCE_GLOBAL_CORRECTION_FAILED');
+    addCheck(checks, 'global-correction', 'A Web correction becomes the effective CLI value and keeps history.', [
+      corrected.observationId,
+      corrected.supersedes,
+      correctedCli.observations.length,
+    ]);
+
+    adapter.commit(event({
+      eventId: 'event-cli-deletion',
+      expectedVersion: 3,
+      occurredAt: '2031-04-05T09:05:00.000Z',
+      source: {
+        provider: 'cli',
+        channel_id: 'terminal',
+        actor_id: 'cli-profile-7',
+        context_id: 'cli-session-7',
+        message_id: 'cli-message-3',
+      },
+      observationId: 'observation-shared-topic-deleted',
+      key: 'shared-topic',
+      value: 'withdrawn',
+      scope: PRIVATE_SCOPE,
+      withdraws: 'observation-shared-topic-v2',
+    }), cli);
+    const deletedWeb = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    requireCondition(effectiveObservation(deletedWeb.observations, 'shared-topic', PRIVATE_SCOPE) === null
+      && deletedWeb.observations.some((item) => item.withdraws === 'observation-shared-topic-v2'),
+    'ACCEPTANCE_GLOBAL_DELETION_FAILED');
+    addCheck(checks, 'global-deletion', 'A CLI deletion removes the active Web value while retaining its tombstone.', [
+      deletedWeb.observations.length,
+      'observation-shared-topic-deleted',
+    ]);
+
+    const beforeProviderFailure = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    let providerError = '';
+    try {
+      loadConfiguredCognitiveMemoryAdapter({
+        modulePath: path.join(root, 'missing-provider.cjs'),
+        home: root,
+        tenantId: TENANT_ID,
+        agentId: AGENT_ID,
+        agentName: 'Nova',
+      });
+    } catch (error) {
+      providerError = error?.code ?? '';
+    }
+    const afterProviderFailure = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    requireCondition(providerError === 'COGNITIVE_MEMORY_PROVIDER_PATH_INVALID'
+      && JSON.stringify(beforeProviderFailure) === JSON.stringify(afterProviderFailure),
+    'ACCEPTANCE_PROVIDER_FAIL_CLOSED_FAILED');
+    addCheck(checks, 'provider-fail-closed', 'An unavailable provider fails before changing the existing memory stream.', [
+      providerError,
+      afterProviderFailure.version,
+    ]);
+
+    const after = sourceHashes(root, protectedFiles);
+    const novaVerification = adapter.verify({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    const atlasVerification = adapter.verify({ tenantId: TENANT_ID, agentId: 'atlas' }, atlasAccess);
+    requireCondition(JSON.stringify(before) === JSON.stringify(after)
+      && novaVerification.valid === true && atlasVerification.valid === true,
+    'ACCEPTANCE_BYTE_PRESERVATION_FAILED');
+    addCheck(checks, 'byte-preservation', 'Synthetic SOUL and identity source bytes remain unchanged and both chains verify.', [
+      after,
+      novaVerification.valid,
+      atlasVerification.valid,
+    ]);
+
+    const report = {
+      schema: SCHEMA,
+      version: PACKAGE_VERSION,
+      scenarioId: 'v7-cross-portal-memory-v1',
+      ok: true,
+      passed: checks.length,
+      total: checks.length,
+      portals: ['cli', 'telegram', 'web'],
+      checks,
+      protectedSourceHashes: after,
+      receiptDigest: digest(checks.map((check) => `${check.id}:${check.receipt}`).join('\n')),
+      scope: 'synthetic-temporary-state',
+      authority: 'acceptance-evidence-only',
+    };
+    adapter.close();
+    adapter = undefined;
+    return report;
+  } finally {
+    try { adapter?.close(); } catch {}
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  renderCognitiveCrossPortalAcceptance,
+  runCognitiveCrossPortalAcceptance,
+};
+

package/bin/cognitive-memory-command.cjs

@@ -3,6 +3,10 @@
 const crypto = require('node:crypto');
 const { createRuntimeCognitiveTurnLifecycle } = require('./cognitive-turn-lifecycle.cjs');
 const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+const {
+  renderCognitiveCrossPortalAcceptance,
+  runCognitiveCrossPortalAcceptance,
+} = require('./cognitive-cross-portal-acceptance.cjs');
 
 const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
 const POSITIVE_ID_RE = /^[1-9]\d*$/u;
@@ -25,12 +29,15 @@ function digestId(prefix, values) {
 
 function isCognitiveMemoryCommand(args) {
   const action = String(args ?? '').trim().split(/\s+/u, 1)[0].toLowerCase();
-  return action === 'focus' || action === 'correct' || action === 'delete';
+  return action === 'focus' || action === 'correct' || action === 'delete' || action === 'acceptance';
 }
 
 function parseCognitiveMemoryCommand(args) {
   const text = String(args ?? '').trim();
   if (text.toLowerCase() === 'focus') return { action: 'focus' };
+  if (/^acceptance(?:\s+--json)?$/iu.test(text)) {
+    return { action: 'acceptance', json: /\s+--json$/iu.test(text) };
+  }
   const correction = /^correct\s+(\S+)\s+(.+)$/iu.exec(text);
   if (correction) {
     const target = clean(correction[1], 128);
@@ -200,6 +207,10 @@ function runCognitiveMemoryCommand({
   lifecycleFactory = createRuntimeCognitiveTurnLifecycle,
 } = {}) {
   const command = parseCognitiveMemoryCommand(args);
+  if (command.action === 'acceptance') {
+    const report = runCognitiveCrossPortalAcceptance();
+    return command.json ? JSON.stringify(report) : renderCognitiveCrossPortalAcceptance(report);
+  }
   const telegram = normalizeTelegramSource(channelSource);
   const lifecycle = openLifecycle(env, lifecycleFactory);
   try {

package/bin/subagent-max-tokens-handoff-policy.cjs

@@ -0,0 +1,55 @@
+"use strict";
+
+const MAX_SUBAGENT_HANDOFF_ATTEMPTS = 1;
+const MAX_PARTIAL_HANDOFF_CHARS = 6000;
+const SUBAGENT_MAX_TOKENS_ERROR =
+  "Subagent turn failed before completing its final summary: reason=max_tokens";
+const SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT = [
+  "Your previous turn reached max_tokens before its final handoff.",
+  "Do not call any tools and do not repeat completed work.",
+  "Return one concise recovery handoff of at most 1200 words with:",
+  "1. completed work and concrete findings",
+  "2. exact files changed or created",
+  "3. checks already run and their actual results",
+  "4. unfinished work or blockers",
+  "5. the exact next action for the parent or this same agent",
+  "State clearly that the task is incomplete when anything remains.",
+].join("\n");
+
+function shouldRequestSubagentHandoff(stopReason, attempts) {
+  return stopReason === "max_tokens"
+    && Number.isSafeInteger(attempts)
+    && attempts >= 0
+    && attempts < MAX_SUBAGENT_HANDOFF_ATTEMPTS;
+}
+
+function boundedPartialHandoff(partialSummary) {
+  const normalized = typeof partialSummary === "string" ? partialSummary.trim() : "";
+  if (normalized.length <= MAX_PARTIAL_HANDOFF_CHARS) return normalized;
+  return `${normalized.slice(0, MAX_PARTIAL_HANDOFF_CHARS)}\n[partial handoff truncated]`;
+}
+
+function buildSubagentMaxTokensFailure(partialSummary) {
+  const partial = boundedPartialHandoff(partialSummary);
+  const lines = [
+    `${SUBAGENT_MAX_TOKENS_ERROR}.`,
+    "The automatic concise handoff also reached max_tokens.",
+  ];
+  if (partial.length > 0) {
+    lines.push("", "[partial_handoff]", partial, "[/partial_handoff]");
+  }
+  lines.push(
+    "",
+    "Resume the same subagent instead of starting the task again; its context and completed tool work are preserved.",
+  );
+  return lines.join("\n");
+}
+
+module.exports = {
+  MAX_PARTIAL_HANDOFF_CHARS,
+  MAX_SUBAGENT_HANDOFF_ATTEMPTS,
+  SUBAGENT_MAX_TOKENS_ERROR,
+  SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT,
+  buildSubagentMaxTokensFailure,
+  shouldRequestSubagentHandoff,
+};

package/blun.mjs

@@ -252261,7 +252261,21 @@ async function runChildTurnToCompletion(child, signal) {
 		if (typeof statusCode === "number") error.statusCode = statusCode;
 		throw error;
 	}
-	if (completion.stopReason === "max_tokens") throw new Error(`${SUBAGENT_MAX_TOKENS_ERROR}.`);
+	return completion.stopReason;
+}
+async function completeChildTurnWithMaxTokensHandoff(child, signal) {
+	let stopReason = await runChildTurnToCompletion(child, signal);
+	let handoffAttempts = 0;
+	while (shouldRequestSubagentHandoff(stopReason, handoffAttempts)) {
+		handoffAttempts += 1;
+		signal.throwIfAborted();
+		if (child.turn.prompt([{
+			type: "text",
+			text: SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT
+		}], SUBAGENT_PROMPT_ORIGIN) === null) throw new Error("Subagent could not start its max_tokens recovery handoff.");
+		stopReason = await runChildTurnToCompletion(child, signal);
+	}
+	if (stopReason === "max_tokens") throw new Error(buildSubagentMaxTokensFailure(lastAssistantText(child)));
 }
 function providerRateLimitErrorFromPayload(error) {
 	const requestId = typeof error.details?.["requestId"] === "string" ? error.details["requestId"] : null;
@@ -252280,7 +252294,7 @@ function shouldSuppressQueuedAttemptFailureEvent(options, error) {
 	if (isProviderRateLimitError(error)) return true;
 	return isAbortError$4(error) || options.signal.aborted;
 }
-var DEFAULT_SUBAGENT_TIMEOUT_MS, resolveSubagentTimeoutMs, runAgentWithTimeoutContinuation, buildSubagentUsageDelta, SUMMARY_MIN_LENGTH, SUMMARY_CONTINUATION_ATTEMPTS, HOOK_TEXT_PREVIEW_LENGTH, SUBAGENT_MAX_TOKENS_ERROR, TOOL_CALL_DISABLED_MESSAGE, SUBAGENT_PROMPT_ORIGIN, SIDE_QUESTION_SYSTEM_REMINDER, SessionSubagentHost;
+var DEFAULT_SUBAGENT_TIMEOUT_MS, resolveSubagentTimeoutMs, runAgentWithTimeoutContinuation, buildSubagentUsageDelta, SUBAGENT_MAX_TOKENS_ERROR, SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT, buildSubagentMaxTokensFailure, shouldRequestSubagentHandoff, SUMMARY_MIN_LENGTH, SUMMARY_CONTINUATION_ATTEMPTS, HOOK_TEXT_PREVIEW_LENGTH, TOOL_CALL_DISABLED_MESSAGE, SUBAGENT_PROMPT_ORIGIN, SIDE_QUESTION_SYSTEM_REMINDER, SessionSubagentHost;
 var init_subagent_host = __esmMin((() => {
 	init_src$4();
 	init_errors$8();
@@ -252294,10 +252308,15 @@ var init_subagent_host = __esmMin((() => {
 	init_summary_continuation();
 	({ DEFAULT_SUBAGENT_TIMEOUT_MS, resolveSubagentTimeoutMs, runAgentWithTimeoutContinuation } = createRequire(import.meta.url)("./bin/subagent-timeout-policy.cjs"));
 	({ buildSubagentUsageDelta } = createRequire(import.meta.url)("./bin/subagent-usage-rollup-policy.cjs"));
+	({
+		SUBAGENT_MAX_TOKENS_ERROR,
+		SUBAGENT_MAX_TOKENS_HANDOFF_PROMPT,
+		buildSubagentMaxTokensFailure,
+		shouldRequestSubagentHandoff
+	} = createRequire(import.meta.url)("./bin/subagent-max-tokens-handoff-policy.cjs"));
 	SUMMARY_MIN_LENGTH = 200;
 	SUMMARY_CONTINUATION_ATTEMPTS = 1;
 	HOOK_TEXT_PREVIEW_LENGTH = 500;
-	SUBAGENT_MAX_TOKENS_ERROR = "Subagent turn failed before completing its final summary: reason=max_tokens";
 	TOOL_CALL_DISABLED_MESSAGE = "Tool calls are disabled for side questions. Answer with text only.";
 	SUBAGENT_PROMPT_ORIGIN = {
 		kind: "system_trigger",
@@ -252561,7 +252580,7 @@ IMPORTANT:
 			return this.waitForChildCompletion(parent, childId, child, profileName, options);
 		}
 		async waitForChildCompletion(parent, childId, child, profileName, options) {
-			await runChildTurnToCompletion(child, options.signal);
+			await completeChildTurnWithMaxTokensHandoff(child, options.signal);
 			let result = lastAssistantText(child);
 			let remainingContinuations = SUMMARY_CONTINUATION_ATTEMPTS;
 			while (remainingContinuations > 0 && result.length < SUMMARY_MIN_LENGTH) {
@@ -252571,7 +252590,7 @@ IMPORTANT:
 					type: "text",
 					text: summary_continuation_default
 				}], SUBAGENT_PROMPT_ORIGIN);
-				await runChildTurnToCompletion(child, options.signal);
+				await completeChildTurnWithMaxTokensHandoff(child, options.signal);
 				result = lastAssistantText(child);
 			}
 			const usage = child.usage.data().total;
@@ -252709,7 +252728,7 @@ function formatForegroundAgentFailure(handle, message, timedOut) {
 		"",
 		`subagent error: ${message}`
 	];
-	if (timedOut) lines.push(`resume_hint: Continue with Agent(resume="${handle.agentId}", prompt="continue"). Use agent_id only; do not set subagent_type. The subagent retains its prior context; redo any unfinished tool call if its result was lost.`);
+	if (timedOut || message.includes(SUBAGENT_MAX_TOKENS_ERROR)) lines.push(`resume_hint: Continue with Agent(resume="${handle.agentId}", prompt="continue"). Use agent_id only; do not set subagent_type. The subagent retains its prior context; redo any unfinished tool call if its result was lost.`);
 	return lines.join("\n");
 }
 function launchErrorMessage(error, signal) {
@@ -423338,7 +423357,7 @@ async function handleMemoryCommand(host, args, dependencies) {
 	}
 	const parsed = parseMemoryCommand(args);
 	if (parsed === void 0) {
-		host.showStatus("/memory status|on|off|focus|correct <id> <value>|delete <id>");
+		host.showStatus("/memory status|on|off|focus|correct <id> <value>|delete <id>|acceptance [--json]");
 		return;
 	}
 	const client = (dependencies ?? defaultDependencies()).createClient(host);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.424",
+  "version": "9.1.426",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {