@vanillagreen/pi-claude-bridge 1.0.6 → 1.1.1

package/README.md

@@ -27,7 +27,7 @@ Restart Pi after installation.
 
 - `claude-bridge/claude-opus-4-7`, Sonnet, and Haiku models in `/model`.
 - Pi tool calls bridged to Claude Code through a local MCP server.
-- Session reuse/rebuild so Claude Code follows Pi history across normal turns, `/compact`, forks, tree navigation, and abort recovery.
+- Session reuse/rebuild so Claude Code follows Pi history across normal turns, `/compact`, tree navigation, and abort recovery. Forks rebuild on the first turn so the fork never inherits the parent's external Claude jsonl.
 - Thinking-level forwarding, summarized Opus thinking display, MCP isolation, and Claude cloud-MCP suppression to reduce token overhead.
 - Optional forwarding of Pi-only context that upstream does not pass to Claude Code.
 

package/bundle/index.js

@@ -18744,9 +18744,22 @@ function lA($, X) {
 import { randomUUID } from "crypto";
 import { mkdirSync as mkdirSync2, writeFileSync, appendFileSync as appendFileSync2, existsSync as existsSync2, rmSync as rmSync2 } from "fs";
 import { dirname } from "path";
+import { readFileSync as readFileSync2 } from "fs";
 import { realpathSync as realpathSync2 } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+function parseJsonl(content) {
+  return content.split("\n").filter((line) => line.trim()).map(parseRecord);
+}
+function parseJsonlFile(path) {
+  return parseJsonl(readFileSync2(path, "utf-8"));
+}
+function parseRecord(line) {
+  const raw = JSON.parse(line);
+  if (raw.type === "user") return raw;
+  if (raw.type === "assistant") return raw;
+  return raw;
+}
 function serializeRecord(record2) {
   return JSON.stringify(record2);
 }
@@ -19147,9 +19160,33 @@ function createSession(opts) {
     model: opts.model
   });
 }
+function openSession(opts) {
+  const projectPath = normalizeProjectPath(opts.projectPath);
+  const jsonlPath = getSessionPath(opts.sessionId, projectPath, opts.claudeDir);
+  return readSession(jsonlPath, projectPath);
+}
+function readSession(jsonlPath, projectPath) {
+  const records = parseJsonlFile(jsonlPath);
+  const firstMsg = records.find((r6) => r6.type === "user" || r6.type === "assistant");
+  const sessionId = firstMsg?.sessionId ?? "";
+  const resolvedProjectPath = projectPath ?? firstMsg?.cwd ?? "";
+  return new Session({
+    sessionId,
+    projectPath: resolvedProjectPath,
+    jsonlPath,
+    slug: firstMsg?.slug,
+    cwd: firstMsg?.cwd,
+    version: firstMsg?.version,
+    gitBranch: firstMsg?.gitBranch,
+    records,
+    fileExists: true
+  });
+}
 
 // src/index.ts
+import { createHash } from "crypto";
 import { accessSync, appendFileSync as appendFileSync3, constants as fsConstants, mkdirSync as mkdirSync3, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { resolve as pathResolve } from "path";
 import { homedir as homedir5 } from "os";
 import { delimiter, dirname as dirname5, join as join5 } from "path";
 
@@ -19275,6 +19312,38 @@ function messageContentToText(content) {
   }
   return hasText ? parts.join("\n") : "";
 }
