blun-king-cli 9.1.395 → 9.1.397

package/LIESMICH.txt

@@ -364,6 +364,34 @@ Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
 verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
 die Medienerzeugung sei nicht verfügbar.
 
+Passende Werkzeuge ohne Such-Zwischenschritt
+---------------------------------------------
+
+Ab BLUN King 9.1.396 vergleicht King die aktuelle Anfrage mit den bereits
+registrierten Werkzeugbeschreibungen. Bei eindeutiger Übereinstimmung lädt er
+für diesen Zug höchstens zwei passende, sonst zurückgestellte Schemata direkt.
+Name, Beschreibung, Parameterhinweise und Beispiele dürfen zur Auswahl
+beitragen; frühere Nachrichten außerhalb des aktuellen Telegram-Kanalblocks
+zählen nicht als neue Absicht.
+
+ToolSearch bleibt für unklare, unbekannte und mehrdeutige Anfragen vollständig
+verfügbar. Eine automatische Auswahl wird nicht dauerhaft gespeichert und
+vergrößert den residenten Werkzeugsatz nicht. Dadurch kann eine natürliche
+Anweisung wie "Zeig mir den letzten Telegram-Verlauf" das passende Werkzeug im
+selben Modellschritt erhalten, während Begrüßungen und fachfremde Anfragen keine
+zusätzlichen Schemata laden.
+
+Abschlussbedingungen mit Laufzeitbeleg
+--------------------------------------
+
+Ab BLUN King 9.1.397 kann ein autonomes Ziel mit ausdrücklich gesetzter
+Abschlussbedingung nicht mehr allein aufgrund einer Textbehauptung als fertig
+markiert werden. Vor dem Abschluss muss ein aktueller Prüf-Checkpoint vorliegen,
+der auf mindestens einem erfolgreichen Laufzeitwerkzeug beruht und als verifiziert
+eingestuft ist. Fehlt dieser Beleg, bleibt das Ziel aktiv und King erhält eine
+konkrete Nachbesserung statt einer falschen Fertigmeldung. Ziele ohne ausdrücklich
+gesetzte Abschlussbedingung behalten ihr bisheriges Verhalten.
+
 Angehängte Bilder werden weiterhin mit ReadMediaFile gelesen. Bild-, Video- und
 Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. GenerateVideo kann außerdem einen abgeschlossenen Bildauftrag

package/README.md

@@ -375,6 +375,32 @@ Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
 verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
 die Medienerzeugung sei nicht verfügbar.
 
+## Passende Werkzeuge ohne Such-Zwischenschritt
+
+Ab BLUN King 9.1.396 vergleicht King die aktuelle Anfrage mit den bereits
+registrierten Werkzeugbeschreibungen. Bei eindeutiger Übereinstimmung lädt er
+für diesen Zug höchstens zwei passende, sonst zurückgestellte Schemata direkt.
+Name, Beschreibung, Parameterhinweise und Beispiele dürfen zur Auswahl
+beitragen; frühere Nachrichten außerhalb des aktuellen Telegram-Kanalblocks
+zählen nicht als neue Absicht.
+
+`ToolSearch` bleibt für unklare, unbekannte und mehrdeutige Anfragen vollständig
+verfügbar. Eine automatische Auswahl wird nicht dauerhaft gespeichert und
+vergrößert den residenten Werkzeugsatz nicht. Dadurch kann eine natürliche
+Anweisung wie „Zeig mir den letzten Telegram-Verlauf“ das passende Werkzeug im
+selben Modellschritt erhalten, während Begrüßungen und fachfremde Anfragen keine
+zusätzlichen Schemata laden.
+
+## Abschlussbedingungen mit Laufzeitbeleg
+
+Ab BLUN King 9.1.397 kann ein autonomes Ziel mit ausdrücklich gesetzter
+Abschlussbedingung nicht mehr allein aufgrund einer Textbehauptung als fertig
+markiert werden. Vor dem Abschluss muss ein aktueller Prüf-Checkpoint vorliegen,
+der auf mindestens einem erfolgreichen Laufzeitwerkzeug beruht und als verifiziert
+eingestuft ist. Fehlt dieser Beleg, bleibt das Ziel aktiv und King erhält eine
+konkrete Nachbesserung statt einer falschen Fertigmeldung. Ziele ohne ausdrücklich
+gesetzte Abschlussbedingung behalten ihr bisheriges Verhalten.
+
 Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
 und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
 nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag

