pi-harness-runtime 1.1.398 → 1.1.403

package/packages/notification/src/adapters/telegram-adapter.ts

@@ -738,8 +738,12 @@ return this._botUsername;
 						body.parse_mode = cfg.parseMode;
 					}
 
-					// Add inline keyboard if enabled and buttons are configured
-					if (enableInlineKeyboard && (actionButtons?.length ?? 0) > 0) {
+					// The keyboard is attached to the final chunk only. The
+					// earlier chunks are the continuation of the same
+					// question, and a button on every chunk would offer the
+					// same action several times.
+					const isLastChunk = i === chunks.length - 1;
+					if (isLastChunk && enableInlineKeyboard && (actionButtons?.length ?? 0) > 0) {
 						body.reply_markup = this.buildInlineKeyboard(actionButtons);
 					}
 

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,6 +760,7 @@ export class NotificationCenter {
 			timestamp: new Date().toISOString(),
 			title,
 			message,
+			...(context.questionId && { questionId: context.questionId }),
 			details: {
 				jobId: context.jobId,
 				requirement: context.requirement,
@@ -719,6 +768,9 @@ export class NotificationCenter {
 				...(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 }),
@@ -734,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: {
@@ -782,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 {
@@ -152,4 +154,20 @@ export interface NotificationContext {
 	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;
 }