+function imageBlockToAnthropic(block) {
+  if (!block.data || !block.mimeType) return void 0;
+  return { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } };
+}
+function toolResultContentToAnthropic(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const blocks = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      blocks.push({ type: "text", text: block.text });
+    } else if (block.type === "image") {
+      const image = imageBlockToAnthropic(block);
+      if (image) blocks.push(image);
+    } else if (block.type) {
+      blocks.push({ type: "text", text: `[${block.type}]` });
+    }
+  }
+  if (blocks.length === 0) return "";
+  if (blocks.every((block) => block.type === "text")) return blocks.map((block) => block.text).join("\n");
+  return blocks;
+}
+function assistantProvenancePrefix(msg) {
+  if (msg.role !== "assistant") return void 0;
+  const provider = typeof msg.provider === "string" ? msg.provider : void 0;
+  const model = typeof msg.model === "string" ? msg.model : void 0;
+  const api = typeof msg.api === "string" ? msg.api : void 0;
+  if (!provider && !model && !api) return void 0;
+  if (provider === PROVIDER_ID || api === "anthropic") return void 0;
+  return `[Prior Pi assistant response from ${provider ?? api ?? "unknown-provider"}${model ? `/${model}` : ""}]
+`;
+}
 function convertPiMessages(messages, customToolNameToSdk) {
   const anthropicMessages = [];
   const sanitizedIds = /* @__PURE__ */ new Map();
@@ -19287,16 +19356,18 @@ function convertPiMessages(messages, customToolNameToSdk) {
         for (const block of msg.content) {
           if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
           else if (block.type === "image" && block.data && block.mimeType) {
-            parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+            parts.push(imageBlockToAnthropic(block));
           }
         }
-        anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+        anthropicMessages.push({ role: "user", content: parts.filter(Boolean).length ? parts.filter(Boolean) : "[image]" });
       } else {
         anthropicMessages.push({ role: "user", content: "[empty]" });
       }
     } else if (msg.role === "assistant") {
       const content = Array.isArray(msg.content) ? msg.content : [];
       const blocks = [];
+      const provenance = assistantProvenancePrefix(msg);
+      if (provenance) blocks.push({ type: "text", text: provenance });
       for (const block of content) {
         if (block.type === "text" && block.text) {
           blocks.push({ type: "text", text: block.text });
@@ -19314,10 +19385,10 @@ function convertPiMessages(messages, customToolNameToSdk) {
       if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
       anthropicMessages.push({ role: "assistant", content: blocks });
     } else if (msg.role === "toolResult") {
-      const text = typeof msg.content === "string" ? msg.content : messageContentToText(msg.content);
+      const content = toolResultContentToAnthropic(msg.content);
       anthropicMessages.push({
         role: "user",
-        content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: text || "", is_error: msg.isError }]
+        content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: content || "", is_error: msg.isError }]
       });
     }
   }
@@ -19360,7 +19431,7 @@ function rewriteSkillsBlock(skillsBlock) {
 }
 
 // src/session-verify.ts
