blun-king-cli 9.1.410 → 9.1.412

package/LIESMICH.txt

@@ -446,6 +446,27 @@ 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.
+
+Ab BLUN King 9.1.412 beginnt jedes vom Modell angelegte dauerhafte Ziel atomar
+mit Revision 1 und einem vollständigen, begrenzten Problemrahmen im
+Aktions-Checkpoint. Der Rahmen bleibt dadurch sofort erhalten und hängt nicht
+mehr von einem späteren UpdateGoal-Aufruf ab. Im God Mode und im automatischen
+Modus läuft ein bereits autorisierter Zielstart ohne zweite Bestätigung weiter;
+im manuellen Modus bleibt die bestehende Freigabe erhalten. Authentifizierte,
+nicht triviale Mehrschrittaufgaben mit überprüfbarem Endzustand dürfen das
+dauerhafte Ziel auch unter einer bereits geltenden Anweisung zum autonomen
+Weiterarbeiten nutzen. Begrüßungen, gewöhnliche Einzelschrittanfragen und vage
+Aufgaben erzeugen weiterhin kein Ziel. Der Problemrahmen bleibt beschreibender
+Arbeitsstand und erteilt niemals Berechtigungen.
+
 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

@@ -452,6 +452,27 @@ 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.
+
+Ab BLUN King 9.1.412 beginnt jedes vom Modell angelegte dauerhafte Ziel atomar
+mit Revision 1 und einem vollständigen, begrenzten Problemrahmen im
+Aktions-Checkpoint. Der Rahmen bleibt dadurch sofort erhalten und hängt nicht
+mehr von einem späteren `UpdateGoal`-Aufruf ab. Im God Mode und im automatischen
+Modus läuft ein bereits autorisierter Zielstart ohne zweite Bestätigung weiter;
+im manuellen Modus bleibt die bestehende Freigabe erhalten. Authentifizierte,
+nicht triviale Mehrschrittaufgaben mit überprüfbarem Endzustand dürfen das
+dauerhafte Ziel auch unter einer bereits geltenden Anweisung zum autonomen
+Weiterarbeiten nutzen. Begrüßungen, gewöhnliche Einzelschrittanfragen und vage
+Aufgaben erzeugen weiterhin kein Ziel. Der Problemrahmen bleibt beschreibender
+Arbeitsstand und erteilt niemals Berechtigungen.
+
 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-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

