@juicesharp/rpiv-warp 1.4.2 → 1.5.1

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to `@juicesharp/rpiv-warp` are documented here.
 Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 Versioning: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.1] - 2026-05-13
+
+### Added
+- Idle prompt emission after agent turns complete, carrying the assistant summary.
+- Configurable heartbeat re-emitting `prompt_submit` during active work (default 15 s, set `heartbeatMs` in config to override, `0` to disable).
+- `session_shutdown` handler clearing all timers and spinner state.
+- Blocking tool input capture attached to `tool_complete` payloads.
+- `before_agent_start` handler capturing the user's query for accurate `prompt_submit` events.
+
+## [1.5.0] - 2026-05-12
+
 ## [1.4.2] - 2026-05-11
 
 ## [1.4.1] - 2026-05-11

package/config.ts

@@ -7,9 +7,11 @@ export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 
 export interface RpivWarpConfig {
 	readonly blockingTools?: readonly string[];
+	readonly heartbeatMs?: number;
 }
 
 export const DEFAULT_BLOCKING_TOOLS: readonly string[] = ["ask_user_question"];
+export const DEFAULT_HEARTBEAT_MS = 15000;
 
 export function loadConfig(): RpivWarpConfig {
 	if (!existsSync(CONFIG_PATH)) return {};
@@ -22,6 +24,14 @@ export function loadConfig(): RpivWarpConfig {
 	}
 }
 
+export function getHeartbeatMs(): number {
+	const config = loadConfig();
+	const ms = config.heartbeatMs;
+	if (ms === 0) return 0; // explicitly disabled
+	if (typeof ms !== "number" || ms <= 0) return DEFAULT_HEARTBEAT_MS;
+	return ms;
+}
+
 export function getBlockingTools(): ReadonlySet<string> {
 	const config = loadConfig();
 	const list = Array.isArray(config.blockingTools) ? config.blockingTools : DEFAULT_BLOCKING_TOOLS;

package/index.ts

@@ -1,12 +1,14 @@
 import { basename } from "node:path";
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import { getBlockingTools } from "./config.js";
+import { DEFAULT_HEARTBEAT_MS, getBlockingTools, getHeartbeatMs } from "./config.js";
 import {
+	buildIdlePromptPayload,
 	buildPromptSubmitPayload,
 	buildQuestionAskedPayload,
 	buildSessionStartPayload,
 	buildStopPayload,
 	buildToolCompletePayload,
+	lastAssistantText,
 	serializePayload,
 	type WarpPayload,
 } from "./payload.js";
@@ -14,12 +16,85 @@ import { detectWarpEnvironment } from "./protocol.js";
 import { startSpinner, stopSpinner } from "./title-spinner.js";
 import { writeOSC777 } from "./warp-notify.js";
 
+// ---------------------------------------------------------------------------
+// Module-level timer state — __resetState() clears for test isolation
+// ---------------------------------------------------------------------------
+
+let pendingQuery = "";
+let idleTimer: ReturnType<typeof setTimeout> | undefined;
+let heartbeatInterval: ReturnType<typeof setInterval> | undefined;
+let heartbeatMs = DEFAULT_HEARTBEAT_MS;
+const toolInputCapture = new Map<string, Record<string, unknown>>();
+
+export function __resetState(): void {
+	pendingQuery = "";
+	if (idleTimer !== undefined) {
+		clearTimeout(idleTimer);
+		idleTimer = undefined;
+	}
+	if (heartbeatInterval !== undefined) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = undefined;
+	}
+	heartbeatMs = DEFAULT_HEARTBEAT_MS;
+	toolInputCapture.clear();
+}
+
 const TITLE = "warp://cli-agent";
 
 function emit(payload: WarpPayload): void {
 	writeOSC777(TITLE, serializePayload(payload));
 }
 