package/bin/goal-completion-evidence-policy.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+function hasCompletionCriterion(goal) {
+  return typeof goal?.completionCriterion === 'string'
+    && goal.completionCriterion.trim().length > 0;
+}
+
+function successfulRuntimeEvidence(checkpoint) {
+  const successfulTools = Number(checkpoint?.evidenceReceipt?.successfulTools);
+  return Number.isSafeInteger(successfulTools) && successfulTools > 0;
+}
+
+function evaluateGoalCompletionEvidence(goal) {
+  if (!hasCompletionCriterion(goal)) {
+    return {
+      required: false,
+      allPassed: true,
+      result: 'satisfied',
+      gaps: [],
+    };
+  }
+
+  const checkpoint = goal?.actionCheckpoint;
+  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) {
+    return {
+      required: true,
+      allPassed: false,
+      result: 'needs_revision',
+      gaps: ['Save a verify-phase action checkpoint before completing the goal.'],
+    };
+  }
+
+  const gaps = [];
+  if (checkpoint.phase !== 'verify') {
+    gaps.push('The latest action checkpoint must be in the verify phase.');
+  }
+  if (checkpoint.evidenceBasis !== 'runtime_tool') {
+    gaps.push('The completion proof must come from a runtime tool.');
+  }
+  if (checkpoint.epistemicState !== 'verified') {
+    gaps.push('The completion proof must be classified as verified.');
+  }
+  if (!successfulRuntimeEvidence(checkpoint)) {
+    gaps.push('The runtime evidence receipt must contain at least one successful tool result.');
+  }
+
+  return {
+    required: true,
+    allPassed: gaps.length === 0,
+    result: gaps.length === 0 ? 'satisfied' : 'needs_revision',
+    gaps,
+  };
+}
+
+module.exports = {
+  evaluateGoalCompletionEvidence,
+};

package/bin/turn-tool-performance-policy.cjs

@@ -5,13 +5,20 @@ const TOOL_SCHEMA_MAX_TOKENS = 32_000;
 const DEFERRED_TOOL_LOADER_NAME = 'ToolSearch';
 const MAX_PERSISTENT_DEFERRED_TOOLS = 4;
 const MAX_TOOL_SEARCH_QUERY_CHARS = 1_000;
