jeopi-cli 16.4.5 → 16.5.1

package/src/sdk.ts

@@ -107,6 +107,7 @@ import {
 import { AgentSession } from "./session/agent-session";
 import { discoverAuthStorage as discoverAuthStorageFromConfig } from "./session/auth-broker-config";
 import type { AuthStorage } from "./session/auth-storage";
+import { createInterruptedTurnAbortMessage } from "./session/exit-diagnostics";
 import {
 	type CustomMessage,
 	convertToLlm,
@@ -1235,11 +1236,19 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	const secretsEnabled = obfuscator?.hasSecrets() === true;
 
-	// Check if session has existing data to restore
-	const existingSession = logger.time("loadSessionContext", () =>
+	// An abnormal process exit after a non-terminal message tail is durable
+	// evidence that the old process can no longer finish that turn. Preserve the
+	// partial transcript and append one terminal aborted assistant record before
+	// rebuilding runtime context. The helper is idempotent once that record exists.
+	let existingBranch = logger.time("getSessionBranch", () => sessionManager.getBranch());
+	const interruptedTurnAbort = createInterruptedTurnAbortMessage(existingBranch);
+	if (interruptedTurnAbort) {
+		sessionManager.appendMessage(interruptedTurnAbort);
+		existingBranch = logger.time("getRecoveredSessionBranch", () => sessionManager.getBranch());
+	}
+	let existingSession = logger.time("loadSessionContext", () =>
 		deobfuscateSessionContext(sessionManager.buildSessionContext(), obfuscator),
 	);
-	const existingBranch = logger.time("getSessionBranch", () => sessionManager.getBranch());
 	const hasExistingSession = existingBranch.length > 0;
 	const hasThinkingEntry = existingBranch.some(entry => entry.type === "thinking_level_change");
 	const hasServiceTierEntry = existingBranch.some(entry => entry.type === "service_tier_change");
@@ -2029,6 +2038,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		// A first-turn user tail has no assistant metadata to copy. Once startup
+		// has selected its final model, use that model to terminate the
+		// interrupted turn before the live agent consumes the restored context.
+		if (model) {
+			const selectedModelAbort = createInterruptedTurnAbortMessage(existingBranch, {
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+			});
+			if (selectedModelAbort) {
+				sessionManager.appendMessage(selectedModelAbort);
+				existingBranch = logger.time("getRecoveredUserTailBranch", () => sessionManager.getBranch());
+				existingSession = logger.time("loadRecoveredUserTailContext", () =>
+					deobfuscateSessionContext(sessionManager.buildSessionContext(), obfuscator),
+				);
+			}
+		}
+
 		// Discover custom commands (TypeScript slash commands)
 		const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
 			? { commands: [], errors: [] }

package/src/session/agent-session.ts

@@ -331,6 +331,7 @@ import {
 import { findCompactMode } from "./compact-modes";
 import {
 	collectPendingToolCalls,
+	createInterruptedTurnAbortMessage,
 	SESSION_EXIT_CUSTOM_TYPE,
 	type SessionExitData,
 	summarizeToolArguments,
@@ -14555,7 +14556,7 @@ export class AgentSession {
 			this.#rekeyHindsightMemoryForCurrentSessionId();
 			this.#rekeyMnemopiMemoryForCurrentSessionId();
 
-			const sessionContext = this.buildDisplaySessionContext();
+			let sessionContext = this.buildDisplaySessionContext();
 			const didReloadConversationChange =
 				previousSessionContext !== undefined &&
 				this.#didSessionMessagesChange(previousSessionContext.messages, sessionContext.messages);
@@ -14613,6 +14614,20 @@ export class AgentSession {
 				}
 			}
 
+			const model = this.model;
+			if (model) {
+				const interruptedTurnAbort = createInterruptedTurnAbortMessage(this.sessionManager.getBranch(), {
+					api: model.api,
+					provider: model.provider,
+					model: model.id,
+				});
+				if (interruptedTurnAbort) {
+					this.sessionManager.appendMessage(interruptedTurnAbort);
+					sessionContext = this.buildDisplaySessionContext();
+					this.agent.replaceMessages(sessionContext.messages);
+				}
+			}
+
 			const hasThinkingEntry = this.sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 			const hasServiceTierEntry = this.sessionManager
 				.getBranch()

package/src/session/blob-store.ts

@@ -5,6 +5,9 @@ import { isEnoent, logger } from "jeopi-utils";
 
 const BLOB_PREFIX = "blob:sha256:";
 
+/** Canonical blob suffix: a 64-char lowercase hex SHA-256 digest, nothing else. */
+const BLOB_HASH_RE = /^[a-f0-9]{64}$/;
+
 export interface BlobPutOptions {
 	/** Optional file extension for a sidecar hardlink/copy that OS openers can type-detect. */
 	extension?: string;
@@ -179,10 +182,24 @@ export function isBlobRef(data: string): boolean {
 	return data.startsWith(BLOB_PREFIX);
 }
 
-/** Extract the SHA-256 hash from a blob reference string. */
+/**
+ * Extract the SHA-256 hash from a blob reference string.
+ *
+ * Returns null when the string is not a blob ref, or when the suffix is not a
+ * canonical 64-char lowercase hex hash. Rejecting non-hash suffixes here is the
+ * single choke point that keeps every resolution path confined to the blob dir:
+ * `get`/`getSync`/`has` feed this value into `path.join(this.dir, hash)`, so an
+ * unvalidated `../` suffix in a crafted session file would otherwise escape the
+ * store and read arbitrary files.
+ */
 export function parseBlobRef(data: string): string | null {
 	if (!data.startsWith(BLOB_PREFIX)) return null;
-	return data.slice(BLOB_PREFIX.length);
+	const hash = data.slice(BLOB_PREFIX.length);
+	if (!BLOB_HASH_RE.test(hash)) {
+		logger.warn("Rejected malformed blob reference", { suffix: hash });
+		return null;
+	}
+	return hash;
 }
 
 /** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */

package/src/session/exit-diagnostics.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "jeopi-agent-core";
+import type { AssistantMessage } from "jeopi-ai";
 import type { SessionEntry } from "./session-entries";
 
 export const TOOL_EXECUTION_START_CUSTOM_TYPE = "tool_execution_start";
@@ -53,11 +54,116 @@ interface ToolCallContent {
 	arguments?: unknown;
 }
 
+export interface AssistantModelMetadata {
+	api: AssistantMessage["api"];
+	provider: string;
+	model: string;
+}
+
 function isObject(value: unknown): value is Record<string, unknown> {
 	if (typeof value !== "object") return false;
 	return value !== null;
 }
 
+function isPendingToolCallDiagnostic(value: unknown): value is PendingToolCallDiagnostic {
+	if (!isObject(value) || typeof value.toolName !== "string") return false;
+	if ("toolCallId" in value && typeof value.toolCallId !== "string") return false;
+	if ("intent" in value && typeof value.intent !== "string") return false;
+	if ("assistantTimestamp" in value && typeof value.assistantTimestamp !== "number") return false;
+	if ("startedAt" in value && typeof value.startedAt !== "string") return false;
+	return true;
+}
+
+function readSessionExit(entry: SessionEntry): SessionExitData | undefined {
+	if (entry.type !== "custom" || entry.customType !== SESSION_EXIT_CUSTOM_TYPE || !isObject(entry.data)) {
+		return undefined;
+	}
+	const { reason, kind, recordedAt } = entry.data;
+	if (
+		typeof reason !== "string" ||
+		(kind !== "normal" && kind !== "signal" && kind !== "fatal" && kind !== "process_exit") ||
+		typeof recordedAt !== "string"
+	) {
+		return undefined;
+	}
+	const rawPending = entry.data.pendingToolCalls;
+	return {
+		reason,
+		kind,
+		recordedAt,
+		pendingToolCalls:
+			Array.isArray(rawPending) && rawPending.every(isPendingToolCallDiagnostic) ? rawPending : undefined,
+	};
+}
+
+/**
+ * createInterruptedTurnAbortMessage returns a terminal assistant record when
+ * the latest persisted process exit follows a non-terminal conversation tail.
+ */
+export function createInterruptedTurnAbortMessage(
+	entries: readonly SessionEntry[],
+	fallbackModel?: AssistantModelMetadata,
+): AssistantMessage | undefined {
+	let exitIndex = -1;
+	let exit: SessionExitData | undefined;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const candidate = readSessionExit(entries[index]!);
+		if (!candidate) continue;
+		exitIndex = index;
+		exit = candidate;
+		break;
+	}
+	if (!exit || (exit.kind === "normal" && !exit.pendingToolCalls?.length)) return undefined;
+
+	let tailIndex = -1;
+	let tail: AgentMessage | undefined;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index]!;
+		if (entry.type !== "message") continue;
+		tailIndex = index;
+		tail = entry.message;
+		break;
+	}
+	if (!tail || tailIndex > exitIndex) return undefined;
+	if (tail.role === "assistant" && !tail.content.some(isToolCallContent)) return undefined;
+
+	let previousAssistant: AssistantMessage | undefined;
+	for (let index = tailIndex; index >= 0; index--) {
+		const entry = entries[index]!;
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		previousAssistant = entry.message;
+		break;
+	}
+	if (
+		tail.role === "toolResult" &&
+		(previousAssistant?.stopReason === "error" || previousAssistant?.stopReason === "aborted")
+	) {
+		return undefined;
+	}
+	const model = previousAssistant ?? fallbackModel;
+	if (!model) return undefined;
+
+	const recordedAt = Date.parse(exit.recordedAt);
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.model,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "aborted",
+		errorMessage: "Previous jeopi process exited before completing the turn.",
+		timestamp: Number.isFinite(recordedAt) ? recordedAt : Date.now(),
+	};
+}
+
 function isToolCallContent(value: unknown): value is ToolCallContent {
 	if (!isObject(value)) return false;
 	return value.type === "toolCall" && (typeof value.name === "string" || typeof value.id === "string");