blun-king-cli 9.1.527 → 9.1.536

package/bin/programmatic-context-isolation.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const PROGRAMMATIC_WIRE_ONLY = 'programmatic_nested';
+
+function isNestedToolEvent(event) {
+  return event?.type === 'tool.call' || event?.type === 'tool.result';
+}
+
+function markProgrammaticNestedEvent(event) {
+  if (!isNestedToolEvent(event)) return event;
+  return {
+    ...event,
+    contextVisibility: PROGRAMMATIC_WIRE_ONLY,
+  };
+}
+
+function isWireOnlyProgrammaticEvent(event) {
+  return isNestedToolEvent(event) && event.contextVisibility === PROGRAMMATIC_WIRE_ONLY;
+}
+
+module.exports = {
+  PROGRAMMATIC_WIRE_ONLY,
+  isWireOnlyProgrammaticEvent,
+  markProgrammaticNestedEvent,
+};

package/bin/programmatic-tool-runtime.mjs

@@ -0,0 +1,301 @@
+import {
+  RELEASE_ASYNC,
+  newQuickJSAsyncWASMModule,
+  shouldInterruptAfterDeadline,
+} from 'quickjs-emscripten';
+
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
+const DEFAULT_LIMITS = Object.freeze({
+  memoryBytes: 16 * 1024 * 1024,
+  stackBytes: 512 * 1024,
+  timeoutMs: 120_000,
+  guestExecutionMs: 3_000,
+  maxCodeChars: 32_000,
+  maxStateChars: 65_536,
+  maxOutputChars: 65_536,
+  maxToolArgumentChars: 32_768,
+  maxToolResultChars: 131_072,
+  maxToolCalls: 64,
+});
+
+let callSequence = 0;
+
+export function createProgrammaticToolRuntime(options) {
+  if (typeof options?.invokeTool !== 'function') {
+    throw new TypeError('invokeTool must be a function');
+  }
+  const allowedTools = normalizeAllowedTools(options.allowedTools);
+  const limits = normalizeLimits(options.limits);
+  const emit = typeof options.onEvent === 'function' ? options.onEvent : () => {};
+
+  return {
+    async run(input) {
+      const code = String(input?.code ?? '');
+      if (code.length > limits.maxCodeChars) {
+        throw new Error(`program exceeds ${limits.maxCodeChars} characters`);
+      }
+      const initialState = normalizeJsonObject(input?.state ?? {}, 'state');
+      const initialStateJson = JSON.stringify(initialState);
+      if (initialStateJson.length > limits.maxStateChars) {
+        throw new Error(`state exceeds ${limits.maxStateChars} characters`);
+      }
+
+      const startedAt = Date.now();
+      const wallDeadline = startedAt + limits.timeoutMs;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(new Error('execution deadline exceeded')), limits.timeoutMs);
+      const detachOuterAbort = forwardAbort(input?.signal, controller);
+      let callCount = 0;
+      let module;
+      let context;
+      emit({ type: 'interpreter.started', toolCount: allowedTools.length });
+
+      try {
+        module = await newQuickJSAsyncWASMModule(RELEASE_ASYNC);
+        context = module.newContext();
+        const runtime = context.runtime;
+        let guestDeadline = Date.now() + limits.guestExecutionMs;
+        runtime.setMemoryLimit(limits.memoryBytes);
+        runtime.setMaxStackSize(limits.stackBytes);
+        runtime.setInterruptHandler(() => (
+          controller.signal.aborted || shouldInterruptAfterDeadline(guestDeadline)()
+        ));
+        for (const [index, tool] of allowedTools.entries()) {
+          const bridgeName = `__blun_ptc_${index}`;
+          const bridge = context.newAsyncifiedFunction(bridgeName, async (rawHandle) => {
+            if (callCount >= limits.maxToolCalls) {
+              return context.newString(errorEnvelope(`tool-call limit of ${limits.maxToolCalls} exceeded`));
+            }
+            const raw = rawHandle === undefined ? '{}' : context.getString(rawHandle);
+            if (raw.length > limits.maxToolArgumentChars) {
+              return context.newString(errorEnvelope(`tool arguments exceed ${limits.maxToolArgumentChars} characters`));
+            }
+            let args;
+            try {
+              args = normalizeJsonObject(JSON.parse(raw), 'tool arguments');
+            } catch (error) {
+              return context.newString(errorEnvelope(errorMessage(error)));
+            }
+            callCount += 1;
+            const callId = nextCallId(tool.name);
+            emit({
+              type: 'interpreter.tool_call',
+              callId,
+              toolName: tool.name,
+              args,
+            });
+            try {
+              const hostStartedAt = Date.now();
+              let value;
+              try {
+                value = await raceHostCall(
+                  options.invokeTool({ name: tool.name, args, callId, signal: controller.signal }),
+                  controller.signal,
+                  wallDeadline,
+                );
+              } finally {
+                guestDeadline += Date.now() - hostStartedAt;
+              }
+              const valueJson = jsonStringify(value, `tool ${tool.name} result`);
+              if (valueJson.length > limits.maxToolResultChars) {
+                throw new Error(`tool result exceeds ${limits.maxToolResultChars} characters`);
+              }
+              emit({
+                type: 'interpreter.tool_result',
+                callId,
+                toolName: tool.name,
+                isError: false,
+              });
+              return context.newString(JSON.stringify({ ok: true, value }));
+            } catch (error) {
+              const message = errorMessage(error);
+              emit({
+                type: 'interpreter.tool_result',
+                callId,
+                toolName: tool.name,
+                isError: true,
+                error: message,
+              });
+              return context.newString(errorEnvelope(message));
+            }
+          });
+          context.setProp(context.global, bridgeName, bridge);
+          bridge.dispose();
+        }
+
+        evaluateBootstrap(context, renderBootstrap(allowedTools, initialStateJson));
+        const evaluated = await context.evalCodeAsync(renderProgram(code), 'blun-ptc.js');
+        if (evaluated.error) {
+          const dumped = context.dump(evaluated.error);
+          evaluated.error.dispose();
+          throw guestError(dumped, controller.signal, guestDeadline);
+        }
+        runtime.setMemoryLimit(-1);
+        const payloadJson = context.getString(evaluated.value);
+        evaluated.value.dispose();
+        const payload = JSON.parse(payloadJson);
+        const resultJson = jsonStringify(payload.result, 'result');
+        const stateJson = jsonStringify(payload.state, 'state');
+        if (resultJson.length > limits.maxOutputChars) {
+          throw new Error(`result exceeds ${limits.maxOutputChars} characters`);
+        }
+        if (stateJson.length > limits.maxStateChars) {
+          throw new Error(`state exceeds ${limits.maxStateChars} characters`);
+        }
+        const outcome = { result: payload.result, state: payload.state, callCount };
+        emit({ type: 'interpreter.completed', callCount, durationMs: Date.now() - startedAt });
+        return outcome;
+      } catch (error) {
+        const normalized = normalizeExecutionError(error, controller.signal);
+        emit({
+          type: 'interpreter.failed',
+          callCount,
+          durationMs: Date.now() - startedAt,
+          error: normalized.message,
+        });
+        throw normalized;
+      } finally {
+        clearTimeout(timeout);
+        detachOuterAbort();
+        context?.dispose();
+      }
+    },
+  };
+}
+
+function normalizeAllowedTools(value) {
+  if (!Array.isArray(value)) throw new TypeError('allowedTools must be an array');
+  const names = new Set();
+  const aliases = new Set();
+  return value.map((entry) => {
+    const name = String(entry?.name ?? '').trim();
+    const alias = String(entry?.alias ?? '').trim();
+    if (!name) throw new Error('tool name must not be empty');
+    if (!IDENTIFIER_RE.test(alias)) throw new Error(`${alias || '[empty]'} is not a valid JavaScript identifier`);
+    if (names.has(name)) throw new Error(`duplicate tool name: ${name}`);
+    if (aliases.has(alias)) throw new Error(`duplicate tool alias: ${alias}`);
+    names.add(name);
+    aliases.add(alias);
+    return Object.freeze({ name, alias });
+  });
+}
+
+function normalizeLimits(value = {}) {
+  const limits = { ...DEFAULT_LIMITS, ...value };
+  for (const [name, number] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`${name} must be a positive integer`);
+  }
+  return Object.freeze(limits);
+}
+
+function normalizeJsonObject(value, label) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return JSON.parse(jsonStringify(value, label));
+}
+
+function jsonStringify(value, label) {
+  try {
+    const result = JSON.stringify(value);
+    if (result === undefined) throw new Error(`${label} is not JSON serializable`);
+    return result;
+  } catch (error) {
+    throw new Error(`${label} is not JSON serializable: ${errorMessage(error)}`);
+  }
+}
+
+function renderBootstrap(tools, stateJson) {
+  const entries = tools.map((tool, index) => {
+    const bridge = `globalThis.__blun_ptc_${index}`;
+    return `${JSON.stringify(tool.alias)}: (() => { const call = ${bridge}; delete ${bridge}; return (args = {}) => { const envelope = JSON.parse(call(JSON.stringify(args))); if (!envelope.ok) throw new Error(envelope.error); return envelope.value; }; })()`;
+  });
+  return `
+    globalThis.state = JSON.parse(${JSON.stringify(stateJson)});
+    globalThis.tools = Object.freeze({ ${entries.join(',')} });
+    delete globalThis.process;
+    delete globalThis.require;
+    delete globalThis.fetch;
+    delete globalThis.Date;
+    delete globalThis.performance;
+    delete globalThis.eval;
+    delete globalThis.Function;
+    undefined;
+  `;
+}
+
+function renderProgram(code) {
+  return `JSON.stringify({ result: (() => { "use strict"; ${code}\n})(), state: globalThis.state })`;
+}
+
+function evaluateBootstrap(context, source) {
+  const result = context.evalCode(source, 'blun-ptc-bootstrap.js');
+  if (result.error) {
+    const dumped = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`interpreter bootstrap failed: ${errorMessage(dumped)}`);
+  }
+  result.value.dispose();
+}
+
+function errorEnvelope(message) {
+  return JSON.stringify({ ok: false, error: String(message) });
+}
+
+function nextCallId(toolName) {
+  callSequence += 1;
+  return `ptc_${toolName.replace(/[^A-Za-z0-9_]/gu, '_')}_${callSequence}`;
+}
+
+function forwardAbort(signal, controller) {
+  if (!signal) return () => {};
+  const onAbort = () => controller.abort(signal.reason);
+  if (signal.aborted) onAbort();
+  else signal.addEventListener('abort', onAbort, { once: true });
+  return () => signal.removeEventListener('abort', onAbort);
+}
+
+async function raceHostCall(value, signal, deadline) {
+  if (signal.aborted) throw signal.reason ?? new Error('program aborted');
+  const remaining = Math.max(0, deadline - Date.now());
+  let timer;
+  let onAbort;
+  const blocked = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('execution deadline exceeded')), remaining);
+    onAbort = () => reject(signal.reason ?? new Error('program aborted'));
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve(value), blocked]);
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener('abort', onAbort);
+  }
+}
+
+function guestError(value, signal, deadline) {
+  if (signal.aborted) return abortReason(signal);
+  if (Date.now() >= deadline || value?.message === 'interrupted') {
+    return new Error('execution deadline exceeded');
+  }
+  return new Error(value?.message ?? errorMessage(value));
+}
+
+function normalizeExecutionError(error, signal) {
+  if (signal.aborted) return abortReason(signal);
+  if (errorMessage(error).includes('interrupted')) {
+    return new Error('guest execution deadline exceeded');
+  }
+  return error instanceof Error ? error : new Error(errorMessage(error));
+}
+
+function abortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  return new Error(signal.reason === undefined ? 'program aborted' : String(signal.reason));
+}
+
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === 'object' && typeof error.message === 'string') return error.message;
+  return String(error);
+}

