blun-king-cli 9.1.342 → 9.1.344

package/bin/cognitive-turn-lifecycle.cjs

@@ -198,6 +198,50 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     ]);
   }
 
+  function recordToolBatch(input) {
+    if (!exactKeys(input, new Set(['turnId', 'entries']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    if (turnId === null || !Array.isArray(input.entries) || input.entries.length < 1 || input.entries.length > 10) {
+      fail('COGNITIVE_LIFECYCLE_INVALID');
+    }
+    const observations = [];
+    const stageParts = [];
+    for (const entry of input.entries) {
+      const { toolCallId, toolName, callKey } = toolFields(
+        { turnId, ...entry },
+        new Set(['turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs']),
+      );
+      const decision = String(entry.decision ?? '');
+      const outcome = String(entry.outcome ?? '');
+      const durationMs = Number(entry.durationMs);
+      if (!TOOL_POLICY_DECISIONS.has(decision) || !TOOL_OUTCOMES.has(outcome)
+          || !Number.isSafeInteger(durationMs) || durationMs < 0) fail('COGNITIVE_LIFECYCLE_INVALID');
+      stageParts.push(`${toolCallId}:${decision}:${outcome}:${durationMs}`);
+      observations.push({
+        domain: 'world',
+        key: `turn:${turnId}:${callKey}:tool-policy`,
+        value: `${decision}:runtime_tool_policy:${toolName}`,
+        confidence: 1,
+        scope: 'runtime',
+      }, {
+        domain: 'expected_evidence',
+        key: `turn:${turnId}:${callKey}:tool-result`,
+        value: `${outcome}:${durationMs}ms:${toolName}`,
+        confidence: 1,
+        scope: 'runtime',
+      }, {
+        domain: 'next_trigger',
+        key: `turn:${turnId}:${callKey}:tool-next`,
+        value: outcome === 'success' ? 'continue-after-tool' : 'inspect-tool-failure',
+        confidence: 1,
+        scope: 'runtime',
+      });
+    }
+    const batchKey = digestId('toolbatch', stageParts);
+    const result = commitStage(`turn-${turnId}-${batchKey}`, observations);
+    return { ...result, events: 1, entries: input.entries.length };
+  }
+
   function projectForTurn(input) {
     if (!exactKeys(input, new Set(['turnId', 'focusScopes']))) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
@@ -226,6 +270,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     recordRightsCheck,
     recordToolPolicy,
     recordToolResult,
+    recordToolBatch,
     recordFocusSnapshot,
     authorizeAttention,
     projectForTurn,

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

@@ -8,6 +8,8 @@ const DEFAULT_SILENCE_MS = 60_000;
 const RESUME_APPROVAL = /^(?:ja|yes|weiter|mach(?:e)? weiter|du kannst weiter(?:machen)?|bitte weiter|fortsetzen|resume|go)(?:[\s.!?,].*)?$/iu;
 const CONVERSATION_CLOSE = /^(?:danke(?: dir)?|dankesch(?:oe|\u00f6)n|alles klar|ok(?:ay)?|passt|das war(?:'s| es| alles)|mehr nicht|fertig)(?:[\s.!?,].*)?$/iu;
 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;
 
 function isPrivateTelegramChat(chatId) {
   return /^[1-9]\d*$/u.test(String(chatId ?? '').trim());
@@ -53,6 +55,20 @@ function isExplicitPauseRequest(text) {
   return EXPLICIT_PAUSE.test(String(text ?? '').trim());
 }
 
+function createDirectReplyTurnStop(inputText) {
+  const direct = DIRECT_TELEGRAM_CHANNEL.test(String(inputText ?? ''));
+  let delivered = false;
+  return {
+    noteToolResult(toolName, isError) {
+      if (direct && isError !== true && TELEGRAM_REPLY_TOOL.test(String(toolName ?? ''))) {
+        delivered = true;
+      }
+      return delivered;
+    },
+    shouldStop: () => delivered,
+  };
+}
+
 function createDirectFocusController(options = {}) {
   const setTimer = options.setTimer ?? setTimeout;
   const clearTimer = options.clearTimer ?? clearTimeout;
@@ -213,6 +229,7 @@ function readDirectFocusCheckpoint(env = process.env) {
 module.exports = {
   DEFAULT_SILENCE_MS,
   createDirectFocusController,
+  createDirectReplyTurnStop,
   directFocusCheckpointPath,
   enqueueTelegramDirect,
   isConversationClose,

package/blun.mjs

@@ -261553,6 +261553,8 @@ var init_turn = __esmMin((() => {
 		currentStep = 0;
 		cognitiveLifecycle;
 		cognitiveLifecycleUnavailable = false;
+		cognitiveToolPolicyByCall = /* @__PURE__ */ new Map();
+		cognitiveToolBatchesByTurn = /* @__PURE__ */ new Map();
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261587,6 +261589,40 @@ var init_turn = __esmMin((() => {
 				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: method, error_type: error?.code ?? error?.name ?? "Error" });
 			}
 		}
+		bufferCognitiveToolPolicy(input) {
+			this.cognitiveToolPolicyByCall.set(input.toolCallId, input);
+		}
+		bufferCognitiveToolResult(input) {
+			const policy = this.cognitiveToolPolicyByCall.get(input.toolCallId);
+			if (policy === void 0 || policy.turnId !== input.turnId) {
+				this.recordCognitiveStage("recordToolResult", input);
+				return;
+			}
+			this.cognitiveToolPolicyByCall.delete(input.toolCallId);
+			const entries = this.cognitiveToolBatchesByTurn.get(input.turnId) ?? [];
+			entries.push({
+				toolCallId: input.toolCallId,
+				toolName: input.toolName,
+				decision: policy.decision,
+				outcome: input.outcome,
+				durationMs: input.durationMs
+			});
+			this.cognitiveToolBatchesByTurn.set(input.turnId, entries);
+		}
+		flushCognitiveToolEvidence(turnId, includePending) {
+			const entries = this.cognitiveToolBatchesByTurn.get(turnId) ?? [];
+			this.cognitiveToolBatchesByTurn.delete(turnId);
+			for (let offset = 0; offset < entries.length; offset += 10) this.recordCognitiveStage("recordToolBatch", {
+				turnId,
+				entries: entries.slice(offset, offset + 10)
+			});
+			if (!includePending) return;
+			for (const [toolCallId, policy] of this.cognitiveToolPolicyByCall) {
+				if (policy.turnId !== turnId) continue;
+				this.cognitiveToolPolicyByCall.delete(toolCallId);
+				this.recordCognitiveStage("recordToolPolicy", policy);
+			}
+		}
 		projectCognitiveState(turnId) {
 			try {
 				return this.getCognitiveLifecycle()?.projectForTurn({ turnId }) ?? null;
@@ -261948,6 +261984,7 @@ var init_turn = __esmMin((() => {
 				durationMs: Date.now() - startedAt
 			};
 			this.agent.usage.endTurn();
+			this.flushCognitiveToolEvidence(turnId, true);
 			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			return ended;
@@ -262062,6 +262099,7 @@ var init_turn = __esmMin((() => {
 				mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
 				...this.requestProviderProps()
 			});
+			this.flushCognitiveToolEvidence(turnId, true);
 			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			this.agent.endResponderTurn();
@@ -262140,6 +262178,7 @@ var init_turn = __esmMin((() => {
 		async runStepLoop(turnId, signal, input, origin) {
 			let stopHookContinuationUsed = false;
 			let goalOutcomeMessageContinuationUsed = false;
+			const directReplyTurnStop = createDirectReplyTurnStop(blunExtractText(input));
 			const deduper = new ToolCallDeduplicator({ telemetry: this.agent.telemetry });
 			if (blunTurnNeedsInitialMcp(input, origin)) await this.agent.mcp?.waitForInitialLoad(signal);
 			const personalMemoryRecall = await this.agent.injection.injectPersonalMemoryForTurn(turnId, input, origin, signal);
@@ -262269,13 +262308,14 @@ var init_turn = __esmMin((() => {
 							},
 							afterStep: async ({ usage }) => {
 								previousStepToolOutcome = currentStepHadTool ? currentStepHadFailure ? "failure" : "success" : "none";
+								this.flushCognitiveToolEvidence(turnId, false);
 								this.agent.usage.record(this.agent.activeResponderModel ?? model, usage, "turn");
 								if (stopForGoalBudget) this.setActiveSteerAcceptance(turnId, false);
 								await this.agent.toolResultBatchOffload.detect();
 								await this.agent.fullCompaction.afterStep(signal);
 								if (compactConversationTool !== void 0 && this.agent.fullCompaction.isProactiveCompactionEligible() && !selectedTools.includes(compactConversationTool)) selectedTools.push(compactConversationTool);
 								deduper.endStep();
-								return stopForGoalBudget ? { stopTurn: true } : void 0;
+								return stopForGoalBudget || directReplyTurnStop.shouldStop() ? { stopTurn: true } : void 0;
 							},
 							shouldContinueAfterStop: async (ctx) => {
 								const { signal } = ctx;
@@ -262321,7 +262361,7 @@ var init_turn = __esmMin((() => {
 							authorizeToolExecution: async (ctx) => {
 								try {
 									const resolution = await this.agent.permission.beforeToolCall(ctx);
-									this.recordCognitiveStage("recordToolPolicy", {
+									this.bufferCognitiveToolPolicy({
 										turnId,
 										toolCallId: ctx.toolCall.id,
 										toolName: ctx.toolCall.name,
@@ -262329,7 +262369,7 @@ var init_turn = __esmMin((() => {
 									});
 									return resolution;
 								} catch (error) {
-									this.recordCognitiveStage("recordToolPolicy", {
+									this.bufferCognitiveToolPolicy({
 										turnId,
 										toolCallId: ctx.toolCall.id,
 										toolName: ctx.toolCall.name,
@@ -262343,6 +262383,7 @@ var init_turn = __esmMin((() => {
 								const { isError, output } = finalResult;
 								currentStepHadTool = true;
 								if (isError === true) currentStepHadFailure = true;
+								directReplyTurnStop.noteToolResult(ctx.toolCall.name, isError);
 								const event = isError === true ? "PostToolUseFailure" : "PostToolUse";
 								this.agent.hooks?.fireAndForgetTrigger(event, {
 									matcherValue: ctx.toolCall.name,
@@ -262478,7 +262519,7 @@ var init_turn = __esmMin((() => {
 				};
 				const errorType = outcome === "error" ? telemetryToolErrorType(event.result) : void 0;
 				if (errorType !== void 0) properties["error_type"] = errorType;
-				this.recordCognitiveStage("recordToolResult", {
+				this.bufferCognitiveToolResult({
 					turnId,
 					toolCallId: event.toolCallId,
 					toolName: started.name,
@@ -419037,7 +419078,7 @@ registerUiCatalogFragment({
 */
 var { projectUnaddressedTelegramContext } = createRequire(import.meta.url)("./bin/telegram-context-projection-policy.cjs");
 var { enqueueTelegramUrgent, rewriteTelegramUrgentEnvelope, telegramUrgentMessage } = createRequire(import.meta.url)("./bin/telegram-urgent-policy.cjs");
-var { createDirectFocusController, enqueueTelegramDirect, readDirectFocusCheckpoint, rewriteTelegramDirectEnvelope, telegramDirectMessage, writeDirectFocusCheckpoint } = createRequire(import.meta.url)("./bin/telegram-direct-focus-policy.cjs");
+var { createDirectFocusController, createDirectReplyTurnStop, enqueueTelegramDirect, readDirectFocusCheckpoint, rewriteTelegramDirectEnvelope, telegramDirectMessage, writeDirectFocusCheckpoint } = createRequire(import.meta.url)("./bin/telegram-direct-focus-policy.cjs");
 var { removeQueuedReloadCommands, removeQueuedSlashCommands } = createRequire(import.meta.url)("./bin/reload-queue-policy.cjs");
 const MAX_BUFFERED_CONTEXT_MESSAGES = 20;
 const MAX_BUFFERED_CONTEXT_CHARS = 24e3;

package/package.json

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