@hienlh/ppm 0.20.5 → 0.20.7

package/src/providers/claude-agent-sdk.ts

@@ -18,10 +18,11 @@ import type {
   ModelOption,
 } from "./provider.interface.ts";
 import { configService } from "../services/config.service.ts";
+import { withSharedContext, stripSharedContext } from "../shared/provider-context.ts";
 import { mcpConfigService } from "../services/mcp-config.service.ts";
 import { listInheritedClaudeMcpServers } from "../services/claude-code-mcp.service.ts";
 import { updateFromSdkEvent } from "../services/claude-usage.service.ts";
-import { getSessionProjectPath, setSessionMetadata, getSessionTitles, insertTurnUsage, getSessionAccount } from "../services/db.service.ts";
+import { getSessionProjectPath, setSessionMetadata, getSessionTitle, setSessionTitle, getSessionTitles, insertTurnUsage, getSessionAccount } from "../services/db.service.ts";
 import { SUBSCRIPTION_PROMPT_CACHE_TTL_MS, API_KEY_PROMPT_CACHE_TTL_MS } from "../services/subprocess-retention.ts";
 import { buildTurnUsage, formatTurnUsageLog } from "../shared/turn-usage.ts";
 import { accountSelector } from "../services/account-selector.service.ts";
@@ -213,6 +214,7 @@ interface PendingApproval {
  * Uses canUseTool callback for tool approvals and AskUserQuestion.
  */
 export class ClaudeAgentSdkProvider implements AIProvider {
+  readonly supportsSharedContext = true;
   id = "claude";
   name = "Claude";
 
@@ -571,7 +573,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       const sessions: SessionInfo[] = sdkSessions.map((s) => ({
         id: s.sessionId,
         providerId: this.id,
-        title: dbTitles[s.sessionId] ?? s.customTitle ?? s.summary ?? s.firstPrompt ?? "Chat",
+        title: dbTitles[s.sessionId] ?? s.customTitle ?? s.summary ?? (stripSharedContext(s.firstPrompt ?? "") || "Chat"),
         createdAt: new Date(s.lastModified).toISOString(),
         updatedAt: new Date(s.lastModified).toISOString(),
       }));
@@ -619,7 +621,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         return {
           id: info.sessionId,
           providerId: this.id,
-          title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? info.firstPrompt ?? "Chat",
+          title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? (stripSharedContext(info.firstPrompt ?? "") || "Chat"),
           createdAt: new Date(info.lastModified).toISOString(),
           updatedAt: new Date(info.lastModified).toISOString(),
         };
@@ -725,13 +727,14 @@ export class ClaudeAgentSdkProvider implements AIProvider {
    * Push a follow-up message into an existing streaming session's generator.
    * Called by WS handler for follow-up messages (Phase 2).
    */
-  pushMessage(sessionId: string, content: string, opts?: { priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> }): void {
+  pushMessage(sessionId: string, content: string, opts?: import("./provider.interface.ts").SendMessageOpts): void {
     const ss = this.streamingSessions.get(sessionId);
     if (!ss) {
       console.warn(`[sdk] pushMessage: no streaming session for ${sessionId}`);
       return;
     }
-    const msgContent = buildMessageParam(content, opts?.images);
+    const modelInput = withSharedContext(content, opts?.sharedContext);
+    const msgContent = buildMessageParam(modelInput, opts?.images);
     ss.controller.push({
       type: 'user',
       message: msgContent,
@@ -740,7 +743,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       priority: opts?.priority ?? 'next',
     });
     // Track latest message for retry paths (fixes stale firstMsg bug)
-    ss.lastUserContent = content;
+    ss.lastUserContent = modelInput;
     ss.lastUserImages = opts?.images;
     console.log(`[sdk] pushMessage: session=${sessionId} priority=${opts?.priority ?? 'next'}`);
   }
@@ -794,6 +797,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     message: string,
     opts?: import("./provider.interface.ts").SendMessageOpts & { forkSession?: boolean; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> },
   ): AsyncIterable<ChatEvent> {
+    const modelInput = withSharedContext(message, opts?.sharedContext);
     // SDK requires valid UUID session IDs. Short/random IDs can leak from
     // tab derivation or URL parsing — migrate to a real UUID early.
     const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -826,7 +830,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     // Follow-up: push into existing streaming session, yield nothing
     const existingStream = this.streamingSessions.get(sessionId);
     if (existingStream) {
-      const msgContent = buildMessageParam(message, opts?.images);
+      const msgContent = buildMessageParam(modelInput, opts?.images);
       existingStream.controller.push({
         type: 'user',
         message: msgContent,
@@ -835,7 +839,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         priority: opts?.priority ?? 'next',
       });
       // Track latest message for retry paths (fixes stale firstMsg bug)
-      existingStream.lastUserContent = message;
+      existingStream.lastUserContent = modelInput;
       existingStream.lastUserImages = opts?.images;
       console.log(`[sdk] sendMessage follow-up: session=${sessionId} pushed to generator`);
       return; // Events flow through first-message's consumer loop
@@ -853,6 +857,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     const count = this.messageCount.get(sessionId) ?? 0;
     const isFirstMessage = count === 0;
     this.messageCount.set(sessionId, count + 1);
+    // Native firstPrompt may truncate before the shared-context block ends.
+    // Keep the opening user title available after restart without replacing a rename.
+    if (isFirstMessage && opts?.sharedContext && getSessionTitle(sessionId) === null) {
+      setSessionTitle(sessionId, meta.title);
+    }
 
     // Check if this session should fork from another
     const forkSourceId = this.forkSources.get(sessionId);
@@ -1145,7 +1154,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // model a bare path instead — the round trip the caller passed them in to avoid.
       const firstMsg = {
         type: 'user' as const,
-        message: buildMessageParam(message, opts?.images),
+        message: buildMessageParam(modelInput, opts?.images),
         parent_tool_use_id: null,
         session_id: sessionId,
       };
@@ -1165,7 +1174,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // Also returns the raw content/images for re-populating the new streaming session.
       const buildRetryMsg = () => {
         const ss = this.streamingSessions.get(sessionId);
-        const content = ss?.lastUserContent ?? message;
+        const content = ss?.lastUserContent ?? modelInput;
         const images = ss?.lastUserImages;
         const retryContent = turnProgressed ? "Continue from where you left off." : content;
         return {
@@ -1184,7 +1193,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // On crash retry, use buildRetryMsg to get the latest user message (not the stale firstMsg)
       const initRetry = crashRetryCount > 0 ? buildRetryMsg() : null;
       initialCtrl.push(initRetry?.msg ?? firstMsg);
-      const initContent = initRetry?.lastUserContent ?? message;
+      const initContent = initRetry?.lastUserContent ?? modelInput;
       const initImages = initRetry?.lastUserImages ?? opts?.images;
 
       const initialQuery = query({
@@ -2219,7 +2228,7 @@ function findMissingSessions(
           if (head[end] === '"') break;
           end++;
         }
-        const raw = head.slice(start, end).replace(/\\n/g, " ").replace(/\\"/g, '"').trim();
+        const raw = stripSharedContext(head.slice(start, end).replace(/\\n/g, "\n").replace(/\\"/g, '"').trim()).replace(/\n/g, " ");
         if (raw.length > 0) {
           title = raw.length > 120 ? raw.slice(0, 120) + "…" : raw;
         }
@@ -2236,4 +2245,3 @@ function findMissingSessions(
   }
   return results;
 }
-

package/src/providers/cli-provider-base.ts

@@ -9,6 +9,7 @@ import type {
 import { spawn, type ChildProcess } from "node:child_process";
 import { parseNdjsonLines } from "../utils/ndjson-line-parser.ts";
 import { configService } from "../services/config.service.ts";
+import { withSharedContext } from "../shared/provider-context.ts";
 
 /**
  * Abstract base class for CLI-spawning AI providers.
@@ -16,6 +17,7 @@ import { configService } from "../services/config.service.ts";
  * Subclasses only implement event mapping + arg building.
  */
 export abstract class CliProvider implements AIProvider {
+  readonly supportsSharedContext = true;
   abstract readonly id: string;
   abstract readonly name: string;
   abstract readonly cliCommand: string;
@@ -118,7 +120,7 @@ export abstract class CliProvider implements AIProvider {
     const config = this.getProviderConfig();
     const args = this.buildArgs({
       sessionId: isResume ? sessionId : undefined,
-      message,
+      message: withSharedContext(message, opts?.sharedContext),
       model: config?.model,
       permissionMode: opts?.permissionMode || config?.permission_mode,
       isResume,

package/src/providers/codex-app-server/codex-history.ts

@@ -1,4 +1,5 @@
 import type { ChatMessage, ChatEvent, SessionInfo } from "../provider.interface.ts";
+import { stripSharedContext } from "../../shared/provider-context.ts";
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
@@ -135,7 +136,7 @@ export function parseRolloutJsonl(
     if (rec.type === "event_msg") {
       if (p.type === "user_message" && typeof p.message === "string") {
         if (pendingEvents.length) flushAssistant("", ts); // tools with no final text
-        messages.push({ id: `rollout-${i++}`, role: "user", content: p.message, timestamp: ts });
+        messages.push({ id: `rollout-${i++}`, role: "user", content: stripSharedContext(p.message), timestamp: ts });
       } else if (p.type === "agent_message" && typeof p.message === "string") {
         flushAssistant(p.message, ts);
       } else if (p.type === "item_completed") {
@@ -145,7 +146,7 @@ export function parseRolloutJsonl(
         const mapped = mapRolloutItem(p.item);
         if (mapped.kind === "user") {
           if (pendingEvents.length) flushAssistant("", ts);
-          messages.push({ id: `rollout-${i++}`, role: "user", content: mapped.text, timestamp: ts });
+          messages.push({ id: `rollout-${i++}`, role: "user", content: stripSharedContext(mapped.text), timestamp: ts });
         } else if (mapped.kind === "assistant") {
           flushAssistant(mapped.text, ts);
         } else if (mapped.kind === "events") {
@@ -196,7 +197,8 @@ export function parseRolloutJsonl(
         if (item.type !== "message") continue;
         const role = item.role === "assistant" ? "assistant" : item.role === "user" ? "user" : null;
         if (!role) continue;
-        const content = contentToText(item.content);
+        const rawContent = contentToText(item.content);
+        const content = role === "user" ? stripSharedContext(rawContent) : rawContent;
         if (content) messages.push({ id: `rollout-${i++}`, role, content, timestamp: ts });
       }
     }

package/src/providers/codex-app-server/codex-provider.ts

@@ -10,6 +10,7 @@ import type {
   UsageInfo,
 } from "../provider.interface.ts";
 import { configService } from "../../services/config.service.ts";
+import { withSharedContext } from "../../shared/provider-context.ts";
 import { setSessionMetadata, getSessionProjectPath, setSessionProvider, setSessionCodexAccount, getSessionCodexAccount, getSessionTitles, insertTurnUsage } from "../../services/db.service.ts";
 import {
   resolveCodexAccountForSession,
@@ -291,6 +292,7 @@ function buildUserInputResponse(questions: unknown, data: unknown): ToolRequestU
  * notification stream. Token-by-token streaming is the load-bearing capability.
  */
 export class CodexAppServerProvider implements AIProvider {
+  readonly supportsSharedContext = true;
   readonly id = "codex";
   readonly name = "Codex";
 
@@ -448,7 +450,7 @@ export class CodexAppServerProvider implements AIProvider {
     // gets. Images lead: the text usually refers to them ("what is this?").
     const input: UserInput[] = [
       ...(opts?.imagePaths ?? []).map((path) => ({ type: "localImage" as const, path })),
-      { type: "text" as const, text: message, text_elements: [] },
+      { type: "text" as const, text: withSharedContext(message, opts?.sharedContext), text_elements: [] },
     ];
     const turnModel = codexModel(opts?.model);
     const turnEffort = opts?.effort ?? this.config?.effort;
@@ -651,6 +653,7 @@ export class CodexAppServerProvider implements AIProvider {
     client.notify("initialized");
 
     const resumeBase = {
+      ...this.contextConfigOverrides(),
       cwd: live.cwd,
       sandbox: live.permission.sandbox,
       approvalPolicy: live.permission.approvalPolicy,
@@ -687,6 +690,17 @@ export class CodexAppServerProvider implements AIProvider {
     return client.request("thread/resume", { threadId, path, ...resumeBase });
   }
 
+  /** Read on connect/resume only; changing settings never interrupts a live turn. */
+  private contextConfigOverrides(): { config?: Record<string, number> } {
+    const providerConfig = this.config;
+    const config: Record<string, number> = {};
+    for (const key of ["model_context_window", "model_auto_compact_token_limit"] as const) {
+      const value = providerConfig?.[key];
+      if (value != null) config[key] = value;
+    }
+    return Object.keys(config).length ? { config } : {};
+  }
+
   private async connect(sessionId: string, opts?: SendMessageOpts): Promise<LiveSession> {
     const meta = this.sessions.get(sessionId);
     const cwd = meta?.projectPath || getSessionProjectPath(sessionId) || process.cwd();
@@ -720,7 +734,7 @@ export class CodexAppServerProvider implements AIProvider {
     await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES }, CONTROL_REQUEST_TIMEOUT_MS);
     client.notify("initialized");
 
-    const resumeBase = { cwd, sandbox: permission.sandbox, approvalPolicy: permission.approvalPolicy, ...(model ? { model } : {}) };
+    const resumeBase = { cwd, sandbox: permission.sandbox, approvalPolicy: permission.approvalPolicy, ...(model ? { model } : {}), ...this.contextConfigOverrides() };
     // Only treat as a resume when a rollout for this id is attributable to THIS
     // project (fail-closed cwd guard) — never resume another project's thread.
     const result = found

package/src/providers/codex-app-server/codex-rollout-header.ts

@@ -1,4 +1,5 @@
 import { mapRolloutItem } from "./codex-rollout-items.ts";
+import { stripSharedContext } from "../../shared/provider-context.ts";
 
 /**
  * Line primitives for a codex rollout JSONL, plus the header a session list
@@ -49,7 +50,7 @@ const TITLE_MAX_CHARS = 80;
 
 /** First user prompt → a one-line label. */
 function toTitle(text: string): string | undefined {
-  const flat = text.replace(/\s+/g, " ").trim();
+  const flat = stripSharedContext(text).replace(/\s+/g, " ").trim();
   if (!flat) return undefined;
   return flat.length > TITLE_MAX_CHARS ? `${flat.slice(0, TITLE_MAX_CHARS - 1)}…` : flat;
 }

package/src/providers/cursor-cli/cursor-history.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { existsSync, readdirSync } from "node:fs";
 import type { ChatMessage, SessionInfo } from "../provider.interface.ts";
+import { stripSharedContext } from "../../shared/provider-context.ts";
 
 const DEFAULT_CHATS_DIR = join(homedir(), ".cursor", "chats");
 
@@ -38,7 +39,7 @@ export async function listCursorSessions(providerId: string, chatsDir?: string):
               const hex = typeof row.value === "string" ? row.value : Buffer.from(row.value).toString("utf-8");
               const json = Buffer.from(hex, "hex").toString("utf-8");
               const meta = JSON.parse(json);
-              if (meta.name) title = meta.name.split("\n")[0].slice(0, 80);
+              if (meta.name) title = stripSharedContext(meta.name).split("\n")[0]?.slice(0, 80) || title;
               if (meta.createdAt) createdAt = new Date(meta.createdAt).toISOString();
             }
           } catch { /* use defaults */ }
@@ -139,6 +140,7 @@ function parseDagBlobs(
           if (parsed.role === "user") {
             const match = content.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
             if (match?.[1]) content = match[1];
+            content = stripSharedContext(content);
           }
           messages.push({
             id: blob.id,
@@ -159,7 +161,7 @@ function parseDagBlobs(
             messages.push({
               id: blob.id,
               role: messages.length % 2 === 0 ? "user" : "assistant",
-              content: textParts,
+              content: messages.length % 2 === 0 ? stripSharedContext(textParts) : textParts,
               timestamp: new Date().toISOString(),
             });
             continue;

package/src/server/routes/settings.ts

@@ -3,6 +3,7 @@ import { configService, FILE_CONFIG_KEYS } from "../../services/config.service.t
 import { getConfigValue, setConfigValue, listPairedChats, getPairingByCode, approvePairing, revokePairing, getPPMBotMemories, getDb } from "../../services/db.service.ts";
 import {
   validateAIProviderConfig,
+  validateCodexContextConfig,
   validateDefaultProvider,
   VALID_PROVIDERS,
   DEFAULT_CONFIG,
@@ -178,16 +179,21 @@ settingsRoutes.get("/ai", (c) => {
   return c.json(ok(stripSensitiveFields(ai)));
 });
 
-/** PUT /settings/ai — update AI provider settings, writes to yaml */
+/** PUT /settings/ai — update AI settings, persists to SQLite */
 settingsRoutes.put("/ai", async (c) => {
   try {
     const body = await c.req.json<{
       default_provider?: string;
+      share_provider_context?: boolean;
       providers?: Record<string, Partial<AIProviderConfig>>;
     }>();
 
     const currentAi = configService.get("ai");
 
+    if ("share_provider_context" in body && typeof body.share_provider_context !== "boolean") {
+      return c.json(err("share_provider_context must be a boolean"), 400);
+    }
+
     // Validate each provider config
     if (body.providers) {
       for (const [name, providerConfig] of Object.entries(body.providers)) {
@@ -201,6 +207,7 @@ settingsRoutes.put("/ai", async (c) => {
     // Merge: body overrides current values (shallow merge per provider)
     const updated = {
       ...currentAi,
+      share_provider_context: body.share_provider_context ?? currentAi.share_provider_context ?? true,
       ...(body.default_provider && { default_provider: body.default_provider }),
     };
     if (body.providers) {
@@ -214,6 +221,13 @@ settingsRoutes.put("/ai", async (c) => {
           ...currentAi.providers[name],
           ...config,
         } as AIProviderConfig;
+        for (const key of ["model_context_window", "model_auto_compact_token_limit"] as const) {
+          if (updated.providers[name]![key] === null) delete updated.providers[name]![key];
+        }
+        const contextErrors = validateCodexContextConfig(updated.providers[name]!);
+        if (contextErrors.length) {
+          return c.json(err(`Provider "${name}": ${contextErrors.join(", ")}`), 400);
+        }
       }
     }
 

package/src/server/ws/chat.ts

@@ -1288,7 +1288,7 @@ export const chatWebSocket = {
         if (provider && "pushMessage" in provider && parsed.type === "message") {
           const effort = getSessionEffort(sessionId) ?? undefined;
           const thinkingBudget = getSessionThinking(sessionId);
-          (provider as any).pushMessage(sessionId, parsed.content, {
+          await chatService.pushMessage(providerId, sessionId, parsed.content, {
             priority: parsed.priority ?? 'next',
             images: parsed.images,
             imagePaths: parsed.imagePaths,
@@ -1413,7 +1413,7 @@ export const chatWebSocket = {
           }, 0);
         });
       } else if (provider && "pushMessage" in provider) {
-        (provider as any).pushMessage(sessionId, instruction, { priority: "next" });
+        await chatService.pushMessage(providerId, sessionId, instruction, { priority: "next" });
         entry.turnEvents = [];
         entry.pendingApprovalEvent = undefined;
         setPhase(sessionId, "thinking");

package/src/services/chat.service.ts

@@ -1,4 +1,8 @@
 import { providerRegistry } from "../providers/registry.ts";
+import { configService } from "./config.service.ts";
+import { createHash } from "node:crypto";
+import { buildSharedProviderContext } from "./provider-shared-context.ts";
+import { stripSharedContext, withSharedContext } from "../shared/provider-context.ts";
 import type {
   Session,
   SessionConfig,
@@ -9,6 +13,20 @@ import type {
 } from "../providers/provider.interface.ts";
 
 class ChatService {
+  // Delivery hints only: a restart/eviction safely sends a fresh snapshot.
+  private sharedSnapshots = new Map<string, string>();
+
+  private rememberSharedContext(providerId: string, sessionId: string, context?: string): void {
+    if (!context) return;
+    const key = `${providerId}:${sessionId}`;
+    this.sharedSnapshots.delete(key);
+    this.sharedSnapshots.set(key, createHash("sha256").update(context).digest("hex"));
+    if (this.sharedSnapshots.size > 512) this.sharedSnapshots.delete(this.sharedSnapshots.keys().next().value!);
+  }
+
+  invalidateSharedContext(providerId: string, sessionId: string): void {
+    this.sharedSnapshots.delete(`${providerId}:${sessionId}`);
+  }
   async createSession(
     providerId?: string,
     config: SessionConfig = {},
@@ -32,6 +50,7 @@ class ChatService {
   ): Promise<Session> {
     const provider = providerRegistry.get(providerId);
     if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    this.invalidateSharedContext(providerId, sessionId);
     return provider.resumeSession(sessionId);
   }
 
@@ -68,6 +87,7 @@ class ChatService {
   ): Promise<void> {
     const provider = providerRegistry.get(providerId);
     if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    this.invalidateSharedContext(providerId, sessionId);
     return provider.deleteSession(sessionId);
   }
 
@@ -82,7 +102,77 @@ class ChatService {
       yield { type: "error", message: `Provider "${providerId}" not found` };
       return;
     }
-    yield* provider.sendMessage(sessionId, message, opts);
+    const prepared = await this.prepareSendOptions(providerId, sessionId, message, opts);
+    this.rememberSharedContext(providerId, sessionId, prepared.sharedContext);
+    let finished = false;
+    let activeSessionId = sessionId;
+    try {
+      for await (const event of provider.sendMessage(sessionId,
+        provider.supportsSharedContext ? message : withSharedContext(message, prepared.sharedContext),
+        { ...prepared, sharedContext: provider.supportsSharedContext ? prepared.sharedContext : undefined })) {
+        if (event.type === "error" || (event.type === "done" && event.resultSubtype?.startsWith("error")) || (event.type === "system" && event.subtype === "compact_done")) {
+          this.invalidateSharedContext(providerId, activeSessionId);
+        }
+        const migratedId = event.type === "session_migrated" ? event.newSessionId : event.type === "done" ? event.sessionId : undefined;
+        if (migratedId && migratedId !== activeSessionId) {
+          const snapshot = this.sharedSnapshots.get(`${providerId}:${activeSessionId}`);
+          if (snapshot) {
+            this.sharedSnapshots.set(`${providerId}:${migratedId}`, snapshot);
+            this.invalidateSharedContext(providerId, activeSessionId);
+          }
+          activeSessionId = migratedId;
+        }
+        yield event;
+      }
+      finished = true;
+    } finally {
+      if (!finished) this.invalidateSharedContext(providerId, activeSessionId);
+    }
+  }
+
+  /** Prepare context for both a new stream and a live stream's follow-up turn. */
+  async prepareSendOptions(
+    providerId: string,
+    sessionId: string,
+    message: string,
+    opts?: SendMessageOpts,
+  ): Promise<SendMessageOpts> {
+    if (!providerRegistry.get(providerId)) throw new Error(`Provider "${providerId}" not found`);
+    let sharedContext: string | undefined;
+    if (configService.get("ai").share_provider_context === false || /^\s*\/(compact|clear|new)(\s|$)/i.test(message)) {
+      this.invalidateSharedContext(providerId, sessionId);
+    }
+    // Slash commands belong to the runtime parser. A context prefix would turn
+    // /compact (or a provider skill) into an ordinary prompt.
+    if (configService.get("ai").share_provider_context !== false && !message.trimStart().startsWith("/")) {
+      const { getSessionProjectPath } = await import("./db.service.ts");
+      const projectPath = this.getSession(sessionId)?.projectPath ?? getSessionProjectPath(sessionId);
+      if (projectPath) {
+        const providers = providerRegistry.listAll().flatMap(({ id }) => {
+          const item = providerRegistry.get(id);
+          return item ? [item] : [];
+        });
+        sharedContext = await buildSharedProviderContext(projectPath, providers, { recipientProviderId: providerId });
+        const hash = createHash("sha256").update(sharedContext).digest("hex");
+        if (this.sharedSnapshots.get(`${providerId}:${sessionId}`) === hash) sharedContext = undefined;
+      }
+    }
+    return { ...opts, sharedContext };
+  }
+
+  /** Push a live follow-up through the same context policy as sendMessage. */
+  async pushMessage(providerId: string, sessionId: string, message: string, opts?: SendMessageOpts): Promise<void> {
+    const provider = providerRegistry.get(providerId);
+    if (!provider) throw new Error(`Provider "${providerId}" not found`);
+    const streaming = provider as typeof provider & {
+      pushMessage?: (id: string, content: string, options: SendMessageOpts) => void;
+    };
+    if (!streaming.pushMessage) return;
+    const prepared = await this.prepareSendOptions(providerId, sessionId, message, opts);
+    streaming.pushMessage(sessionId,
+      provider.supportsSharedContext ? message : withSharedContext(message, prepared.sharedContext),
+      { ...prepared, sharedContext: provider.supportsSharedContext ? prepared.sharedContext : undefined });
+    this.rememberSharedContext(providerId, sessionId, prepared.sharedContext);
   }
 
   /** Look up a session across all providers (for WS handler) */
@@ -106,7 +196,10 @@ class ChatService {
   async getMessages(providerId: string, sessionId: string): Promise<ChatMessage[]> {
     const provider = providerRegistry.get(providerId);
     if (!provider) return [];
-    return await provider.getMessages?.(sessionId) ?? [];
+    const messages = await provider.getMessages?.(sessionId) ?? [];
+    return messages.map((message) => message.role === "user"
+      ? { ...message, content: stripSharedContext(message.content) }
+      : message);
   }
 }
 

package/src/services/codex-native-memory.ts

@@ -0,0 +1,66 @@
+import { Database } from "bun:sqlite";
+import { readdirSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const MAX_MEMORIES = 24;
+const MAX_CHARS = 24_000;
+
+function latestDatabase(home: string, name: string): string | undefined {
+  try {
+    const candidates = readdirSync(home).filter((file) => new RegExp(`^${name}_\\d+\\.sqlite$`).test(file));
+    candidates.sort((a, b) => Number(b.match(/_(\d+)/)?.[1]) - Number(a.match(/_(\d+)/)?.[1]));
+    return candidates[0] ? join(home, candidates[0]) : undefined;
+  } catch { return undefined; }
+}
+
+/** Read native distilled memories only for threads belonging to this exact project. */
+export function readCodexNativeMemory(projectPath: string, codexHomes: string[]): Array<{ path: string; content: string }> {
+  const result: Array<{ path: string; content: string }> = [];
+  const windows = process.platform === "win32";
+  let canonicalProject = resolve(projectPath);
+  try { canonicalProject = realpathSync(canonicalProject); } catch { /* A deleted project can still have native memory. */ }
+  const project = canonicalProject.replaceAll("\\", "/").replace(/\/+$/, "");
+  let remaining = MAX_CHARS;
+  const seen = new Set<string>();
+  for (const home of new Set(codexHomes)) {
+    if (!remaining || result.length >= MAX_MEMORIES) break;
+    const statePath = latestDatabase(home, "state");
+    if (!statePath) continue;
+    // Older native releases stored stage1_outputs in the state database itself.
+    const memoryPath = latestDatabase(home, "memories") ?? statePath;
+    let state: Database | undefined;
+    let memories: Database | undefined;
+    try {
+      state = new Database(statePath, { readonly: true });
+      const columns = state.query("PRAGMA table_info(threads)").all() as Array<{ name: string }>;
+      const cwd = "rtrim(replace(cwd, char(92), '/'), '/')";
+      const enabled = columns.some((column) => column.name === "memory_mode") ? " AND memory_mode != 'disabled'" : "";
+      const recent = columns.some((column) => column.name === "updated_at") ? " ORDER BY updated_at DESC" : "";
+      const threads = state.query(`SELECT id FROM threads WHERE ${windows ? `lower(${cwd})` : cwd} = ?${enabled}${recent} LIMIT 256`)
+        .all(windows ? project.toLowerCase() : project) as Array<{ id: string }>;
+      if (!threads.length) continue;
+      memories = new Database(memoryPath, { readonly: true });
+      const placeholders = threads.map(() => "?").join(",");
+      const rows = memories.query(`SELECT thread_id, substr(raw_memory, 1, 12000) AS raw_memory, length(raw_memory) AS full_length FROM stage1_outputs WHERE thread_id IN (${placeholders}) ORDER BY generated_at DESC LIMIT ?`)
+        .all(...threads.map((thread) => thread.id), MAX_MEMORIES) as Array<{ thread_id: string; raw_memory: string; full_length: number }>;
+      for (const row of rows) {
+        const raw = row.raw_memory?.trim();
+        if (!raw || raw.includes("\0") || seen.has(raw) || remaining < 200) continue;
+        const path = `${memoryPath}#stage1_outputs/${row.thread_id}`;
+        const excerpt = raw.slice(0, Math.max(0, remaining - 180));
+        const truncated = row.full_length > excerpt.length;
+        const content = excerpt + (truncated ? "\n[Excerpt truncated. Read the raw_memory column of this source database row for the remaining native memory.]" : "");
+        seen.add(raw);
+        result.push({ path, content });
+        remaining -= content.length;
+        if (result.length >= MAX_MEMORIES) break;
+      }
+    } catch {
+      // Missing, locked, or newer incompatible native schemas must not block chat.
+    } finally {
+      memories?.close();
+      state?.close();
+    }
+  }
+  return result;
+}

package/src/services/db.service.ts

@@ -1301,10 +1301,24 @@ export function deleteSessionMetadata(sessionId: string): void {
  */
 export function setSessionMigratedTo(oldSessionId: string, newSessionId: string): void {
   if (oldSessionId === newSessionId) return;
-  getDb().query(
-    "INSERT INTO session_metadata (session_id, migrated_to) VALUES (?, ?) " +
-    "ON CONFLICT(session_id) DO UPDATE SET migrated_to = excluded.migrated_to",
-  ).run(oldSessionId, newSessionId);
+  const database = getDb();
+  database.transaction(() => {
+    // A provider's real thread id replaces the draft id on the first turn.
+    // Carry explicit choices with it before reconnect reads session_state.
+    // Keep any choices already made on the destination (including thinking OFF).
+    database.query(`
+      INSERT INTO session_metadata (session_id, model, effort, thinking_budget)
+      SELECT ?, model, effort, thinking_budget FROM session_metadata WHERE session_id = ?
+      ON CONFLICT(session_id) DO UPDATE SET
+        model = COALESCE(session_metadata.model, excluded.model),
+        effort = COALESCE(session_metadata.effort, excluded.effort),
+        thinking_budget = COALESCE(session_metadata.thinking_budget, excluded.thinking_budget)
+    `).run(newSessionId, oldSessionId);
+    database.query(
+      "INSERT INTO session_metadata (session_id, migrated_to) VALUES (?, ?) " +
+      "ON CONFLICT(session_id) DO UPDATE SET migrated_to = excluded.migrated_to",
+    ).run(oldSessionId, newSessionId);
+  })();
 }
 
 /**

package/src/services/jsonl-transcript-parser.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import type { ChatEvent, ChatMessage } from "../types/chat.ts";
 import { stringifyToolResultContent } from "../shared/tool-result-content.ts";
+import { stripSharedContext } from "../shared/provider-context.ts";
 
 const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
 const TEAMMATE_MSG_RE = /<teammate-message[^>]*>[\s\S]*?<\/teammate-message>/g;
@@ -117,7 +118,7 @@ export function parseSessionMessage(
   return {
     id: msg.uuid,
     role,
-    content: textContent,
+    content: role === "user" ? stripSharedContext(textContent) : textContent,
     events: events.length > 0 ? events : undefined,
     timestamp: msg.timestamp ?? new Date().toISOString(),
     sdkUuid: msg.uuid,