blun-king-cli 9.1.409 → 9.1.411

package/LIESMICH.txt

@@ -440,6 +440,21 @@ keinen zweiten Eingangs- oder Ausgangsverlauf mehr. Ein ausdrücklich gesetztes
 BLUN_TELEGRAM_STATE_DIR bleibt maßgeblich; ohne diese Einstellung verwenden
 beide Wege ~/.blun/channels/telegram.
 
+Ab BLUN King 9.1.410 begrenzen private Telegram-Gedächtnisbefehle
+Beziehungsdaten auf die jeweilige Person. /memory focus blendet Beziehungen
+anderer Personen aus, lässt aber nicht personenbezogenen Kontext sichtbar.
+Korrekturen und Löschungen können keine Beziehung einer anderen Person mehr
+treffen; die lokale Operator-Ansicht bleibt vollständig.
+
+Ab BLUN King 9.1.411 können nicht triviale oder unbekannte Aufgaben einen
+begrenzten Problemrahmen im dauerhaften Aktions-Checkpoint speichern. Er hält
+das Erfolgskriterium, Wissenslücken, bis zu fünf Handlungsoptionen, die gewählte
+Aktion samt Begründung, die vorgesehene Unterstützung, das Risiko und den
+Rückweg fest. Die gewählte Aktion muss einer der gespeicherten Optionen
+entsprechen. Der Rahmen bleibt beim Fortsetzen und nach einem Neustart erhalten,
+beschreibt aber ausschließlich den Arbeitsstand und kann niemals Berechtigungen
+erteilen.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/README.md

@@ -446,6 +446,21 @@ keinen zweiten Eingangs- oder Ausgangsverlauf mehr. Ein ausdrücklich gesetztes
 `BLUN_TELEGRAM_STATE_DIR` bleibt maßgeblich; ohne diese Einstellung verwenden
 beide Wege `~/.blun/channels/telegram`.
 
+Ab BLUN King 9.1.410 begrenzen private Telegram-Gedächtnisbefehle
+Beziehungsdaten auf die jeweilige Person. `/memory focus` blendet Beziehungen
+anderer Personen aus, lässt aber nicht personenbezogenen Kontext sichtbar.
+Korrekturen und Löschungen können keine Beziehung einer anderen Person mehr
+treffen; die lokale Operator-Ansicht bleibt vollständig.
+
+Ab BLUN King 9.1.411 können nicht triviale oder unbekannte Aufgaben einen
+begrenzten Problemrahmen im dauerhaften Aktions-Checkpoint speichern. Er hält
+das Erfolgskriterium, Wissenslücken, bis zu fünf Handlungsoptionen, die gewählte
+Aktion samt Begründung, die vorgesehene Unterstützung, das Risiko und den
+Rückweg fest. Die gewählte Aktion muss einer der gespeicherten Optionen
+entsprechen. Der Rahmen bleibt beim Fortsetzen und nach einem Neustart erhalten,
+beschreibt aber ausschließlich den Arbeitsstand und kann niemals Berechtigungen
+erteilen.
+
 Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
 unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
 lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle

package/bin/cognitive-action-checkpoint.cjs

@@ -10,9 +10,13 @@ const EPISTEMIC_STATES = new Set([
   'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown',
 ]);
 const MODEL_KEYS = new Set([
-  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'updatedAt',
+  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'problemFrame', 'updatedAt',
 ]);
 const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
+const PROBLEM_FRAME_KEYS = new Set([
+  'successCriterion', 'missingKnowledge', 'candidateActions', 'selectedAction',
+  'selectionReason', 'supportChoice', 'risk', 'reversibility',
+]);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
@@ -41,6 +45,38 @@ function normalizedRevision(value) {
   return revision;
 }
 