+function cancelIdleTimer(): void {
+	if (idleTimer !== undefined) {
+		clearTimeout(idleTimer);
+		idleTimer = undefined;
+	}
+}
+
+function startIdleTimer(ctx: ExtensionContext, branch: SessionEntry[]): void {
+	cancelIdleTimer();
+	idleTimer = setTimeout(() => {
+		idleTimer = undefined;
+		const summary = lastAssistantText(branch);
+		emit(buildIdlePromptPayload(ctx, summary));
+	}, 300);
+	if (typeof (idleTimer as ReturnType<typeof setTimeout>).unref === "function") {
+		(idleTimer as ReturnType<typeof setTimeout>).unref();
+	}
+}
+
+function startHeartbeat(ctx: ExtensionContext, ms: number): void {
+	stopHeartbeat();
+	if (ms <= 0) return; // disabled
+	heartbeatInterval = setInterval(() => {
+		emit(buildPromptSubmitPayload(ctx, pendingQuery));
+	}, ms);
+	if (typeof heartbeatInterval.unref === "function") {
+		heartbeatInterval.unref();
+	}
+}
+
+function stopHeartbeat(): void {
+	if (heartbeatInterval !== undefined) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = undefined;
+	}
+}
+
+function captureToolInput(toolCallId: string, input: unknown): void {
+	if (typeof input === "object" && input !== null) {
+		toolInputCapture.set(toolCallId, input as Record<string, unknown>);
+	}
+}
+
+function consumeToolInput(toolCallId: string): Record<string, unknown> | undefined {
+	const input = toolInputCapture.get(toolCallId);
+	toolInputCapture.delete(toolCallId);
+	return input;
+}
+
 function readBranch(ctx: ExtensionContext): SessionEntry[] {
 	return ctx.sessionManager.getBranch() as SessionEntry[];
 }