package/bin/skill-activation-performance-policy.cjs

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+  hasHistoricalOffloadPressure,
+  historyTextChars,
+} = require('./history-offload-pressure-policy.cjs');
+
 const SKILL_ACTIVATION_KEEP_RECENT_MESSAGES = 20;
 const SKILL_ACTIVATION_MIN_CHARS = 4_000;
 const SKILL_ACTIVATION_MARKER = '[Earlier skill activation compacted]';
@@ -40,6 +45,10 @@ function compactSkillActivationMessage(message) {
 
 function compactHistoricalSkillActivations(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return messages;
+  if (!hasHistoricalOffloadPressure({
+    historyLength: messages.length,
+    historyChars: historyTextChars(messages),
+  })) return messages;
   const recentStart = Math.max(0, messages.length - SKILL_ACTIVATION_KEEP_RECENT_MESSAGES);
   let changed = false;
   const projected = messages.map((message, index) => {

package/bin/structured-subagent-output.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+const MAX_SCHEMA_BYTES = 16 * 1024;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const MAX_SCHEMA_DEPTH = 12;
+const MAX_SCHEMA_NODES = 128;
+const MAX_ERROR_BYTES = 2048;
+const STRUCTURED_SUBAGENT_OUTPUT_ERROR = 'Structured subagent output invalid after one repair attempt';
+
+const ALLOWED_SCHEMA_KEYS = new Set([
+  'type',
+  'properties',
+  'required',
+  'additionalProperties',
+  'items',
+  'enum',
+  'const',
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'exclusiveMaximum',
+  'minLength',
+  'maxLength',
+  'minItems',
+  'maxItems',
+  'description',
+]);
+
+const ALLOWED_TYPES = new Set([
+  'object',
+  'array',
+  'string',
+  'number',
+  'integer',
+  'boolean',
+  'null',
+]);
+
+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 boundedText(value, maxBytes = MAX_ERROR_BYTES) {
+  const text = String(value);
+  const bytes = Buffer.from(text, 'utf8');
+  if (bytes.byteLength <= maxBytes) return text;
+  return `${bytes.subarray(0, Math.max(0, maxBytes - 3)).toString('utf8')}...`;
+}
+
+function assertFiniteNumber(value, path) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new Error(`${path} must be a finite number`);
+  }
+}
+
+function assertNonNegativeInteger(value, path) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${path} must be a non-negative integer`);
+  }
+}
+
+function inspectSchemaNode(node, path, depth, state) {
+  if (!isPlainObject(node)) throw new Error(`${path} must be a JSON Schema object`);
+  if (depth > MAX_SCHEMA_DEPTH) {
+    throw new Error(`response_format.schema exceeds maximum depth ${MAX_SCHEMA_DEPTH}`);
+  }
+  state.nodes += 1;
+  if (state.nodes > MAX_SCHEMA_NODES) {
+    throw new Error(`response_format.schema exceeds maximum node count ${MAX_SCHEMA_NODES}`);
+  }
+
+  for (const key of Object.keys(node)) {
+    if (!ALLOWED_SCHEMA_KEYS.has(key)) {
+      throw new Error(`${path}.${key} is not supported in response_format.schema`);
+    }
+  }
+
+  if (node.type !== undefined && (!ALLOWED_TYPES.has(node.type) || typeof node.type !== 'string')) {
+    throw new Error(`${path}.type must be one supported scalar JSON Schema type`);
+  }
+  if (node.description !== undefined && typeof node.description !== 'string') {
+    throw new Error(`${path}.description must be a string`);
+  }
+  if (node.properties !== undefined) {
+    if (!isPlainObject(node.properties)) throw new Error(`${path}.properties must be an object`);
+    for (const [name, child] of Object.entries(node.properties)) {
+      inspectSchemaNode(child, `${path}.properties[${JSON.stringify(name)}]`, depth + 1, state);
+    }
+  }
+  if (node.required !== undefined) {
+    if (!Array.isArray(node.required) || node.required.some((item) => typeof item !== 'string')) {
+      throw new Error(`${path}.required must be an array of property names`);
+    }
+    if (new Set(node.required).size !== node.required.length) {
+      throw new Error(`${path}.required must not contain duplicate property names`);
+    }
+    if (node.required.some((name) => !isPlainObject(node.properties) || !(name in node.properties))) {
+      throw new Error(`${path}.required may reference only declared properties`);
+    }
+  }
+  if (node.additionalProperties !== undefined && typeof node.additionalProperties !== 'boolean') {
+    throw new Error(`${path}.additionalProperties must be a boolean`);
+  }
+  if (node.items !== undefined) {
+    inspectSchemaNode(node.items, `${path}.items`, depth + 1, state);
+  }
+  if (node.enum !== undefined && (!Array.isArray(node.enum) || node.enum.length === 0)) {
+    throw new Error(`${path}.enum must be a non-empty array`);
+  }
+  for (const key of ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum']) {
+    if (node[key] !== undefined) assertFiniteNumber(node[key], `${path}.${key}`);
+  }
+  for (const key of ['minLength', 'maxLength', 'minItems', 'maxItems']) {
+    if (node[key] !== undefined) assertNonNegativeInteger(node[key], `${path}.${key}`);
+  }
+}
+
+function prepareStructuredResponseFormat(responseFormat, compileValidator) {
+  if (responseFormat === undefined) return undefined;
+  if (!isPlainObject(responseFormat)) throw new Error('response_format must be an object');
+  const keys = Object.keys(responseFormat);
+  if (keys.some((key) => key !== 'name' && key !== 'schema')) {
+    throw new Error('response_format accepts only name and schema');
+  }
+  if (typeof responseFormat.name !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/u.test(responseFormat.name)) {
+    throw new Error('response_format.name must start with a letter and contain at most 64 letters, digits, underscores, or hyphens');
+  }
+  if (!isPlainObject(responseFormat.schema) || responseFormat.schema.type !== 'object') {
+    throw new Error('response_format.schema root must have type "object"');
+  }
+
+  let serializedSchema;
+  try {
+    serializedSchema = JSON.stringify(responseFormat.schema);
+  } catch (error) {
+    throw new Error(`response_format.schema must be JSON-serializable: ${boundedText(error)}`);
+  }
+  if (Buffer.byteLength(serializedSchema, 'utf8') > MAX_SCHEMA_BYTES) {
+    throw new Error(`response_format.schema exceeds ${MAX_SCHEMA_BYTES} bytes`);
+  }
+  const schema = JSON.parse(serializedSchema);
+  inspectSchemaNode(schema, 'response_format.schema', 1, { nodes: 0 });
+  if (typeof compileValidator !== 'function') throw new Error('response_format validator compiler is unavailable');
+
+  let validator;
+  try {
+    validator = compileValidator(schema);
+  } catch (error) {
+    throw new Error(`response_format.schema could not be compiled: ${boundedText(error)}`);
+  }
+  if (typeof validator !== 'function') throw new Error('response_format validator compiler returned no validator');
+  return Object.freeze({
+    name: responseFormat.name,
+    schema: Object.freeze(schema),
+    serializedSchema,
+    validator,
+  });
+}
+
+function formatValidatorErrors(errors) {
+  if (!Array.isArray(errors) || errors.length === 0) return 'value does not match response_format.schema';
+  return boundedText(errors.map((error) => {
+    const path = typeof error?.instancePath === 'string' && error.instancePath.length > 0
+      ? error.instancePath
+      : '$';
+    if (error?.keyword === 'required' && typeof error?.params?.missingProperty === 'string') {
+      return `${path} must have required property ${JSON.stringify(error.params.missingProperty)}`;
+    }
+    if (error?.keyword === 'additionalProperties' && typeof error?.params?.additionalProperty === 'string') {
+      return `${path} must not have additional property ${JSON.stringify(error.params.additionalProperty)}`;
+    }
+    return `${path} ${error?.message || 'is invalid'}`;
+  }).join('; '));
+}
+
+function validateStructuredSubagentOutput(text, prepared) {
+  if (typeof text !== 'string') return { ok: false, error: 'final response is not text' };
+  if (Buffer.byteLength(text, 'utf8') > MAX_OUTPUT_BYTES) {
+    return { ok: false, error: `final response exceeds ${MAX_OUTPUT_BYTES} bytes` };
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return { ok: false, error: `final response is not exactly one JSON value: ${boundedText(error)}` };
+  }
+  try {
+    if (!prepared.validator(value)) {
+      return { ok: false, error: formatValidatorErrors(prepared.validator.errors) };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      validatorException: true,
+      error: `response_format validator exception: ${boundedText(error)}`,
+    };
+  }
+  return { ok: true, value };
+}
+
+function buildStructuredResponseFormatReminder(prepared) {
+  return [
+    `Your final assistant message for this run must be exactly one JSON object matching response format ${JSON.stringify(prepared.name)}.`,
+    'Do not wrap it in Markdown, a code fence, XML, or explanatory prose.',
+    'Tool use and intermediate work remain unchanged. This schema grants no additional capability.',
+    `JSON Schema: ${prepared.serializedSchema}`,
+  ].join('\n');
+}
+
+function buildStructuredResponseRepairPrompt(prepared, error) {
+  return [
+    'Your previous final response did not satisfy the required response format.',
+    `Validation error: ${boundedText(error)}`,
+    `Return exactly one corrected JSON object for ${JSON.stringify(prepared.name)} and nothing else.`,
+    `JSON Schema: ${prepared.serializedSchema}`,
+  ].join('\n');
+}
+
+function safeTokenCount(value) {
+  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+
+function buildStructuredSubagentEnvelope({ agentId, profileName, responseFormat, result, usage }) {
+  return JSON.stringify({
+    agent_id: agentId,
+    actual_subagent_type: profileName,
+    status: 'completed',
+    response_format: responseFormat.name,
+    result,
+    usage: {
+      input: safeTokenCount(usage?.inputOther),
+      output: safeTokenCount(usage?.output),
+      cache_read: safeTokenCount(usage?.inputCacheRead),
+      cache_write: safeTokenCount(usage?.inputCacheCreation),
+    },
+  });
+}
+
+module.exports = {
+  MAX_SCHEMA_BYTES,
+  MAX_OUTPUT_BYTES,
+  MAX_SCHEMA_DEPTH,
+  MAX_SCHEMA_NODES,
+  STRUCTURED_SUBAGENT_OUTPUT_ERROR,
+  prepareStructuredResponseFormat,
+  validateStructuredSubagentOutput,
+  buildStructuredResponseFormatReminder,
+  buildStructuredResponseRepairPrompt,
+  buildStructuredSubagentEnvelope,
+};

package/bin/telegram-direct-focus-policy.cjs

@@ -10,6 +10,9 @@ const CONVERSATION_CLOSE = /^(?:danke(?: dir)?|dankesch(?:oe|\u00f6)n|alles klar
 const EXPLICIT_PAUSE = /^(?:(?:bitte\s+)?(?:pause|pausier(?:e)?|stop|stopp|warte|halt(?:e)?\s+an|nicht\s+weiter(?:machen)?))(?:[\s.!?,].*)?$/iu;
 const DIRECT_TELEGRAM_CHANNEL = /<channel\b(?=[^>]*\bsource=["']telegram["'])(?=[^>]*\bpriority=["']direct["'])[^>]*>/iu;
 const TELEGRAM_REPLY_TOOL = /^mcp__[^\s]*telegram[^\s]*__reply$/iu;
+const DIRECT_CHANNEL_PAYLOAD = /<channel\b(?=[^>]*\bsource=["']telegram["'])(?=[^>]*\bpriority=["']direct["'])[^>]*>([\s\S]*?)<\/channel>/giu;
+const DIRECT_WORK_INTENT = /\b(?:auftrag|arbeite|bau(?:e|en)?|build|check|continue|edit|feuer\s+frei|fix|fortsetzen|implement|install|lies|mach(?:e)?\s+weiter|mess|patch|pruef|resume|run|schreib|starte?|test|update|weiterarbeiten|weiterbauen|write)\b/iu;
+const DIRECT_WORK_PAUSE = /\b(?:halt(?:e)?\s+an|nicht\s+weiter(?:machen)?|pause|pausier(?:e)?|stop|stopp|warte)\b/iu;
 
 function isPrivateTelegramChat(chatId) {
   return /^[1-9]\d*$/u.test(String(chatId ?? '').trim());
@@ -55,8 +58,26 @@ function isExplicitPauseRequest(text) {
   return EXPLICIT_PAUSE.test(String(text ?? '').trim());
 }
 
+function directTelegramPayloadText(inputText) {
+  const matches = [...String(inputText ?? '').matchAll(DIRECT_CHANNEL_PAYLOAD)];
+  return String(matches.at(-1)?.[1] ?? '').trim();
+}
+
+function directMessageAllowsWorkContinuation(inputText) {
+  if (!DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''))) return false;
+  const payload = directTelegramPayloadText(inputText);
+  return payload.length > 0 && !DIRECT_WORK_PAUSE.test(payload);
+}
+
+function directMessageStartsOrResumesWork(inputText) {
+  if (!directMessageAllowsWorkContinuation(inputText)) return false;
+  const payload = directTelegramPayloadText(inputText);
+  return isResumeApproval(payload) || DIRECT_WORK_INTENT.test(payload);
+}
+
 function createDirectReplyTurnStop(inputText) {
-  const direct = DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''));
+  const direct = DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''))
+    && !directMessageStartsOrResumesWork(inputText);
   let delivered = false;
   return {
     noteToolResult(toolName, isError) {
@@ -236,6 +257,9 @@ module.exports = {
   DEFAULT_SILENCE_MS,
   createDirectFocusController,
   createDirectReplyTurnStop,
+  directMessageAllowsWorkContinuation,
+  directMessageStartsOrResumesWork,
+  directTelegramPayloadText,
   directFocusCheckpointPath,
   enqueueTelegramDirect,
   isConversationClose,