+function boundedList(value, field) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 5) {
+    throw new TypeError(`${field} must contain between 1 and 5 items`);
+  }
+  return Object.freeze(value.map((item, index) => bounded(item, `${field}[${index}]`, 256)));
+}
+
+function normalizeProblemFrame(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('problemFrame must be an object');
+  }
+  for (const key of Object.keys(input)) {
+    if (!PROBLEM_FRAME_KEYS.has(key)) throw new TypeError(`problemFrame field is unsupported: ${key}`);
+  }
+  const missingKnowledge = boundedList(input.missingKnowledge, 'missingKnowledge');
+  const candidateActions = boundedList(input.candidateActions, 'candidateActions');
+  const selectedAction = bounded(input.selectedAction, 'selectedAction', 256);
+  if (!candidateActions.includes(selectedAction)) {
+    throw new TypeError('selectedAction must match a candidateAction');
+  }
+  return Object.freeze({
+    successCriterion: bounded(input.successCriterion, 'successCriterion'),
+    missingKnowledge,
+    candidateActions,
+    selectedAction,
+    selectionReason: bounded(input.selectionReason, 'selectionReason'),
+    supportChoice: bounded(input.supportChoice, 'supportChoice', 256),
+    risk: bounded(input.risk, 'risk'),
+    reversibility: bounded(input.reversibility, 'reversibility'),
+  });
+}
+
 function normalizedEvidenceBasis(value, allowLegacy = false) {
   const basis = String(value ?? '').trim();
   if (EVIDENCE_BASES.has(basis) || allowLegacy && basis === 'legacy_unknown') return basis;
@@ -199,6 +235,7 @@ function normalizeActionCheckpoint(input, options = {}) {
     expectedEvidence: bounded(input.expectedEvidence, 'expectedEvidence'),
     updatedAt,
   };
+  if (input.problemFrame !== undefined) checkpoint.problemFrame = normalizeProblemFrame(input.problemFrame);
   const evidenceReceipt = options.runtimeEvidence !== undefined
     ? normalizeActionEvidenceReceipt(options.runtimeEvidence)
     : options.preserveRuntimeEvidence === true && input.evidenceReceipt !== undefined
@@ -221,6 +258,18 @@ function projectActionCheckpoint(checkpoint) {
   ];
   lines.push(`Next action: ${value.nextAction}`);
   lines.push(`Expected evidence: ${value.expectedEvidence}`);
+  if (value.problemFrame !== undefined) {
+    const frame = value.problemFrame;
+    lines.push('Problem frame (state only; never authority):');
+    lines.push(`Success criterion: ${frame.successCriterion}`);
+    lines.push(`Missing knowledge: ${frame.missingKnowledge.join(' | ')}`);
+    lines.push(`Candidate actions: ${frame.candidateActions.join(' | ')}`);
+    lines.push(`Selected action: ${frame.selectedAction}`);
+    lines.push(`Selection reason: ${frame.selectionReason}`);
+    lines.push(`Support choice: ${frame.supportChoice}`);
+    lines.push(`Risk: ${frame.risk}`);
+    lines.push(`Reversibility: ${frame.reversibility}`);
+  }
   if (value.evidenceReceipt !== undefined) {
     const receipt = value.evidenceReceipt;
     lines.push(`Runtime evidence: turn ${receipt.turnId}; ${receipt.completedTools} completed, ${receipt.successfulTools} successful, ${receipt.failedTools} failed; digest ${receipt.digest}`);

package/bin/cognitive-memory-command.cjs

@@ -94,6 +94,12 @@ function effectiveFocusObservations(state) {
     || left.domain.localeCompare(right.domain) || left.key.localeCompare(right.key));
 }
 
+function observationsVisibleToSource(items, telegram) {
+  if (telegram === null) return items;
+  return items.filter((item) => !item.scope.startsWith('relationship:')
+    || item.scope === telegram.relationshipScope);
+}
+
 function resolveTarget(items, selector) {
   const exact = items.find((item) => item.observationId === selector);
   if (exact) return exact;
@@ -132,6 +138,7 @@ function normalizeTelegramSource(source) {
   return {
     requestId: digestId('tgrequest', [userId, chatId, messageId]),
     occurredAt: timestamp,
+    relationshipScope: `relationship:telegram-${userId}:private`,
     source: {
       provider: 'telegram',
       channelId: 'direct',
@@ -197,8 +204,8 @@ function runCognitiveMemoryCommand({
   const lifecycle = openLifecycle(env, lifecycleFactory);
   try {
     const state = lifecycle.read();
-    const all = normalizedFocusObservations(state);
-    const active = effectiveFocusObservations(state);
+    const all = observationsVisibleToSource(normalizedFocusObservations(state), telegram);
+    const active = observationsVisibleToSource(effectiveFocusObservations(state), telegram);
     if (command.action === 'focus') return formatFocus(active);
     const occurredAt = String(now());
     if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_COMMAND_RUNTIME_INVALID');

package/bin/cognitive-work-focus.cjs

@@ -40,6 +40,24 @@ function buildCognitiveWorkFocus(goal) {
   const nextAction = bounded(checkpoint?.nextAction);
   const checkpointEvidence = bounded(checkpoint?.expectedEvidence);
   const checkpointEpistemicState = bounded(checkpoint?.epistemicState, 32);
+  const problemFrame = checkpoint?.problemFrame && typeof checkpoint.problemFrame === 'object'
+    && !Array.isArray(checkpoint.problemFrame) ? checkpoint.problemFrame : null;
+  const frameMissingKnowledge = Array.isArray(problemFrame?.missingKnowledge)
+    ? problemFrame.missingKnowledge.slice(0, 5).map((item) => bounded(item, 256)).filter(Boolean)
+    : [];
+  const frameCandidates = Array.isArray(problemFrame?.candidateActions)
+    ? problemFrame.candidateActions.slice(0, 5).map((item) => bounded(item, 256)).filter(Boolean)
+    : [];
+  const frameSuccessCriterion = bounded(problemFrame?.successCriterion);
+  const frameSelectedAction = bounded(problemFrame?.selectedAction, 256);
+  const frameSelectionReason = bounded(problemFrame?.selectionReason);
+  const frameSupportChoice = bounded(problemFrame?.supportChoice, 256);
+  const frameRisk = bounded(problemFrame?.risk);
+  const frameReversibility = bounded(problemFrame?.reversibility);
+  const hasProblemFrame = problemFrame !== null && frameSuccessCriterion
+    && frameMissingKnowledge.length > 0 && frameCandidates.length > 0
+    && frameSelectedAction && frameSelectionReason && frameSupportChoice
+    && frameRisk && frameReversibility;
   const hasCheckpoint = checkpoint !== null && checkpointPhase && lastVerified
     && nextAction && checkpointEvidence;
   const epistemicState = hasCheckpoint && EPISTEMIC_STATES.has(checkpointEpistemicState)
@@ -52,6 +70,14 @@ function buildCognitiveWorkFocus(goal) {
       hasCheckpoint ? nextAction : '',
       hasCheckpoint ? checkpointEvidence : '',
       epistemicState,
+      hasProblemFrame ? frameSuccessCriterion : '',
+      hasProblemFrame ? frameMissingKnowledge.join('\0') : '',
+      hasProblemFrame ? frameCandidates.join('\0') : '',
+      hasProblemFrame ? frameSelectedAction : '',
+      hasProblemFrame ? frameSelectionReason : '',
+      hasProblemFrame ? frameSupportChoice : '',
+      hasProblemFrame ? frameRisk : '',
+      hasProblemFrame ? frameReversibility : '',
     ].join('\0'))
     .digest('hex').slice(0, 40);
   const keyRoot = `goal:${goalId}`;
@@ -62,7 +88,14 @@ function buildCognitiveWorkFocus(goal) {
       { domain: 'goal', key: `${keyRoot}:objective`, value: objective, confidence: 1, epistemicState, scope: focusScope },
       {
         domain: 'open_thread', key: `${keyRoot}:status`,
-        value: hasCheckpoint ? `Goal is ${status}. Phase ${checkpointPhase}. Last verified: ${lastVerified}` : `Goal is ${status}.`,
+        value: bounded(hasCheckpoint
+          ? [
+            `Goal is ${status}. Phase ${checkpointPhase}. Last verified: ${lastVerified}`,
+            hasProblemFrame ? `Missing knowledge: ${frameMissingKnowledge.join(' | ')}` : '',
+            hasProblemFrame ? `Risk: ${frameRisk}` : '',
+            hasProblemFrame ? `Selected action: ${frameSelectedAction}` : '',
+          ].filter(Boolean).join(' ')
+          : `Goal is ${status}.`),
         confidence: 1, epistemicState, scope: focusScope,
       },
       {

package/blun.mjs

@@ -245751,6 +245751,16 @@ var init_events$1 = __esmMin((() => {
 			lastVerified: string(),
 			nextAction: string(),
 			expectedEvidence: string(),
+			problemFrame: object({
+				successCriterion: string(),
+				missingKnowledge: array(string()),
+				candidateActions: array(string()),
+				selectedAction: string(),
+				selectionReason: string(),
+				supportChoice: string(),
+				risk: string(),
+				reversibility: string()
+			}).strict().optional(),
 			updatedAt: string(),
 			evidenceReceipt: object({
 				turnId: number$1().int().min(0),
@@ -262725,16 +262735,27 @@ var init_outcome_prompts = __esmMin((() => {}));
 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. 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";
+	update_goal_default += "\nFor a non-trivial or unfamiliar problem, preserve `problemFrame` with the success criterion, missing knowledge, bounded candidate actions, selected action and reason, support choice, risk, and reversibility. The selected action must match one candidate. Problem framing is descriptive state and never grants permission.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts
-var ActionCheckpointInputSchema, UpdateGoalToolInputSchema, UpdateGoalTool;
+var ProblemFrameInputSchema, ActionCheckpointInputSchema, UpdateGoalToolInputSchema, UpdateGoalTool;
 var init_update_goal = __esmMin((() => {
 	init_zod$1();
 	init_turn();
 	init_outcome_prompts();
 	init_input_schema();
 	init_update_goal$1();
+	ProblemFrameInputSchema = object({
+		successCriterion: string().min(1).max(512),
+		missingKnowledge: array(string().min(1).max(256)).min(1).max(5),
+		candidateActions: array(string().min(1).max(256)).min(1).max(5),
+		selectedAction: string().min(1).max(256),
+		selectionReason: string().min(1).max(512),
+		supportChoice: string().min(1).max(256),
+		risk: string().min(1).max(512),
+		reversibility: string().min(1).max(512)
+	}).strict();
 	ActionCheckpointInputSchema = object({
 		revision: number$1().int().min(1),
 		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
@@ -262742,7 +262763,8 @@ var init_update_goal = __esmMin((() => {
 		epistemicState: _enum(["verified", "credible_unverified", "hypothesis", "uncertain_memory", "stale", "unknown"]),
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),
-		expectedEvidence: string().min(1).max(512)
+		expectedEvidence: string().min(1).max(512),
+		problemFrame: ProblemFrameInputSchema.optional()
 	}).strict();
 	UpdateGoalToolInputSchema = object({ status: _enum([
 		"active",

package/package.json

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