pi-harness-runtime 1.1.397 → 1.1.402

package/packages/notification/src/notification-center.ts

@@ -12,7 +12,7 @@
 import { logError, logWarn } from "./file-logger.js";
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
-import { DatabaseSync } from "node:sqlite";
+import { createRequire } from "node:module";
 
 import type {
 	InlineKeyboardButton,
@@ -32,6 +32,23 @@ import { NtfyAdapter } from "./adapters/ntfy-adapter.js";
 import { EmailAdapter } from "./adapters/email-adapter.js";
 import { WebhookAdapter } from "./adapters/webhook-adapter.js";
 
+/**
+ * Load the SQLite binding lazily.
+ *
+ * `node:sqlite` does not exist in every runtime (Bun 1.3 has no
+ * `node:sqlite`), and a static import makes the whole module unloadable
+ * there. The persisted channel settings are an optimisation: without the
+ * database the center still works with the configured defaults.
+ */
+function loadDatabaseSync(): typeof import("node:sqlite").DatabaseSync | null {
+	try {
+		const require = createRequire(import.meta.url);
+		return require("node:sqlite").DatabaseSync;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Pending approval request
  */
@@ -48,7 +65,7 @@ export class NotificationCenter {
 	private adapters: Map<string, ChannelAdapter> = new Map();
 	private channelEnabled: Map<string, boolean> = new Map();
 	private redactPatterns: RegExp[];
-	private db: DatabaseSync | null = null;
+	private db: import("node:sqlite").DatabaseSync | null = null;
 	/** Pending approval requests keyed by jobId */
 	private pendingApprovals: Map<string, PendingApproval> = new Map();
 
@@ -69,6 +86,15 @@ export class NotificationCenter {
 	 */
 	private initDatabase(): void {
 		try {
+			const DatabaseSync = loadDatabaseSync();
+			if (!DatabaseSync) {
+				logWarn(
+					"[NotificationCenter]",
+					"node:sqlite is unavailable - the channel settings are not persisted",
+				);
+				return;
+			}
+
 			const dbPath = NotificationCenter.getDatabasePath();
 			this.db = new DatabaseSync(dbPath);
 
@@ -203,6 +229,14 @@ export class NotificationCenter {
 			const adapter = this.createAdapter(config);
 			if (adapter && adapter.isConfigured()) {
 				this.adapters.set(config.id, adapter);
+				// A registered channel without a persisted state is enabled
+				// unless its configuration says otherwise. Without this the
+				// channel is registered but silently skipped by notify(),
+				// which happens whenever the settings database is
+				// unavailable (no `node:sqlite` in the runtime).
+				if (!this.channelEnabled.has(config.id)) {
+					this.channelEnabled.set(config.id, config.enabled !== false);
+				}
 				return true;
 			}
 		} catch (error) {
@@ -515,14 +549,21 @@ export class NotificationCenter {
 		const approveLabel = options?.approveLabel ?? "Yes";
 		const rejectLabel = options?.rejectLabel ?? "No";
 
+		// The canonical request ID is the approval correlation key. The
+		// presentation `jobId` may carry a prefix ("waiting-user-q-123") and
+		// must not be used for the correlation: a callback that carries the
+		// prefixed value can never match the pending question, so the click
+		// is reported as stale and the approval is lost.
+		const target = context.questionId ?? context.jobId;
+
 		// Build buttons
 		const buttons: InlineKeyboardButton[] = [
-			{ text: `\u2705 ${approveLabel}`, callbackData: buildCallbackData(CallbackActions.APPROVE, context.jobId) },
-			{ text: `\u274C ${rejectLabel}`, callbackData: buildCallbackData(CallbackActions.REJECT, context.jobId) },
+			{ text: `\u2705 ${approveLabel}`, callbackData: buildCallbackData(CallbackActions.APPROVE, target) },
+			{ text: `\u274C ${rejectLabel}`, callbackData: buildCallbackData(CallbackActions.REJECT, target) },
 		];
 
 		// Track this pending approval so callback can resolve it
-		this.trackPendingApproval(context.jobId, event, context);
+		this.trackPendingApproval(target, event, context);
 
 		// Send to each channel with buttons (respecting enabled state)
 		const results: NotificationResult[] = [];
@@ -547,16 +588,23 @@ export class NotificationCenter {
 					results.push({ success: false, channel: id, error: String(error) });
 				}
 			} else if (adapter instanceof LineAdapter) {
-				// LINE: Send approval request with text fallback directing user to answer via Telegram or Pi
+				// LINE: the same question and the same canonical request ID
+				// as Telegram, with the same Yes/No actions. The postback
+				// data uses the shared callback format, so the webhook
+				// forwards it into the same runtime resolver.
 				try {
 					const linePayload: NotificationPayload = {
 						jobId: context.jobId,
 						timestamp: new Date().toISOString(),
 						event,
 						title: "Approval Required",
-						message: (context.requirement || "A decision is needed.") + "\n\nReply via Telegram or type answer in Pi.",
+						message: context.requirement || "A decision is needed.",
+						...(context.questionId && { questionId: context.questionId }),
 						details: {
 						jobId: context.jobId,
+						...(context.questionId && { questionId: context.questionId }),
+						...(context.questionKind && { questionKind: context.questionKind }),
+						_actionButtons: buttons,
 						...options?.additionalDetails,
 					},
 					};
@@ -712,12 +760,17 @@ export class NotificationCenter {
 			timestamp: new Date().toISOString(),
 			title,
 			message,
+			...(context.questionId && { questionId: context.questionId }),
 			details: {
 				jobId: context.jobId,
 				requirement: context.requirement,
 				...(context.taskId && { taskId: context.taskId }),
 				...(context.taskTitle && { taskTitle: context.taskTitle }),
 				...(context.error && { error: context.error }),
+				...(context.reason && { reason: context.reason }),
+				...(context.trigger && { trigger: context.trigger }),
+				...(context.questionId && { questionId: context.questionId }),
+				...(context.questionKind && { questionKind: context.questionKind }),
 				// Pass inline keyboard options to Telegram adapter
 				...(options?.enableInlineKeyboard && { _enableInlineKeyboard: true }),
 				...(options?.actionButtons && { _actionButtons: options.actionButtons }),
@@ -733,6 +786,11 @@ export class NotificationCenter {
 		const req = context.requirement ?? "";
 		const requirement =
 			req.length > 50 ? req.slice(0, 50) + "..." : req;
+		// The question the agent asks has to reach the user in full. A
+		// truncated question is not a question the user can answer, so the
+		// approval events keep the complete text and let the adapter split
+		// it for the platform.
+		const fullRequirement = req;
 
 		const map: Record<NotificationEvent, { title: string; message: string }> = {
 			JobStarted: {
@@ -781,7 +839,7 @@ export class NotificationCenter {
 			},
 			WaitingForUserInput: {
 				title: "Your Input Needed",
-				message: `Agent needs your input: "${requirement}"${context.error ? ` (${context.error})` : ""}`,
+				message: `Agent needs your input: "${fullRequirement}"${context.error ? ` (${context.error})` : ""}`,
 			},
 			AssistantResponse: {
 				title: "Assistant",

package/packages/notification/src/pending-question.ts

@@ -19,13 +19,31 @@ export type QuestionKind =
 /**
  * Question states
  */
-export type QuestionState = 
+export type QuestionState =
   | "pending"      // Waiting for response
   | "evaluating"   // Jev is evaluating
   | "resolved"     // User answered
   | "cancelled"    // Cancelled (e.g., session switch)
   | "expired";     // Timed out
 
+/**
+ * The typed outcome of a Jev evaluation.
+ *
+ * It is deliberately not the same shape as a human answer: an autonomous
+ * decision is never reported as a user "yes".
+ */
+export type JevOutcome =
+  | "approve"
+  | "reject"
+  | "wait"
+  | "proceed_with_caution";
+
+/** Who resolved the question. */
+export type ResolutionSource = "user" | "jev" | "timeout";
+
+/** The channel a human answer came from. */
+export type ResolutionChannel = "telegram" | "line" | "pi";
+
 /**
  * Channel delivery states
  */
@@ -51,6 +69,16 @@ export interface PendingQuestion {
   questionText: string;
   /** Question kind */
   kind: QuestionKind;
+  /** Does the proposed action need an explicit human authorization? */
+  requiresExplicitAuthorization?: boolean;
+  /** Can the proposed action destroy or damage something? */
+  destructive?: boolean;
+  /** Can the proposed action be undone? */
+  reversible?: boolean;
+  /** Does the proposed action reach the outside world? */
+  external?: boolean;
+  /** The signals the risk facts were derived from. */
+  riskSignals?: string[];
   /** Current state */
   state: QuestionState;
   /** When created */
@@ -62,7 +90,13 @@ export interface PendingQuestion {
   /** Resolution: "yes", "no", "clarification", or undefined */
   resolution?: "yes" | "no" | "clarification";
   /** Who resolved it */
-  resolvedBy?: "user" | "jev" | "timeout";
+  resolvedBy?: ResolutionSource;
+  /** The channel a human answer came from. Unset for a Jev resolution. */
+  resolvedChannel?: ResolutionChannel;
+  /** The Jev outcome, when the decision was autonomous. */
+  jevOutcome?: JevOutcome;
+  /** The short reason of the Jev decision. */
+  jevReason?: string;
   /** Channel delivery states */
   deliveryState: {
     telegram?: ChannelDeliveryState;
@@ -413,6 +447,14 @@ export class PendingQuestionController {
     workspacePath: string;
     jobId?: string;
     kind: QuestionKind;
+    /** The deterministic risk facts of the proposed action. */
+    risk?: {
+      requiresExplicitAuthorization?: boolean;
+      destructive?: boolean;
+      reversible?: boolean;
+      external?: boolean;
+      signals?: string[];
+    };
   }): PendingQuestion {
     const requestId = this.generateRequestId();
     
@@ -423,6 +465,11 @@ export class PendingQuestionController {
       jobId: params.jobId,
       questionText: params.text,
       kind: params.kind,
+      requiresExplicitAuthorization: params.risk?.requiresExplicitAuthorization,
+      destructive: params.risk?.destructive,
+      reversible: params.risk?.reversible,
+      external: params.risk?.external,
+      riskSignals: params.risk?.signals,
       state: "pending",
       createdAt: new Date(),
       dueAt: new Date(Date.now() + this.config.evaluationDelayMs),
@@ -482,9 +529,11 @@ export class PendingQuestionController {
    */
   resolve(params: {
     resolution: "yes" | "no" | "clarification";
-    by: "user" | "jev" | "timeout";
+    by: ResolutionSource;
     /** Optional requestId to validate (first-answer-wins) */
     requestId?: string;
+    /** The channel a human answer came from. */
+    channel?: ResolutionChannel;
   }): boolean {
     if (!this.currentQuestion) {
       logWarn("[PendingQuestion]", "No question to resolve - no pending question");
@@ -504,22 +553,125 @@ export class PendingQuestionController {
         `Question already resolved as ${this.currentQuestion.resolution} - duplicate callback ignored`);
       return false;
     }
-    
+
     this.currentQuestion.state = "resolved";
     this.currentQuestion.resolution = params.resolution;
     this.currentQuestion.resolvedBy = params.by;
     this.currentQuestion.resolvedAt = new Date();
-    
+    if (params.by === "user" && params.channel) {
+      this.currentQuestion.resolvedChannel = params.channel;
+    }
+
     logWarn("[PendingQuestion]", `Resolved question ${this.currentQuestion.requestId}: ${params.resolution} by ${params.by}`);
-    
-    // Notify callback
-    if (this.userAnswerCallback) {
+
+    // Notify callback. A Jev resolution is NOT a user answer: it must never
+    // be dispatched as a synthetic "yes" into the conversation.
+    if (params.by === "jev") {
+      if (this.jevDecisionCallback) {
+        this.jevDecisionCallback(this.currentQuestion, {
+          action: "continue",
+          reason: "resolved by jev",
+          eligible: true,
+        });
+      }
+    } else if (this.userAnswerCallback) {
       this.userAnswerCallback(this.currentQuestion, params.resolution);
     }
 
     return true;
   }
 
+  /**
+   * Resolve a question with an autonomous Jev decision.
+   *
+   * The question is closed with `resolvedBy: "jev"`, the outcome is recorded
+   * and the Jev callback is notified. No user answer is dispatched: nobody
+   * clicked anything.
+   *
+   * @returns true if the question was closed, false when it was stale or
+   *   already answered by a human.
+   */
+  resolveByJev(
+    requestId: string,
+    outcome: JevOutcome,
+    reason?: string,
+  ): boolean {
+    if (!this.currentQuestion) {
+      logWarn("[PendingQuestion]", "No question to resolve - no pending question");
+      return false;
+    }
+
+    if (this.currentQuestion.requestId !== requestId) {
+      logWarn("[PendingQuestion]",
+        `Jev resolution for an unknown request: ${requestId} (current=${this.currentQuestion.requestId})`);
+      return false;
+    }
+
+    if (this.currentQuestion.state === "resolved") {
+      logWarn("[PendingQuestion]",
+        `Question already resolved as ${this.currentQuestion.resolution} - jev decision ignored`);
+      return false;
+    }
+
+    this.currentQuestion.state = "resolved";
+    this.currentQuestion.resolvedBy = "jev";
+    this.currentQuestion.jevOutcome = outcome;
+    this.currentQuestion.jevReason = reason;
+    this.currentQuestion.resolvedAt = new Date();
+
+    logWarn("[PendingQuestion]",
+      `Closed question ${this.currentQuestion.requestId} with jev outcome ${outcome}`);
+
+    if (this.jevDecisionCallback) {
+      this.jevDecisionCallback(this.currentQuestion, {
+        action: outcome === "reject" ? "stop" : outcome === "wait" ? "wait" : "continue",
+        reason: reason ?? `jev:${outcome}`,
+        eligible: true,
+        metadata: { outcome },
+      });
+    }
+
+    return true;
+  }
+
+  /**
+   * Apply an approval action from a channel to the current question.
+   *
+   * The action names are the shared callback actions, so Telegram and LINE
+   * use the same values and the same resolver. A stale request ID, a
+   * duplicate click or a wrong session leaves the running wait untouched.
+   */
+  applyApproval(
+    action: string,
+    requestId: string,
+    channel: ResolutionChannel,
+  ): { applied: boolean; resolution?: "yes" | "no"; reason?: string } {
+    if (action !== "approve" && action !== "reject") {
+      return { applied: false, reason: `unknown action '${action}'` };
+    }
+
+    const resolution = action === "approve" ? "yes" : "no";
+    const applied = this.resolve({ resolution, by: "user", requestId, channel });
+
+    return applied
+      ? { applied: true, resolution }
+      : { applied: false, resolution, reason: "stale or duplicate request ID" };
+  }
+
+  /**
+   * Is the request ID still actionable?
+   *
+   * A button of a closed question is stale: it must not resolve another
+   * question and it must not clear a running wait.
+   */
+  isActionable(requestId: string): boolean {
+    if (!this.currentQuestion) return false;
+    return (
+      this.currentQuestion.requestId === requestId &&
+      (this.currentQuestion.state === "pending" || this.currentQuestion.state === "evaluating")
+    );
+  }
+
   /**
    * Cancel the current question (e.g., on session switch)
    */

package/packages/notification/src/types.ts

@@ -37,6 +37,8 @@ export interface NotificationPayload {
 	// Inline keyboard buttons for Telegram
 	enableInlineKeyboard?: boolean;
 	actionButtons?: InlineKeyboardButton[];
+	/** The canonical pending-question request ID (the approval correlation key). */
+	questionId?: string;
 }
 
 export interface NotificationConfig {
@@ -148,5 +150,24 @@ export interface NotificationContext {
 	requirement: string;
 	taskId?: string;
 	taskTitle?: string;
+	/** A real failure. Only error events render this under an "Error:" label. */
 	error?: string;
+	/** Why the event happened (a resume trigger, a quota detail, a review reason). */
+	reason?: string;
+	/**
+	 * Why the work resumed ("post-compact", "provider-overload"). A trigger is
+	 * not a failure: it renders as "Trigger: ..." in a human wording, never
+	 * under an "Error:" label.
+	 */
+	trigger?: string;
+	/**
+	 * The canonical pending-question request ID.
+	 *
+	 * It is the approval correlation key: the callback data of every Yes/No
+	 * action points at it. The presentation `jobId` may carry a prefix and
+	 * must not be used for the correlation.
+	 */
+	questionId?: string;
+	/** The kind of the pending question (approval, clarification, ...). */
+	questionKind?: string;
 }

package/packages/notification/test/approval-payload.test.ts

@@ -0,0 +1,269 @@
+/**
+ * Approval payload tests.
+ *
+ * The question has to reach the user complete, and the Yes/No actions have
+ * to point at the canonical request ID - on Telegram and on LINE. A button
+ * that carries a prefixed job ID can never match the pending question, so
+ * every click is reported as stale and the approval is lost.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { NotificationCenter } from "../src/notification-center.js";
+import { PendingQuestionController } from "../src/pending-question.js";
+import { parseCallbackData } from "../src/telegram-webhook-handler.js";
+import type { NotificationConfig } from "../src/types.js";
+
+const LONG_QUESTION =
+	"Want me to implement the persistence layer with the SQLite schema, the migration runner and the rollback path, and then wire it into the harness? ";
+
+interface CapturedRequest {
+	url: string;
+	body: Record<string, any>;
+}
+
+let captured: CapturedRequest[] = [];
+let originalFetch: typeof globalThis.fetch;
+
+function createCenter(): NotificationCenter {
+	const config: NotificationConfig = {
+		channels: [
+			{
+				id: "telegram",
+				type: "telegram",
+				enabled: true,
+				config: {
+					botToken: "test-bot-token",
+					chatId: "12345",
+					enableInlineKeyboard: true,
+				},
+			},
+			{
+				id: "line",
+				type: "line",
+				enabled: true,
+				config: { channelAccessToken: "test-line-token", userId: "U-test" },
+			},
+		],
+	};
+	return new NotificationCenter(config);
+}
+
+function telegramRequests(): CapturedRequest[] {
+	return captured.filter((r) => r.url.includes("api.telegram.org"));
+}
+
+function lineRequests(): CapturedRequest[] {
+	return captured.filter((r) => r.url.includes("api.line.me"));
+}
+
+beforeEach(() => {
+	captured = [];
+	originalFetch = globalThis.fetch;
+	globalThis.fetch = (async (input: any, init?: any) => {
+		const url = typeof input === "string" ? input : (input?.url ?? "");
+		let body: any = {};
+		try {
+			body = JSON.parse(init?.body ?? "{}");
+		} catch {
+			body = {};
+		}
+		captured.push({ url, body });
+
+		// The content filter asks Jev. Without a configured key the answer
+		// does not matter, and a failure keeps the test offline.
+		if (url.includes("typesafe.ai")) {
+			return new Response("unauthorized", { status: 401 });
+		}
+		return new Response(JSON.stringify({ ok: true, result: {} }), {
+			status: 200,
+			headers: { "Content-Type": "application/json" },
+		});
+	}) as typeof globalThis.fetch;
+});
+
+afterEach(() => {
+	globalThis.fetch = originalFetch;
+});
+
+describe("approval payload", () => {
+	it("sends the complete question to Telegram without truncating it", async () => {
+		const center = createCenter();
+		const question = LONG_QUESTION.repeat(3);
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: "q-long",
+			questionId: "q-long",
+			requirement: question,
+		});
+
+		const text = telegramRequests()
+			.map((r) => String(r.body.text ?? ""))
+			.join("\n");
+
+		expect(text).toContain(question.trim());
+		// The shared 50 character summary must not be used for a question.
+		expect(text).not.toContain("...");
+	});
+
+	it("sends the complete question to LINE", async () => {
+		const center = createCenter();
+		const question = LONG_QUESTION.repeat(3);
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: "q-long",
+			questionId: "q-long",
+			requirement: question,
+		});
+
+		const line = lineRequests()[0];
+		const messages = line?.body?.messages ?? [];
+		const textMessage = messages.find((m: any) => m.type === "text");
+
+		expect(textMessage).toBeDefined();
+		expect(String(textMessage.text)).toContain(question.trim());
+	});
+
+	it("puts the canonical request ID into the Telegram callback data", async () => {
+		const center = createCenter();
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: "waiting-user-q-123",
+			questionId: "q-123",
+			requirement: "Want me to continue?",
+		});
+
+		const telegram = telegramRequests()[0];
+		const keyboard = telegram?.body?.reply_markup;
+		expect(keyboard).toBeDefined();
+
+		const approve = keyboard.inline_keyboard[0][0];
+		const reject = keyboard.inline_keyboard[0][1];
+
+		const parsedApprove = parseCallbackData(approve.callback_data);
+		const parsedReject = parseCallbackData(reject.callback_data);
+
+		expect(parsedApprove.action).toBe("approve");
+		expect(parsedReject.action).toBe("reject");
+		// The canonical ID, not the prefixed presentation job ID.
+		expect(parsedApprove.targetId).toBe("q-123");
+		expect(parsedReject.targetId).toBe("q-123");
+	});
+
+	it("resolves the matching pending question from the real callback data", async () => {
+		const center = createCenter();
+		const controller = new PendingQuestionController();
+		const question = controller.createQuestion({
+			text: "Want me to continue?",
+			sessionId: "session-1",
+			workspacePath: "/tmp",
+			kind: "approval",
+		});
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: `waiting-user-${question.requestId}`,
+			questionId: question.requestId,
+			requirement: "Want me to continue?",
+		});
+
+		const telegram = telegramRequests()[0];
+		const callbackData = telegram.body.reply_markup.inline_keyboard[0][0]
+			.callback_data as string;
+		const parsed = parseCallbackData(callbackData);
+
+		const applied = controller.applyApproval(
+			parsed.action,
+			parsed.targetId,
+			"telegram",
+		);
+
+		expect(applied.applied).toBe(true);
+		expect(applied.resolution).toBe("yes");
+		expect(controller.getResolution()).toBe("yes");
+		expect(controller.getCurrentQuestion()?.resolvedBy).toBe("user");
+		expect(controller.getCurrentQuestion()?.resolvedChannel).toBe("telegram");
+	});
+
+	it("uses the same canonical ID for the LINE postback actions", async () => {
+		const center = createCenter();
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: "waiting-user-q-123",
+			questionId: "q-123",
+			requirement: "Want me to continue?",
+		});
+
+		const line = lineRequests()[0];
+		const messages = line?.body?.messages ?? [];
+		const template = messages.find((m: any) => m.type === "template");
+		expect(template).toBeDefined();
+
+		const actions = template.template.actions;
+		expect(actions).toHaveLength(2);
+		expect(actions[0].type).toBe("postback");
+		expect(actions[1].type).toBe("postback");
+
+		const approve = parseCallbackData(actions[0].data);
+		const reject = parseCallbackData(actions[1].data);
+
+		expect(approve.action).toBe("approve");
+		expect(reject.action).toBe("reject");
+		expect(approve.targetId).toBe("q-123");
+		expect(reject.targetId).toBe("q-123");
+	});
+
+	it("routes the LINE postback into the same resolver as Telegram", async () => {
+		const center = createCenter();
+		const controller = new PendingQuestionController();
+		const question = controller.createQuestion({
+			text: "Want me to continue?",
+			sessionId: "session-1",
+			workspacePath: "/tmp",
+			kind: "approval",
+		});
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: `waiting-user-${question.requestId}`,
+			questionId: question.requestId,
+			requirement: "Want me to continue?",
+		});
+
+		const line = lineRequests()[0];
+		const messages = line?.body?.messages ?? [];
+		const template = messages.find((m: any) => m.type === "template");
+		const parsed = parseCallbackData(template.template.actions[0].data);
+
+		const applied = controller.applyApproval(
+			parsed.action,
+			parsed.targetId,
+			"line",
+		);
+
+		expect(applied.applied).toBe(true);
+		expect(controller.getResolution()).toBe("yes");
+		expect(controller.getCurrentQuestion()?.resolvedChannel).toBe("line");
+	});
+
+	it("attaches the keyboard only to the final chunk of a long question", async () => {
+		const center = createCenter();
+		const question = `${LONG_QUESTION.repeat(30)}Want me to continue?`;
+
+		await center.notifyWithApproval("WaitingForUserInput", {
+			jobId: "q-chunked",
+			questionId: "q-chunked",
+			requirement: question,
+		});
+
+		const requests = telegramRequests();
+		expect(requests.length).toBeGreaterThan(1);
+
+		const withKeyboard = requests.filter((r) => r.body?.reply_markup);
+		expect(withKeyboard).toHaveLength(1);
+		// The actionable message is the last one.
+		expect(withKeyboard[0]).toBe(requests[requests.length - 1]);
+
+		// The question stays understandable across the chunks.
+		const allText = requests.map((r) => String(r.body.text ?? "")).join("");
+		expect(allText).toContain("Want me to continue?");
+		expect(allText).toContain("[Part 1/");
+	});
+});