@@ -36,31 +111,53 @@ export default function (pi: ExtensionAPI): void {
 	if (!warp.isWarp || !warp.supportsStructured) return;
 
 	const blockingTools = getBlockingTools();
+	heartbeatMs = getHeartbeatMs();
 
 	pi.on("session_start", async (event, ctx) => {
 		if (event.reason !== "startup") return;
 		emit(buildSessionStartPayload(ctx));
 	});
 
+	pi.on("before_agent_start", async (event) => {
+		pendingQuery = event.prompt ?? "";
+	});
+
 	pi.on("agent_start", async (_event, ctx) => {
-		emit(buildPromptSubmitPayload(ctx));
+		emit(buildSessionStartPayload(ctx)); // Item 2: defensive re-announce
+		emit(buildPromptSubmitPayload(ctx, pendingQuery));
 		startSpinner(titleSuffix(ctx));
+		cancelIdleTimer(); // Item 3: cancel pending idle from previous turn
+		startHeartbeat(ctx, heartbeatMs); // Item 4: heartbeat
 	});
 
 	pi.on("agent_end", async (_event, ctx) => {
 		emit(buildStopPayload(ctx, readBranch(ctx)));
 		stopSpinner();
+		stopHeartbeat(); // Item 4: stop heartbeat
+		startIdleTimer(ctx, readBranch(ctx)); // Item 3: schedule idle_prompt after 300ms
 	});
 
 	pi.on("tool_call", async (event, ctx) => {
 		if (!blockingTools.has(event.toolName)) return;
+		captureToolInput(event.toolCallId, event.input); // Item 6: capture input
 		emit(buildQuestionAskedPayload(ctx));
 		stopSpinner();
+		stopHeartbeat(); // Item 4: pause heartbeat
 	});
 
 	pi.on("tool_execution_end", async (event, ctx) => {
 		if (!blockingTools.has(event.toolName)) return;
-		emit(buildToolCompletePayload(ctx, event.toolName));
+		const toolInput = consumeToolInput(event.toolCallId); // Item 6: consume input
+		emit(buildToolCompletePayload(ctx, event.toolName, toolInput));
 		startSpinner(titleSuffix(ctx));
+		startHeartbeat(ctx, heartbeatMs); // Item 4: resume heartbeat
+	});
+
+	pi.on("session_shutdown", async () => {
+		cancelIdleTimer();
+		stopHeartbeat();
+		pendingQuery = "";
+		toolInputCapture.clear();
+		stopSpinner();
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@juicesharp/rpiv-warp",
-	"version": "1.4.2",
+	"version": "1.5.1",
 	"private": false,
 	"description": "Pi extension. Native Warp terminal notifications, dispatched via OSC 777 on Pi lifecycle events.",
 	"keywords": [

package/payload.ts

@@ -16,24 +16,8 @@ import { negotiateProtocolVersion, type WarpEvent } from "./protocol.js";
 // ---------------------------------------------------------------------------
 
 /**
- * Warp's `CLIAgent` enum recognizes 12 IDs (warpdotdev/warp:
- * `app/src/terminal/cli_agent.rs`), and `"pi"` is one of them — semantically
- * correct identity for this extension. However, the session listener at
- * `app/src/terminal/cli_agent_sessions/listener/mod.rs:48-57` currently routes
- * only `Claude | OpenCode | Gemini | Auggie | Codex` to a notification handler
- * and drops every other variant (including `Pi` and `Unknown`). So `"pi"`
- * parses correctly but produces no toast in current Warp builds.
- *
- * Workaround options, all bad:
- *   - `agent: "claude"` → toasts render, but tab gets the Claude Code icon &
- *     "Claude" label via `SessionType::CliAgent(CLIAgent::Claude)`. Identity-
- *     misrepresenting; user-visibly wrong.
- *   - any non-allowlisted ID → no toast.
- *
- * Real fix is upstream: PR `warpdotdev/warp` moving `CLIAgent::Pi` into the
- * `DefaultSessionListener` arm + adding `icon()` / `brand_color()` cases
- * (template: `specs/APP-4067/TECH.md` did this for Gemini). Until that ships,
- * we keep the correct identity and accept that Warp won't render the toast.
+ * Warp's `CLIAgent::Pi` is routed to `DefaultSessionListener` since Warp's
+ * open-source release (warpdotdev/warp `listener/mod.rs:93-99`).
  */
 export const AGENT_ID = "pi";
 export const TRUNCATE_LIMIT = 200;
@@ -58,11 +42,16 @@ export interface StopExtras {
 export interface IdlePromptExtras {
 	readonly summary: string;
 }
+export interface PromptSubmitExtras {
+	readonly query: string;
+}
 export interface ToolCompleteExtras {
 	readonly tool_name: string;
+	readonly tool_input?: Record<string, unknown>;
 }
 
-export type WarpPayload = WarpPayloadBase & Partial<StopExtras & IdlePromptExtras & ToolCompleteExtras>;
+export type WarpPayload = WarpPayloadBase &
+	Partial<StopExtras & IdlePromptExtras & PromptSubmitExtras & ToolCompleteExtras>;
 
 // ---------------------------------------------------------------------------
 // Text helpers — small, single-purpose, composable
@@ -141,8 +130,11 @@ export function buildSessionStartPayload(ctx: ExtensionContext): WarpPayload {
 	return baseEnvelope("session_start", ctx);
 }
 
-export function buildPromptSubmitPayload(ctx: ExtensionContext): WarpPayload {
-	return baseEnvelope("prompt_submit", ctx);
+export function buildPromptSubmitPayload(ctx: ExtensionContext, query: string = ""): WarpPayload {
+	return {
+		...baseEnvelope("prompt_submit", ctx),
+		query,
+	};
 }
 
 export function buildQuestionAskedPayload(ctx: ExtensionContext): WarpPayload {
@@ -164,10 +156,15 @@ export function buildIdlePromptPayload(ctx: ExtensionContext, summary: string):
 	};
 }
 
-export function buildToolCompletePayload(ctx: ExtensionContext, toolName: string): WarpPayload {
+export function buildToolCompletePayload(
+	ctx: ExtensionContext,
+	toolName: string,
+	toolInput?: Record<string, unknown>,
+): WarpPayload {
 	return {
 		...baseEnvelope("tool_complete", ctx),
 		tool_name: toolName,
+		...(toolInput !== undefined ? { tool_input: toolInput } : {}),
 	};
 }