+const MAX_AUTO_RANKED_TOOLS = 2;
+const TOOL_RANK_STOP_WORDS = new Set([
+  'aber', 'also', 'and', 'aus', 'bitte', 'can', 'das', 'den', 'der', 'des', 'die', 'dies', 'diese',
+  'du', 'ein', 'eine', 'einer', 'eines', 'for', 'fuer', 'für', 'haben', 'ich', 'ist', 'kann', 'kannst',
+  'mal', 'me', 'mein', 'meine', 'mir', 'mit', 'of', 'please', 'soll', 'the', 'und', 'uns', 'von',
+  'was', 'wir', 'with', 'you', 'zeige', 'zeig', 'pruefe', 'prüfe', 'lies', 'read', 'show', 'get',
+]);
 const TOOL_SEARCH_INTENT_WORDS = new Set([
   'find', 'fetch', 'get', 'holen', 'list', 'read', 'search', 'show', 'anzeigen', 'lesen', 'suchen',
 ]);
 const TOOL_SEARCH_RELATED_TERM_GROUPS = Object.freeze([
   Object.freeze([
     'current', 'inbox', 'latest', 'message', 'messages', 'nachricht', 'nachrichten', 'queue', 'queued',
-    'recent', 'update', 'updates',
+    'recent', 'letzte', 'letzten', 'letzter', 'vergangen', 'update', 'updates',
   ]),
   Object.freeze([
     'chat', 'conversation', 'history', 'log', 'logs', 'processed', 'protokoll', 'transcript', 'verlauf',
@@ -165,6 +172,96 @@ function relatedSearchTerms(token) {
   return group || [token];
 }
 
+function rankingIntentTexts(value) {
+  const text = String(value || '');
+  const channelBodies = [...text.matchAll(
+    /(?:^|\r?\n)<channel\b[^>]*>\r?\n([\s\S]*?)\r?\n<\/channel>(?=\r?\n|$)/giu,
+  )].map((match) => match[1]);
+  return channelBodies.length > 0 ? channelBodies : [text];
+}
+
+function rankingTokens(value) {
+  return [...new Set(String(value || '')
+    .normalize('NFKC')
+    .toLowerCase()
+    .match(/[\p{L}\p{N}]{3,}/gu) || [])]
+    .filter((token) => !TOOL_RANK_STOP_WORDS.has(token));
+}
+
+function toolRankingDocument(tool) {
+  const name = String(tool?.name || '');
+  const leaf = name.split(/__|:/).at(-1) || name;
+  const nameTokens = rankingTokens(`${name.replaceAll('_', ' ')} ${leaf.replaceAll('_', ' ')}`);
+  const descriptionTokens = rankingTokens(tool?.description);
+  const parameterText = [];
+  const properties = tool?.parameters?.properties;
+  if (properties && typeof properties === 'object') {
+    for (const [parameterName, definition] of Object.entries(properties)) {
+      parameterText.push(parameterName, definition?.description || '');
+    }
+  }
+  const exampleText = Array.isArray(tool?.examples)
+    ? tool.examples.map((example) => example?.prompt || '').join(' ')
+    : '';
+  return {
+    name,
+    nameTokens: new Set(nameTokens),
+    descriptionTokens: new Set(descriptionTokens),
+    detailTokens: new Set(rankingTokens(`${parameterText.join(' ')} ${exampleText}`)),
+  };
+}
+
+function tokenMatchScore(document, token) {
+  if (document.nameTokens.has(token)) return 10;
+  if (document.descriptionTokens.has(token)) return 5;
+  if (document.detailTokens.has(token)) return 4;
+  const related = relatedSearchTerms(token).filter((term) => term !== token);
+  if (related.some((term) => document.nameTokens.has(term))) return 5;
+  if (related.some((term) => document.descriptionTokens.has(term))) return 3;
+  if (related.some((term) => document.detailTokens.has(term))) return 2;
+  return 0;
+}
+
+/**
+ * Select a tiny, high-confidence subset of deferred schemas for the current
+ * request. This mirrors AnythingLLM's tool-reranker boundary without adding an
+ * embedding runtime: King reuses the descriptions it already owns and keeps
+ * ToolSearch available whenever the lexical evidence is weak or ambiguous.
+ */
+function rankedToolNamesForTurnText(tools, value, options = {}) {
+  const maxTools = Math.max(0, Math.min(
+    MAX_AUTO_RANKED_TOOLS,
+    Number.isInteger(options.maxTools) ? options.maxTools : MAX_AUTO_RANKED_TOOLS,
+  ));
+  if (maxTools === 0) return new Set();
+  const queryTokens = [...new Set(rankingIntentTexts(value).flatMap(rankingTokens))];
+  if (queryTokens.length === 0) return new Set();
+
+  const ranked = (Array.isArray(tools) ? tools : []).map((tool) => {
+    const document = toolRankingDocument(tool);
+    if (!document.name) return null;
+    let score = 0;
+    let matchedTokens = 0;
+    let exactNameMatches = 0;
+    for (const token of queryTokens) {
+      const tokenScore = tokenMatchScore(document, token);
+      if (tokenScore === 0) continue;
+      score += tokenScore;
+      matchedTokens += 1;
+      if (document.nameTokens.has(token)) exactNameMatches += 1;
+    }
+    const highConfidence = matchedTokens >= 2 || (exactNameMatches >= 1 && score >= 10);
+    return highConfidence ? { name: document.name, score, matchedTokens, exactNameMatches } : null;
+  }).filter(Boolean).sort((left, right) => (
+    right.matchedTokens - left.matchedTokens
+    || right.score - left.score
+    || right.exactNameMatches - left.exactNameMatches
+    || left.name.localeCompare(right.name)
+  ));
+
+  return new Set(ranked.slice(0, maxTools).map((entry) => entry.name));
+}
+
 function searchRelatedDeferredTools(tools, query, options = {}) {
   const normalized = normalizeDeferredToolQuery(query).toLowerCase();
   if (!normalized || normalized.startsWith('select:')) return [];
@@ -351,6 +448,7 @@ module.exports = {
   mediaGenerationToolNamesForText,
   mediaToolNamesForTurnText,
   normalizeDeferredToolQuery,
+  rankedToolNamesForTurnText,
   rememberDeferredToolAfterNotFound,
   toolSchemaBudgetTokens,
 };

package/blun.mjs

@@ -21447,6 +21447,7 @@ var { projectSoulText } = createRequire(import.meta.url)("./bin/soul-organizatio
 var { soulFileInstruction } = createRequire(import.meta.url)("./bin/soul-preservation-policy.cjs");
 var { readProfilePersona, resolveSoulFile } = createRequire(import.meta.url)("./bin/profile-identity-resolution.cjs");
 var { advanceActionEvidenceReceipt, assertActionCheckpointEvidenceBasis, assertActionCheckpointRevision, emptyActionEvidenceReceipt, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
+var { evaluateGoalCompletionEvidence } = createRequire(import.meta.url)("./bin/goal-completion-evidence-policy.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
 	const additionalDirs = normalizeAdditionalDirs(options?.additionalDirs ?? []);
 	const [cwdListing, agentsMdResult, additionalDirsInfo] = await Promise.all([
@@ -230394,6 +230395,10 @@ var init_goal$1 = __esmMin((() => {
 		async markComplete(input = {}, actor = "model") {
 			const state = this.state;
 			if (state === void 0 || state.status !== "active") return null;
+			const completionEvidence = evaluateGoalCompletionEvidence(state);
+			if (!completionEvidence.allPassed) {
+				throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Completion criterion needs revision: ${completionEvidence.gaps.join(" ")} Run the required verification, save a runtime-backed verify checkpoint, then mark the goal complete.`);
+			}
 			const mcInjector = this.agent.injection?.getMissionContractInjector();
 			if (mcInjector) {
 				const evaluation = mcInjector.evaluate();
@@ -261514,7 +261519,7 @@ function toolResultText(result) {
 function abandonedToolResultOutput(ended) {
 	return `Tool call did not complete: ${ended.reason === "cancelled" ? "the turn was cancelled" : ended.reason === "failed" ? `the turn failed${ended.error !== void 0 ? ` (${ended.error.message})` : ""}` : "the turn ended"} before its result was recorded. Do not assume the tool completed successfully.`;
 }
-var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -261531,7 +261536,7 @@ var init_turn = __esmMin((() => {
 	init_tool_result_budget();
 	init_user_message_offload();
 	init_assistant_message_offload();
-	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
+	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaToolNamesForTurnText, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	({ projectRecurringCronHistory } = createRequire(import.meta.url)("./bin/recurring-cron-history-policy.cjs"));
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
 	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.cjs"));
@@ -262265,12 +262270,13 @@ var init_turn = __esmMin((() => {
 				variant: "cognitive_continuity"
 			});
 			this.setActiveSteerAcceptance(turnId, true);
+			const turnText = blunExtractText(input);
 			const turnNeedsTools = blunTurnNeedsTools(input, origin);
 			const turnHasAttachment = blunTurnHasAttachment(input);
 			const turnThinkingEffort = turnHasAttachment ? void 0 : selectThinkingEffortForTurn(blunExtractText(blunThinkingIntentInput(input)), origin.kind);
 			const fastConversation = turnThinkingEffort === "off" || turnThinkingEffort === "low";
 			const pendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
-			const requiredToolNames = mediaToolNamesForTurnText(blunExtractText(input));
+			const requiredToolNames = mediaToolNamesForTurnText(turnText);
 			const turnSystemPrompt = pendingMediaJobIds.length > 0 ? blunPendingMediaSystemPrompt(fastConversation ? this.agent.fastConversationSystemPrompt : this.agent.effectiveSystemPrompt, pendingMediaJobIds) : fastConversation ? this.agent.fastConversationSystemPrompt : void 0;
 			const turnLLM = this.agent.llmForTurn(turnThinkingEffort, turnSystemPrompt);
 			let previousStepToolOutcome = "initial";
@@ -262285,10 +262291,13 @@ var init_turn = __esmMin((() => {
 					const originTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
 					const compactConversationTool = originTools.find((tool) => tool.name === "CompactConversation");
 					const eligibleTools = originTools.filter((tool) => tool.name !== "CompactConversation" || this.agent.fullCompaction.isProactiveCompactionEligible());
+					const turnRequiredToolNames = new Set(requiredToolNames);
+					const rankedToolNames = rankedToolNamesForTurnText(eligibleTools, turnText);
+					for (const name of rankedToolNames) turnRequiredToolNames.add(name);
 					const toolSelection = fastConversation ? {
-						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds, requiredToolNames)],
+						tools: [...blunFastConversationTools(eligibleTools, input, pendingMediaJobIds, turnRequiredToolNames)],
 						deferredToolCount: 0
-					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, requiredToolNames) : {
+					} : turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens, this.loadedToolNames, turnRequiredToolNames) : {
 						tools: [],
 						deferredToolCount: 0
 					};
@@ -262356,7 +262365,9 @@ var init_turn = __esmMin((() => {
 								const steerThinkingEffort = "low";
 								const steerPendingMediaJobIds = this.agent.toolServices?.media?.pendingMediaJobIds?.() ?? [];
 								const steerLLM = this.agent.llmForTurn(steerThinkingEffort, blunPendingMediaSystemPrompt(this.agent.fastConversationSystemPrompt, steerPendingMediaJobIds));
-								const steerRequiredToolNames = mediaToolNamesForTurnText(blunExtractText(steerInput));
+								const steerText = blunExtractText(steerInput);
+								const steerRequiredToolNames = mediaToolNamesForTurnText(steerText);
+								for (const name of rankedToolNamesForTurnText(eligibleTools, steerText)) steerRequiredToolNames.add(name);
 								const steerTools = [...blunFastConversationTools(eligibleTools, steerInput, steerPendingMediaJobIds, steerRequiredToolNames)];
 								const steerHistory = () => blunFastConversationHistory(this.agent.context.history);
 								const buildSteerMessages = () => this.agent.context.project(steerHistory(), { dropOrphanResults: true });
@@ -262704,7 +262715,7 @@ var init_outcome_prompts = __esmMin((() => {}));
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.md?raw
 var update_goal_default;
 var init_update_goal$1 = __esmMin((() => {
-	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, and an explicit evidence basis. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
+	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, and an explicit evidence basis. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts

package/package.json

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