-import { statSync as statSync2, readFileSync as readFileSync2 } from "fs";
+import { statSync as statSync2, readFileSync as readFileSync3 } from "fs";
 function verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount) {
   const warnings = [];
   let st;
@@ -19372,7 +19443,7 @@ function verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount)
   }
   let content;
   try {
-    content = readFileSync2(jsonlPath, "utf8");
+    content = readFileSync3(jsonlPath, "utf8");
   } catch (e2) {
     warnings.push(`file unreadable \u2014 path=${jsonlPath} size=${st.size} err=${e2.message}`);
     return warnings;
@@ -19484,7 +19555,7 @@ function popContext() {
 }
 
 // src/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2, resolve } from "path";
 var PACKAGE_ID = "@vanillagreen/pi-claude-bridge";
@@ -19525,7 +19596,7 @@ function settingsPaths(cwd) {
 function tryParseJson(path) {
   if (!existsSync3(path)) return {};
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch (e2) {
     console.error(`claude-bridge: failed to parse ${path}: ${e2}`);
     return {};
@@ -19536,7 +19607,7 @@ function readManagerConfig(cwd) {
   for (const path of settingsPaths(cwd)) {
     if (!existsSync3(path)) continue;
     try {
-      const parsed = JSON.parse(readFileSync3(path, "utf8"));
+      const parsed = JSON.parse(readFileSync4(path, "utf8"));
       const configRoot = asRecord(asRecord(asRecord(parsed?.vstack)?.extensionManager)?.config);
       const config2 = asRecord(configRoot?.[PACKAGE_ID]);
       if (config2) mergeDeep(merged, config2);
@@ -19587,7 +19658,7 @@ function loadConfig(cwd) {
 }
 
 // src/agents-md.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
 var GLOBAL_AGENTS_PATH = join3(homedir3(), ".pi", "agent", "AGENTS.md");
@@ -19612,7 +19683,7 @@ function extractAgentsAppend() {
   const agentsPath = resolveAgentsMdPath();
   if (!agentsPath) return void 0;
   try {
-    const content = readFileSync4(agentsPath, "utf-8").trim();
+    const content = readFileSync5(agentsPath, "utf-8").trim();
     if (!content) return void 0;
     const sanitized = sanitizeAgentsContent(content);
     return sanitized.length > 0 ? `# CLAUDE.md
@@ -19632,7 +19703,7 @@ function sanitizeAgentsContent(content) {
 }
 
 // src/prompt-context.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname4, join as join4, resolve as resolve3 } from "path";
 function piUserDir2() {
@@ -19643,7 +19714,7 @@ function piUserDir2() {
 function readTrimmed(path) {
   try {
     if (!existsSync5(path)) return void 0;
-    const content = readFileSync5(path, "utf8").trim();
+    const content = readFileSync6(path, "utf8").trim();
     return content.length > 0 ? content : void 0;
   } catch {
     return void 0;
@@ -19727,11 +19798,7 @@ ${taskReminder}`);
     }
   }
   if (settings.includeCavemanHook) {
-    const caveman = extractBlockByMarkers(systemPrompt, [
-      /^Caveman communication mode active/m,
-      /^Token efficiency mode: terse smart caveman/m,
-      /^Caveman mode is active/m
-    ]);
+    const caveman = extractBlockByMarkers(systemPrompt, [/^You MUST respond in caveman /m]);
     if (caveman) {
       parts.push(`### before_agent_start: caveman
 
@@ -34267,7 +34334,7 @@ config(en_default());
 // src/typebox-to-zod.ts
 function jsonSchemaPropertyToZod(prop) {
   let base;
-  if (Array.isArray(prop.enum)) base = external_exports.enum(prop.enum);
+  if (Array.isArray(prop.enum) && prop.enum.length > 0) base = external_exports.enum(prop.enum);
   else switch (prop.type) {
     case "string":
       base = external_exports.string();
@@ -34279,12 +34346,22 @@ function jsonSchemaPropertyToZod(prop) {
     case "boolean":
       base = external_exports.boolean();
       break;
-    case "array":
+    case "array": {
       base = prop.items ? external_exports.array(jsonSchemaPropertyToZod(prop.items)) : external_exports.array(external_exports.unknown());
+      const minItems = typeof prop.minItems === "number" ? prop.minItems : void 0;
+      if (minItems !== void 0) base = base.min(minItems);
       break;
-    case "object":
-      base = external_exports.record(external_exports.string(), external_exports.unknown());
+    }
+    case "object": {
+      if (prop.properties && typeof prop.properties === "object" && !Array.isArray(prop.properties)) {
+        base = external_exports.object(jsonSchemaToZodShape(prop));
+        if (prop.additionalProperties === false) base = base.strict();
+        else if (prop.additionalProperties === true) base = base.passthrough();
+      } else {
+        base = external_exports.record(external_exports.string(), external_exports.unknown());
+      }
       break;
+    }
     default:
       base = external_exports.unknown();
   }
@@ -34423,6 +34500,113 @@ var CLAUDE_BRIDGE_TOOL_ISOLATION = {
   allowedTools: [`mcp__${MCP_SERVER_NAME}__*`]
 };
 var sharedSession = null;
+var extensionApi;
+var BRIDGE_SESSION_CUSTOM_TYPE = "claude-bridge-session";
+function fingerprintMessages(messages) {
+  const normalized = messages.map((message) => {
+    if (message.role === "assistant") {
+      return {
+        role: message.role,
+        provider: message.provider,
+        model: message.model,
+        content: message.content
+      };
+    }
+    return message;
+  });
+  return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+function readBuiltSessionContext(sessionManager) {
+  const built = typeof sessionManager?.buildSessionContext === "function" ? sessionManager.buildSessionContext() : void 0;
+  return Array.isArray(built?.messages) ? built : void 0;
+}
+function latestPersistedBridgeSession(sessionManager) {
+  const entries = typeof sessionManager?.getEntries === "function" ? sessionManager.getEntries() : [];
+  if (!Array.isArray(entries)) return void 0;
+  for (let i2 = entries.length - 1; i2 >= 0; i2--) {
+    const entry = entries[i2];
+    if (entry?.type !== "custom" || entry.customType !== BRIDGE_SESSION_CUSTOM_TYPE) continue;
+    const data = entry.data;
+    if (!data || typeof data.sessionId !== "string" || typeof data.cursor !== "number" || typeof data.cwd !== "string" || typeof data.fingerprint !== "string") continue;
+    return data;
+  }
+  return void 0;
+}
+function claudeSessionExists(sessionId, cwd) {
+  try {
+    const session = openSession({ sessionId, projectPath: cwd, claudeDir: process.env.CLAUDE_CONFIG_DIR });
+    statSync3(session.jsonlPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function canonicalize(p4) {
+  if (!p4) return void 0;
+  try {
+    return realpathSync3.native(p4);
+  } catch {
+    return pathResolve(p4);
+  }
+}
+function shouldRestorePersistedBridgeEntry(persisted, currentPiSessionId, currentCwd) {
+  if (!persisted.piSessionId) return "missing piSessionId";
+  if (currentPiSessionId && persisted.piSessionId !== currentPiSessionId) {
+    return `piSessionId mismatch (persisted=${persisted.piSessionId} current=${currentPiSessionId})`;
+  }
+  if (currentCwd && canonicalize(persisted.cwd) !== canonicalize(currentCwd)) {
+    return `cwd mismatch (persisted=${persisted.cwd} current=${currentCwd})`;
+  }
+  return void 0;
+}
+function restoreSharedSessionFromPi(ctx2) {
+  const persisted = latestPersistedBridgeSession(ctx2.sessionManager);
+  if (!persisted) return;
+  const currentPiSessionId = typeof ctx2.sessionManager?.getSessionId === "function" ? ctx2.sessionManager.getSessionId() : void 0;
+  const currentCwd = typeof ctx2.sessionManager?.getCwd === "function" ? ctx2.sessionManager.getCwd() : ctx2.cwd;
+  const rejection = shouldRestorePersistedBridgeEntry(persisted, currentPiSessionId, currentCwd);
+  if (rejection) {
+    debug(`restoreSharedSession: ${rejection} \u2014 forcing rebuild`);
+    return;
+  }
+  const built = readBuiltSessionContext(ctx2.sessionManager);
+  if (!built) return;
+  const cursor = Math.max(0, Math.min(persisted.cursor, built.messages.length));
+  const fingerprint = fingerprintMessages(built.messages.slice(0, cursor));
+  if (fingerprint !== persisted.fingerprint) {
+    debug(`restoreSharedSession: fingerprint mismatch for ${persisted.sessionId.slice(0, 8)}`);
+    return;
+  }
+  if (!claudeSessionExists(persisted.sessionId, persisted.cwd)) {
+    debug(`restoreSharedSession: Claude session missing for ${persisted.sessionId.slice(0, 8)}`);
+    return;
+  }
+  sharedSession = { sessionId: persisted.sessionId, cursor, cwd: persisted.cwd };
+  debug(`restoreSharedSession: restored ${persisted.sessionId.slice(0, 8)}, cursor=${cursor}`);
+}
+function schedulePersistSharedSession(ctxLike) {
+  if (!extensionApi || !sharedSession || !ctxLike?.sessionManager) return;
+  const snapshot = { ...sharedSession };
+  const timer = setTimeout(() => {
+    try {
+      const built = readBuiltSessionContext(ctxLike.sessionManager);
+      if (!built) return;
+      const cursor = Math.max(0, Math.min(snapshot.cursor, built.messages.length));
+      const data = {
+        ...snapshot,
+        cursor,
+        fingerprint: fingerprintMessages(built.messages.slice(0, cursor)),
+        piSessionId: typeof ctxLike.sessionManager?.getSessionId === "function" ? ctxLike.sessionManager.getSessionId() : void 0,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      extensionApi?.appendEntry(BRIDGE_SESSION_CUSTOM_TYPE, data);
+      debug(`persistSharedSession: saved ${data.sessionId.slice(0, 8)}, cursor=${data.cursor}`);
+    } catch (error51) {
+      debug("persistSharedSession failed:", error51);
+    }
+  }, 0);
+  timer.unref?.();
+}
 function convertAndImportMessages(session, messages, customToolNameToSdk) {
   const { anthropicMessages, sanitizedIds } = convertPiMessages(messages, customToolNameToSdk);
   debug(`convertAndImportMessages: ${messages.length} pi msgs \u2192 ${anthropicMessages.length} anthropic msgs`);
@@ -35138,6 +35322,7 @@ function streamClaudeAgentSdk(model, context, options) {
   return stream;
 }
 function index_default(pi) {
+  extensionApi = pi;
   process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
   const config2 = loadConfig(process.cwd());
   debug("loadConfig:", JSON.stringify(config2));
@@ -35159,8 +35344,13 @@ function index_default(pi) {
     if (event.reason === "new" || event.reason === "resume" || event.reason === "fork") {
       clearSession(`session_start:${event.reason}`);
     }
+    if (event.reason === "startup" || event.reason === "resume") restoreSharedSessionFromPi(ctx2);
   });
   pi.on("session_shutdown", () => clearSession("session_shutdown"));
+  pi.on("message_end", (event, ctx2) => {
+    const message = event.message;
+    if (message?.role === "assistant" && message.provider === PROVIDER_ID) schedulePersistSharedSession(ctx2);
+  });
   const markRebuild = (event) => {
     if (sharedSession) {
       debug(`${event}: marking needsRebuild on session ${sharedSession.sessionId.slice(0, 8)}`);
@@ -35188,5 +35378,7 @@ export {
   CLAUDE_BRIDGE_TOOL_ISOLATION,
   DISALLOWED_BUILTIN_TOOLS,
   index_default as default,
-  mapToolName
+  mapToolName,
+  restoreSharedSessionFromPi,
+  shouldRestorePersistedBridgeEntry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-claude-bridge",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "description": "Pi provider bridge that runs Claude Code through the Claude Agent SDK, with opt-in forwarding for Pi prompt context.",
   "type": "module",
   "keywords": [

package/src/convert.ts

@@ -2,7 +2,7 @@
 // Extracted so they can be tested without pulling in the full extension runtime.
 
 import type { Message as PiMessage } from "@earendil-works/pi-ai";
-import type { Message as SessionMessage } from "cc-session-io";
+import type { ContentBlock, Message as SessionMessage } from "cc-session-io";
 import { pascalCase } from "change-case";
 
 export const PROVIDER_ID = "claude-bridge";
@@ -44,6 +44,42 @@ export function messageContentToText(
 	return hasText ? parts.join("\n") : "";
 }
 
+function imageBlockToAnthropic(block: { data?: string; mimeType?: string }): ContentBlock | undefined {
+	if (!block.data || !block.mimeType) return undefined;
+	return { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } } as ContentBlock;
+}
+
+function toolResultContentToAnthropic(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | ContentBlock[] {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const blocks: ContentBlock[] = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) {
+			blocks.push({ type: "text", text: block.text });
+		} else if (block.type === "image") {
+			const image = imageBlockToAnthropic(block);
+			if (image) blocks.push(image);
+		} else if (block.type) {
+			blocks.push({ type: "text", text: `[${block.type}]` });
+		}
+	}
+	if (blocks.length === 0) return "";
+	if (blocks.every((block) => block.type === "text")) return blocks.map((block) => (block as { text: string }).text).join("\n");
+	return blocks;
+}
+
+function assistantProvenancePrefix(msg: PiMessage): string | undefined {
+	if (msg.role !== "assistant") return undefined;
+	const provider = typeof (msg as any).provider === "string" ? (msg as any).provider : undefined;
+	const model = typeof (msg as any).model === "string" ? (msg as any).model : undefined;
+	const api = typeof (msg as any).api === "string" ? (msg as any).api : undefined;
+	if (!provider && !model && !api) return undefined;
+	if (provider === PROVIDER_ID || api === "anthropic") return undefined;
+	return `[Prior Pi assistant response from ${provider ?? api ?? "unknown-provider"}${model ? `/${model}` : ""}]\n`;
+}
+
 /** Convert pi message array to Anthropic API format. */
 export function convertPiMessages(
 	messages: PiMessage[],
@@ -61,16 +97,18 @@ export function convertPiMessages(
 				for (const block of msg.content) {
 					if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
 					else if (block.type === "image" && block.data && block.mimeType) {
-						parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+						parts.push(imageBlockToAnthropic(block));
 					}
 				}
-				anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+				anthropicMessages.push({ role: "user", content: parts.filter(Boolean).length ? parts.filter(Boolean) as ContentBlock[] : "[image]" });
 			} else {
 				anthropicMessages.push({ role: "user", content: "[empty]" });
 			}
 		} else if (msg.role === "assistant") {
 			const content = Array.isArray(msg.content) ? msg.content : [];
 			const blocks = [];
+			const provenance = assistantProvenancePrefix(msg);
+			if (provenance) blocks.push({ type: "text", text: provenance });
 			for (const block of content) {
 				if (block.type === "text" && block.text) {
 					blocks.push({ type: "text", text: block.text });
@@ -88,10 +126,10 @@ export function convertPiMessages(
 			if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
 			anthropicMessages.push({ role: "assistant", content: blocks });
 		} else if (msg.role === "toolResult") {
-			const text = typeof msg.content === "string" ? msg.content : messageContentToText(msg.content);
+			const content = toolResultContentToAnthropic(msg.content);
 			anthropicMessages.push({
 				role: "user",
-				content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: text || "", is_error: msg.isError }],
+				content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: content || "", is_error: msg.isError }],
 			});
 		}
 	}

package/src/index.ts

@@ -3,8 +3,10 @@ import * as piAi from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { createSdkMcpServer, query, type EffortLevel, type SDKMessage, type SDKUserMessage, type SettingSource } from "@anthropic-ai/claude-agent-sdk";
 import type { Base64ImageSource, ContentBlockParam, MessageParam } from "@anthropic-ai/sdk/resources";
-import { createSession, deleteSession, repairToolPairing } from "cc-session-io";
+import { createSession, deleteSession, openSession, repairToolPairing } from "cc-session-io";
+import { createHash } from "crypto";
 import { accessSync, appendFileSync, constants as fsConstants, mkdirSync, realpathSync, statSync } from "fs";
+import { resolve as pathResolve } from "path";
 import { homedir } from "os";
 import { delimiter, dirname, join } from "path";
 import { PROVIDER_ID, messageContentToText, convertPiMessages } from "./convert.js";
@@ -184,12 +186,145 @@ interface SessionState {
 }
 
 let sharedSession: SessionState | null = null;
+let extensionApi: ExtensionAPI | undefined;
+
+const BRIDGE_SESSION_CUSTOM_TYPE = "claude-bridge-session";
+
+interface PersistedBridgeSessionState extends SessionState {
+	fingerprint: string;
+	piSessionId?: string;
+	updatedAt: string;
+}
+
+function fingerprintMessages(messages: Context["messages"]): string {
+	const normalized = messages.map((message) => {
+		if (message.role === "assistant") {
+			return {
+				role: message.role,
+				provider: (message as AssistantMessage).provider,
+				model: (message as AssistantMessage).model,
+				content: (message as AssistantMessage).content,
+			};
+		}
+		return message;
+	});
+	return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+
+function readBuiltSessionContext(sessionManager: unknown): { messages: Context["messages"] } | undefined {
+	const built = typeof (sessionManager as any)?.buildSessionContext === "function" ? (sessionManager as any).buildSessionContext() : undefined;
+	return Array.isArray(built?.messages) ? built as { messages: Context["messages"] } : undefined;
+}
+
+function latestPersistedBridgeSession(sessionManager: unknown): PersistedBridgeSessionState | undefined {
+	const entries = typeof (sessionManager as any)?.getEntries === "function" ? (sessionManager as any).getEntries() : [];
+	if (!Array.isArray(entries)) return undefined;
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry?.type !== "custom" || entry.customType !== BRIDGE_SESSION_CUSTOM_TYPE) continue;
+		const data = entry.data as Partial<PersistedBridgeSessionState> | undefined;
+		if (!data || typeof data.sessionId !== "string" || typeof data.cursor !== "number" || typeof data.cwd !== "string" || typeof data.fingerprint !== "string") continue;
+		return data as PersistedBridgeSessionState;
+	}
+	return undefined;
+}
+
+function claudeSessionExists(sessionId: string, cwd: string): boolean {
+	try {
+		const session = openSession({ sessionId, projectPath: cwd, claudeDir: process.env.CLAUDE_CONFIG_DIR });
+		statSync(session.jsonlPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function canonicalize(p: string | undefined): string | undefined {
+	if (!p) return undefined;
+	try { return realpathSync.native(p); } catch { return pathResolve(p); }
+}
+
+// Decides whether a persisted bridge-session marker is safe to restore.
+//
+// The fork case is the load-bearing one: pi/core's createBranchedSession copies
+// every non-label entry from root→leaf into the new session file. That includes
+// our claude-bridge-session markers from the parent. Restoring from them would
+// --resume parent's Claude jsonl on the fork's first turn, leaking conversation
+// past the fork point.
+//
+// Returns undefined when the entry is safe to use, or a short rejection reason
+// for diagnostic logging. Old entries without piSessionId always reject, which
+// degrades safely to the rebuild path.
+export function shouldRestorePersistedBridgeEntry(
+	persisted: { piSessionId?: string; cwd: string },
+	currentPiSessionId: string | undefined,
+	currentCwd: string | undefined,
+): string | undefined {
+	if (!persisted.piSessionId) return "missing piSessionId";
+	if (currentPiSessionId && persisted.piSessionId !== currentPiSessionId) {
+		return `piSessionId mismatch (persisted=${persisted.piSessionId} current=${currentPiSessionId})`;
+	}
+	if (currentCwd && canonicalize(persisted.cwd) !== canonicalize(currentCwd)) {
+		return `cwd mismatch (persisted=${persisted.cwd} current=${currentCwd})`;
+	}
+	return undefined;
+}
+
+export function restoreSharedSessionFromPi(ctx: { sessionManager?: unknown; cwd?: string }): void {
+	const persisted = latestPersistedBridgeSession(ctx.sessionManager);
+	if (!persisted) return;
+	const currentPiSessionId = typeof (ctx.sessionManager as any)?.getSessionId === "function" ? (ctx.sessionManager as any).getSessionId() : undefined;
+	const currentCwd = typeof (ctx.sessionManager as any)?.getCwd === "function" ? (ctx.sessionManager as any).getCwd() : ctx.cwd;
+	const rejection = shouldRestorePersistedBridgeEntry(persisted, currentPiSessionId, currentCwd);
+	if (rejection) {
+		debug(`restoreSharedSession: ${rejection} — forcing rebuild`);
+		return;
+	}
+	const built = readBuiltSessionContext(ctx.sessionManager);
+	if (!built) return;
+	const cursor = Math.max(0, Math.min(persisted.cursor, built.messages.length));
+	const fingerprint = fingerprintMessages(built.messages.slice(0, cursor));
+	if (fingerprint !== persisted.fingerprint) {
+		debug(`restoreSharedSession: fingerprint mismatch for ${persisted.sessionId.slice(0, 8)}`);
+		return;
+	}
+	if (!claudeSessionExists(persisted.sessionId, persisted.cwd)) {
+		debug(`restoreSharedSession: Claude session missing for ${persisted.sessionId.slice(0, 8)}`);
+		return;
+	}
+	sharedSession = { sessionId: persisted.sessionId, cursor, cwd: persisted.cwd };
+	debug(`restoreSharedSession: restored ${persisted.sessionId.slice(0, 8)}, cursor=${cursor}`);
+}
+
+function schedulePersistSharedSession(ctxLike?: { sessionManager?: unknown }): void {
+	if (!extensionApi || !sharedSession || !ctxLike?.sessionManager) return;
+	const snapshot = { ...sharedSession };
+	const timer = setTimeout(() => {
+		try {
+			const built = readBuiltSessionContext(ctxLike.sessionManager);
+			if (!built) return;
+			const cursor = Math.max(0, Math.min(snapshot.cursor, built.messages.length));
+			const data: PersistedBridgeSessionState = {
+				...snapshot,
+				cursor,
+				fingerprint: fingerprintMessages(built.messages.slice(0, cursor)),
+				piSessionId: typeof (ctxLike.sessionManager as any)?.getSessionId === "function" ? (ctxLike.sessionManager as any).getSessionId() : undefined,
+				updatedAt: new Date().toISOString(),
+			};
+			extensionApi?.appendEntry(BRIDGE_SESSION_CUSTOM_TYPE, data);
+			debug(`persistSharedSession: saved ${data.sessionId.slice(0, 8)}, cursor=${data.cursor}`);
+		} catch (error) {
+			debug("persistSharedSession failed:", error);
+		}
+	}, 0);
+	timer.unref?.();
+}
 
 // Convert pi messages to Anthropic API format for session import.
-// Lossy: non-Anthropic thinking blocks are dropped (no valid signature), and only
-// text/image/toolCall block types are handled. If all blocks in an assistant message
-// are filtered, the message is dropped — which can create invalid sequences (e.g.
-// two user messages in a row, or tool_result without preceding tool_use).
+// Lossy: non-Anthropic thinking blocks are dropped (no valid signature). User and
+// tool-result image blocks are preserved when possible. If assistant blocks are
+// otherwise incompatible, convertPiMessages emits a text placeholder so the record
+// sequence stays valid before repairToolPairing runs.
 function convertAndImportMessages(
 	session: ReturnType<typeof createSession>,
 	messages: Context["messages"],
@@ -1166,6 +1301,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 // --- Extension registration ---
 
 export default function (pi: ExtensionAPI) {
+	extensionApi = pi;
 	// Disable non-essential Claude Code traffic (update checks, MCP registry, telemetry)
 	process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
 
@@ -1195,8 +1331,17 @@ export default function (pi: ExtensionAPI) {
 		if (event.reason === "new" || event.reason === "resume" || event.reason === "fork") {
 			clearSession(`session_start:${event.reason}`);
 		}
+		// Note: "fork" intentionally omitted from restoration. createBranchedSession
+		// copies the parent's persisted bridge entries into the fork; restoring from
+		// them would --resume the parent's Claude jsonl and leak conversation past the
+		// fork point. Letting the first fork turn rebuild is the correct path.
+		if (event.reason === "startup" || event.reason === "resume") restoreSharedSessionFromPi(ctx);
 	});
 	pi.on("session_shutdown", () => clearSession("session_shutdown"));
+	pi.on("message_end", (event, ctx) => {
+		const message = (event as { message?: AssistantMessage }).message;
+		if (message?.role === "assistant" && message.provider === PROVIDER_ID) schedulePersistSharedSession(ctx);
+	});
 
 	// pi /compact and session-tree navigation (rewind / fork-at-point /
 	// branch switch) both mutate pi's messages array out from under the

package/src/prompt-context.ts

@@ -115,11 +115,7 @@ export function buildPromptContextAppend(systemPrompt: string | undefined, cwd:
 	}
 
 	if (settings.includeCavemanHook) {
-		const caveman = extractBlockByMarkers(systemPrompt, [
-			/^Caveman communication mode active/m,
-			/^Token efficiency mode: terse smart caveman/m,
-			/^Caveman mode is active/m,
-		]);
+		const caveman = extractBlockByMarkers(systemPrompt, [/^You MUST respond in caveman /m]);
 		if (caveman) {
 			parts.push(`### before_agent_start: caveman\n\n${caveman}`);
 			labels.push("caveman hook");

package/src/typebox-to-zod.ts

@@ -13,15 +13,29 @@ import { z } from "zod";
 
 export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
 	let base: z.ZodTypeAny;
-	if (Array.isArray(prop.enum)) base = z.enum(prop.enum as [string, ...string[]]);
+	if (Array.isArray(prop.enum) && prop.enum.length > 0) base = z.enum(prop.enum as [string, ...string[]]);
 	else switch (prop.type) {
 		case "string": base = z.string(); break;
 		case "number": case "integer": base = z.number(); break;
 		case "boolean": base = z.boolean(); break;
-		case "array": base = prop.items
-			? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
-			: z.array(z.unknown()); break;
-		case "object": base = z.record(z.string(), z.unknown()); break;
+		case "array": {
+			base = prop.items
+				? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
+				: z.array(z.unknown());
+			const minItems = typeof prop.minItems === "number" ? prop.minItems : undefined;
+			if (minItems !== undefined) base = (base as z.ZodArray<z.ZodTypeAny>).min(minItems);
+			break;
+		}
+		case "object": {
+			if (prop.properties && typeof prop.properties === "object" && !Array.isArray(prop.properties)) {
+				base = z.object(jsonSchemaToZodShape(prop));
+				if (prop.additionalProperties === false) base = (base as z.ZodObject<Record<string, z.ZodTypeAny>>).strict();
+				else if (prop.additionalProperties === true) base = (base as z.ZodObject<Record<string, z.ZodTypeAny>>).passthrough();
+			} else {
+				base = z.record(z.string(), z.unknown());
+			}
+			break;
+		}
 		default: base = z.unknown();
 	}
 	if (typeof prop.description === "string") base = base.describe(prop.description);