@@ -230174,6 +230174,7 @@ var init_goal$1 = __esmMin((() => {
 				wallClockMs: 0,
 				budgetLimits: {}
 			};
+			if (record.actionCheckpoint !== void 0) state.actionCheckpoint = normalizeActionCheckpoint(record.actionCheckpoint, { preserveUpdatedAt: true, preserveRuntimeEvidence: true });
 			this.state = state;
 			this.agent.replayBuilder.push({
 				type: "goal_updated",
@@ -230265,12 +230266,21 @@ var init_goal$1 = __esmMin((() => {
 				wallClockResumedAt: Date.now(),
 				budgetLimits: {}
 			};
+			if (input.actionCheckpoint !== void 0) {
+				assertActionCheckpointRevision(undefined, input.actionCheckpoint);
+				const runtimeEvidence = this.agent.turn.actionEvidenceReceiptForCurrentTurn();
+				assertActionCheckpointEvidenceBasis(undefined, input.actionCheckpoint, runtimeEvidence);
+				state.actionCheckpoint = normalizeActionCheckpoint(input.actionCheckpoint, {
+					runtimeEvidence
+				});
+			}
 			this.persistState(state);
 			this.agent.records.logRecord({
 				type: "goal.create",
 				goalId: state.goalId,
 				objective: state.objective,
-				completionCriterion: state.completionCriterion
+				completionCriterion: state.completionCriterion,
+				actionCheckpoint: state.actionCheckpoint
 			});
 			this.trackGoalCreated(actor, input.replace === true);
 			return this.toSnapshot(state);
@@ -233581,7 +233591,7 @@ var init_goal_start_review_ask = __esmMin((() => {
 		}
 		evaluate(context) {
 			if (context.toolCall.name !== "CreateGoal") return;
-			if (this.agent.permission.mode === "auto") return;
+			if (this.agent.permission.mode !== "manual") return;
 			if (context.execution.display?.kind !== "goal_start") return;
 			return {
 				kind: "ask",
@@ -234611,6 +234621,7 @@ function migrateGoalCreate(record) {
 		goalId: record.goalId,
 		objective: record.objective,
 		completionCriterion: record.completionCriterion,
+		actionCheckpoint: record.actionCheckpoint,
 		time: record.time
 	};
 }
@@ -245751,6 +245762,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),
@@ -260216,7 +260237,7 @@ bytesWritten: number$1().int().nonnegative() });
 //#region ../../packages/agent-core/src/tools/builtin/goal/create-goal.md?raw
 var create_goal_default;
 var init_create_goal$1 = __esmMin((() => {
-	create_goal_default = "Create a durable, structured goal that the runtime will pursue across multiple turns.\n\nCall `CreateGoal` only when:\n\n- the user explicitly asks you to start a goal or work autonomously toward an outcome, or\n- a host goal-intake prompt asks you to create one.\n\nDo NOT create a goal for greetings, ordinary questions, or vague requests that lack a\nverifiable completion condition. A goal needs a checkable end state.\n\nWhen the request is vague, ask the user for the missing completion criterion before creating\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\nrespect that and create the goal.\n\nInclude a `completionCriterion` when the user provides one, or when it can be stated without\ninventing new requirements. Keep `objective` concise; reference long task descriptions by file\npath rather than pasting them.\n\nCreating a goal fails if one already exists, so use `replace: true` only when the user explicitly\nwants to abandon the current goal and start a new one.\n";
+	create_goal_default = "Create a durable, structured goal that the runtime will pursue across multiple turns.\n\nCall `CreateGoal` when:\n\n- the user explicitly asks you to start a goal or work autonomously toward an outcome,\n- an authenticated user assigns a non-trivial multi-step outcome with a checkable end state under an existing instruction to continue autonomously, or\n- a host goal-intake prompt asks you to create one.\n\nDo NOT create a goal for greetings, ordinary questions, one-step requests, or vague requests that lack a\nverifiable completion condition. A goal needs a checkable end state.\n\nWhen the request is vague, ask the user for the missing completion criterion before creating\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\nrespect that and create the goal.\n\nInclude a `completionCriterion` when the user provides one, or when it can be stated without\ninventing new requirements. Keep `objective` concise; reference long task descriptions by file\npath rather than pasting them. Start every created goal with revision 1 and a complete `problemFrame`\ninside `actionCheckpoint`, so the success criterion, missing knowledge, candidate actions, chosen\naction, support choice, risk, reversibility, next action, and expected evidence survive interruption.\nThis frame is descriptive state only and never grants permission.\n\nCreating a goal fails if one already exists, so use `replace: true` only when the user explicitly\nwants to abandon the current goal and start a new one.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/serialize.ts
@@ -260235,15 +260256,42 @@ function goalResultForModel(result) {
 var init_serialize = __esmMin((() => {}));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/create-goal.ts
-var CreateGoalToolInputSchema, CreateGoalTool;
+function createProblemFrameInputSchema() {
+	return 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();
+}
+function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFrame = false) {
+	return object({
+		revision: number$1().int().min(1),
+		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
+		evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward"]),
+		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),
+		problemFrame: requireProblemFrame ? problemFrameSchema : problemFrameSchema.optional()
+	}).strict();
+}
+var ProblemFrameInputSchema, ActionCheckpointInputSchema, CreateGoalActionCheckpointInputSchema, CreateGoalToolInputSchema, CreateGoalTool;
 var init_create_goal = __esmMin((() => {
 	init_zod$1();
 	init_input_schema();
 	init_create_goal$1();
 	init_serialize();
+	ProblemFrameInputSchema ??= createProblemFrameInputSchema();
+	CreateGoalActionCheckpointInputSchema ??= createActionCheckpointInputSchema(ProblemFrameInputSchema, true);
 	CreateGoalToolInputSchema = object({
 		objective: string().min(1).describe("The objective to pursue. Must have a verifiable end state."),
 		completionCriterion: string().optional().describe("How to verify the goal is complete. Include when the user provides one."),
+		actionCheckpoint: CreateGoalActionCheckpointInputSchema,
 		replace: boolean$1().optional().describe("Replace an existing active, paused, or blocked goal instead of failing.")
 	}).strict();
 	CreateGoalTool = class {
@@ -260264,6 +260312,7 @@ var init_create_goal = __esmMin((() => {
 					const snapshot = await goal.createGoal({
 						objective: args.objective,
 						completionCriterion: args.completionCriterion,
+						actionCheckpoint: args.actionCheckpoint,
 						replace: args.replace
 					}, "model");
 					return { output: JSON.stringify({ goal: goalForModel(snapshot) }, null, 2) };
@@ -260273,12 +260322,12 @@ var init_create_goal = __esmMin((() => {
 		/**
 		* Starting a goal switches the agent into autonomous, multi-turn work, so its
 		* approval reuses the same choice the `/goal` command offers: pick the
-		* permission mode to run under, or decline. `auto` mode auto-approves the goal
-		* upstream and never reaches this prompt, so the menu only covers manual/yolo.
+		* permission mode to run under, or decline. Auto and God Mode continue under
+		* their already selected permission level; only manual mode asks again.
 		*/
 		resolveGoalStartDisplay(args) {
 			const mode = this.agent.permission.mode;
-			if (mode === "auto") return void 0;
+			if (mode !== "manual") return void 0;
 			return {
 				kind: "goal_start",
 				objective: args.objective,
@@ -262725,25 +262774,19 @@ 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 UpdateGoalToolInputSchema, UpdateGoalTool;
 var init_update_goal = __esmMin((() => {
 	init_zod$1();
 	init_turn();
 	init_outcome_prompts();
 	init_input_schema();
 	init_update_goal$1();
-	ActionCheckpointInputSchema = object({
-		revision: number$1().int().min(1),
-		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
-		evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward"]),
-		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)
-	}).strict();
+	ProblemFrameInputSchema ??= createProblemFrameInputSchema();
+	ActionCheckpointInputSchema ??= createActionCheckpointInputSchema(ProblemFrameInputSchema);
 	UpdateGoalToolInputSchema = object({ status: _enum([
 		"active",
 		"complete",

package/package.json

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