@gkorepanov/ccodex 0.4.12 → 0.4.14

package/README.md

@@ -155,7 +155,7 @@ keep working):
 | | |
 |---|---|
 | **CCodex** | `0.4.8` |
-| **Embedded Codex CLI** | `0.145.0` (pinned; a newer global Codex never replaces it) |
+| **Embedded Codex CLI** | `0.146.0` (pinned; a newer global Codex never replaces it) |
 | **Claude Agent SDK / Claude Code** | `0.3.219` / `2.1.219` |
 | **Runtime** | Node.js `>=22.13 <27`, npm `>=10` |
 | **Platforms** | macOS 11+ (arm64) · Linux arm64 & x64, glibc ≥2.31 (Ubuntu 22.04+, Debian 11+, Fedora/RHEL equivalents). Alpine/musl not supported |

package/config/compatibility.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "productVersion": "0.4.12",
+  "productVersion": "0.4.14",
   "node": ">=22.13 <27",
-  "codexCli": "0.145.0",
-  "codexGitRevision": "1635de866c61d1b76e50b31928ee6d61482435a8",
+  "codexCli": "0.146.0",
+  "codexGitRevision": "be449751a978f02e5bbba886999662956c7f38f5",
   "claudeAgentSdk": "0.3.219",
   "claudeCode": "2.1.219",
   "protocolFixture": "codex-0.144.4",

package/dist/claude/service.d.ts

@@ -66,6 +66,7 @@ export interface ClaudeHandoffSource {
     readonly thread: Thread;
     readonly turns: Turn[];
     readonly settings: ThreadSettings;
+    readonly runtimeWorkspaceRoots: readonly string[];
 }
 export interface ClaudeThreadAdminEffects {
     rename(sessionId: string, name: string, cwd: string): Promise<void>;

package/dist/claude/service.js

@@ -1,8 +1,8 @@
-import { join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { statSync } from "node:fs";
 import { deleteSession, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
-import { settingsGeneration } from "../store/HybridStore.js";
+import { runtimeWorkspaceRoots as storedWorkspaceRoots, settingsGeneration } from "../store/HybridStore.js";
 import { SqliteHybridStore } from "../store/sqliteStore.js";
 import { LayeredHybridStore } from "../store/memoryStore.js";
 import { createClaudeQuery } from "./queryFactory.js";
@@ -51,28 +51,77 @@ function existingThreadCwd(value) {
 function turnReasoningEffort(params) {
     return params.collaborationMode?.settings.reasoning_effort ?? params.effort ?? undefined;
 }
-function sandboxPolicy(mode, cwd) {
+function workspaceRoots(value) {
+    const roots = [];
+    const seen = new Set();
+    for (const root of value) {
+        if (!isAbsolute(root))
+            throw invalidParams(`Claude runtime workspace root '${root}' must be absolute.`);
+        if (!seen.has(root)) {
+            seen.add(root);
+            roots.push(root);
+        }
+    }
+    return roots;
+}
+function workspaceSelection(params, previous) {
+    const environments = params.environments;
+    if (environments?.some((environment) => environment.environmentId !== "local")) {
+        throw invalidParams("Claude threads only support the local Codex environment.");
+    }
+    if (environments && environments.length > 1) {
+        throw invalidParams("Claude threads support at most one local Codex environment.");
+    }
+    const environment = environments?.[0];
+    const requestedCwd = environment?.cwd ?? params.cwd ?? previous?.cwd ?? process.cwd();
+    const cwd = existingThreadCwd(requestedCwd);
+    const explicitRoots = environment
+        ? environment.runtimeWorkspaceRoots
+        : params.runtimeWorkspaceRoots;
+    if (explicitRoots !== undefined && explicitRoots !== null) {
+        return { cwd, runtimeWorkspaceRoots: workspaceRoots(explicitRoots) };
+    }
+    if (!previous)
+        return { cwd, runtimeWorkspaceRoots: [cwd] };
+    if (cwd === previous.cwd)
+        return { cwd, runtimeWorkspaceRoots: [...previous.runtimeWorkspaceRoots] };
+    return {
+        cwd,
+        runtimeWorkspaceRoots: workspaceRoots(previous.runtimeWorkspaceRoots.map((root) => root === previous.cwd ? cwd : root)),
+    };
+}
+function writableRoots(cwd, runtimeWorkspaceRoots) {
+    return workspaceRoots([cwd, ...runtimeWorkspaceRoots]);
+}
+function sandboxPolicy(mode, cwd, runtimeWorkspaceRoots = [cwd]) {
     if (mode === "read-only")
         return { type: "readOnly", networkAccess: false };
     if (mode === "danger-full-access")
         return { type: "dangerFullAccess" };
     return {
         type: "workspaceWrite",
-        writableRoots: [cwd],
+        writableRoots: writableRoots(cwd, runtimeWorkspaceRoots),
         networkAccess: false,
         excludeTmpdirEnvVar: false,
         excludeSlashTmp: false,
     };
 }
-function permissionProfileSandboxPolicy(profile, cwd) {
+function permissionProfileSandboxPolicy(profile, cwd, runtimeWorkspaceRoots = [cwd]) {
     if (profile === ":read-only")
-        return sandboxPolicy("read-only", cwd);
+        return sandboxPolicy("read-only", cwd, runtimeWorkspaceRoots);
     if (profile === ":workspace")
-        return sandboxPolicy("workspace-write", cwd);
+        return sandboxPolicy("workspace-write", cwd, runtimeWorkspaceRoots);
     if (profile === ":danger-full-access")
-        return sandboxPolicy("danger-full-access", cwd);
+        return sandboxPolicy("danger-full-access", cwd, runtimeWorkspaceRoots);
     throw invalidParams(`Claude threads do not support Codex permission profile '${profile}'.`);
 }
+function inheritedSandboxPolicy(policy, cwd, runtimeWorkspaceRoots) {
+    if (policy && typeof policy === "object" && "type" in policy
+        && policy.type === "workspaceWrite") {
+        return { ...policy, writableRoots: writableRoots(cwd, runtimeWorkspaceRoots) };
+    }
+    return policy;
+}
 function approvalsReviewer(value, fallback = "user") {
     return value ?? fallback;
 }
@@ -82,10 +131,11 @@ function threadResponse(record, includeTurns) {
         ...settings,
         thread: {
             ...record.thread,
+            isPinned: record.thread.isPinned ?? false,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             turns: includeTurns ? record.thread.turns : [],
         },
-        runtimeWorkspaceRoots: [record.thread.cwd],
+        runtimeWorkspaceRoots: [...storedWorkspaceRoots(record)],
         instructionSources: [],
         sandbox,
         reasoningEffort,
@@ -333,6 +383,7 @@ export class ClaudeService {
             thread: { ...this.withNativeMetadata(snapshot.record), turns },
             turns,
             settings: threadSettings(snapshot.record),
+            runtimeWorkspaceRoots: storedWorkspaceRoots(snapshot.record),
         };
     }
     currentThreadSettings(threadId) {
@@ -443,6 +494,15 @@ export class ClaudeService {
                     : null,
             };
         }
+        if (resume.cwd !== undefined || resume.runtimeWorkspaceRoots !== undefined) {
+            await this.applySettings({
+                threadId,
+                ...(resume.cwd !== undefined ? { cwd: resume.cwd } : {}),
+                ...(resume.runtimeWorkspaceRoots !== undefined
+                    ? { runtimeWorkspaceRoots: resume.runtimeWorkspaceRoots }
+                    : {}),
+            });
+        }
         await (await this.sessions.getOrCreate(threadId)).materializeRuntime();
         record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
         record = this.withCatalogModel(record);
@@ -848,7 +908,7 @@ export class ClaudeService {
         this.requireIndependentThread(params.threadId, "update metadata for");
         return this.sessions.submit(params.threadId, {
             type: "threadAdmin",
-            command: { kind: "metadata", gitInfo: params.gitInfo },
+            command: { kind: "metadata", gitInfo: params.gitInfo, isPinned: params.isPinned },
         });
     }
     async archiveThread(threadId) {
@@ -1093,10 +1153,13 @@ export class ClaudeService {
             throw error;
         }
         const createdAt = nowSeconds();
-        const cwd = existingThreadCwd(params.cwd ?? sourceRecord.thread.cwd);
+        const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
+            cwd: sourceRecord.thread.cwd,
+            runtimeWorkspaceRoots: storedWorkspaceRoots(sourceRecord),
+        });
         const threadId = uuidv7();
         const thread = {
-            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false,
+            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false, isPinned: false,
             sessionId: threadId, forkedFromId: visibleForkedFromId,
             cwd, modelProvider: "claude", createdAt, updatedAt: createdAt, recencyAt: createdAt,
             status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
@@ -1108,12 +1171,15 @@ export class ClaudeService {
         };
         const copiedTurns = sourceTurns.map((turn) => forkProjection(turn, thread.id));
         const record = {
-            ...sourceRecord, thread, claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier,
+            ...sourceRecord, thread, runtimeWorkspaceRoots,
+            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier,
             approvalPolicy: params.approvalPolicy ?? sourceRecord.approvalPolicy,
             approvalsReviewer: approvalsReviewer(params.approvalsReviewer, sourceRecord.approvalsReviewer),
             sandboxPolicy: params.permissions
-                ? permissionProfileSandboxPolicy(params.permissions, cwd)
-                : params.sandbox ? sandboxPolicy(params.sandbox, cwd) : sourceRecord.sandboxPolicy,
+                ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
+                : params.sandbox
+                    ? sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots)
+                    : inheritedSandboxPolicy(sourceRecord.sandboxPolicy, cwd, runtimeWorkspaceRoots),
             baseInstructions: params.baseInstructions === undefined ? sourceRecord.baseInstructions : params.baseInstructions,
             developerInstructions: params.developerInstructions === undefined
                 ? sourceRecord.developerInstructions : params.developerInstructions,
@@ -1510,6 +1576,7 @@ export class ClaudeService {
         if (!native)
             return {
                 ...record.thread,
+                isPinned: record.thread.isPinned ?? false,
                 canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             };
         const createdAt = native.createdAt === undefined
@@ -1518,8 +1585,9 @@ export class ClaudeService {
         const updatedAt = Math.floor(native.lastModified / 1_000);
         return {
             ...record.thread,
+            isPinned: record.thread.isPinned ?? false,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
-            name: (native.customTitle ?? native.summary) || record.thread.name,
+            name: record.thread.name || native.customTitle || native.summary,
             preview: native.firstPrompt ?? record.thread.preview,
             cwd: native.cwd ?? record.thread.cwd,
             createdAt,
@@ -1587,7 +1655,8 @@ export class ClaudeService {
         const reasoningEffort = settings?.effort ?? null;
         const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
         const createdAt = nowSeconds();
-        const cwd = existingThreadCwd(params.cwd ?? process.cwd());
+        const workspace = workspaceSelection(params);
+        const { cwd, runtimeWorkspaceRoots } = workspace;
         return {
             thread: {
                 id: uuidv7(),
@@ -1597,6 +1666,7 @@ export class ClaudeService {
                 parentThreadId: null,
                 preview: "",
                 ephemeral: params.ephemeral ?? false,
+                isPinned: false,
                 historyMode: params.historyMode ?? "legacy",
                 modelProvider: "claude",
                 createdAt,
@@ -1615,6 +1685,7 @@ export class ClaudeService {
                 name: null,
                 turns: [],
             },
+            runtimeWorkspaceRoots,
             claudeSessionId: uuidv7(),
             modelPickerId,
             claudeModelValue,
@@ -1622,8 +1693,8 @@ export class ClaudeService {
             approvalPolicy: params.approvalPolicy ?? "on-request",
             approvalsReviewer: approvalsReviewer(params.approvalsReviewer),
             sandboxPolicy: params.permissions
-                ? permissionProfileSandboxPolicy(params.permissions, cwd)
-                : sandboxPolicy(params.sandbox, cwd),
+                ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
+                : sandboxPolicy(params.sandbox, cwd, runtimeWorkspaceRoots),
             baseInstructions: params.baseInstructions ?? null,
             developerInstructions: params.developerInstructions ?? null,
             personality: settings?.personality ?? params.personality ?? null,
@@ -1678,7 +1749,13 @@ export class ClaudeService {
             const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
             if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
                 throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
-            const cwd = existingThreadCwd(params.cwd ?? before.thread.cwd);
+            const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
+                cwd: before.thread.cwd,
+                runtimeWorkspaceRoots: storedWorkspaceRoots(before),
+            });
+            const workspaceChanged = cwd !== before.thread.cwd
+                || runtimeWorkspaceRoots.length !== storedWorkspaceRoots(before).length
+                || runtimeWorkspaceRoots.some((root, index) => root !== storedWorkspaceRoots(before)[index]);
             const reasoningEffort = params.effort === undefined ? before.reasoningEffort : params.effort;
             const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
             syncCanonicalSettings = requestedServiceTier === "fast" && serviceTier !== "fast";
@@ -1688,14 +1765,17 @@ export class ClaudeService {
             const candidate = {
                 ...before,
                 thread: { ...before.thread, cwd },
+                runtimeWorkspaceRoots,
                 modelPickerId,
                 claudeModelValue,
                 serviceTier,
                 approvalPolicy: params.approvalPolicy ?? before.approvalPolicy,
                 approvalsReviewer: approvalsReviewer(params.approvalsReviewer, before.approvalsReviewer),
                 sandboxPolicy: params.permissions
-                    ? permissionProfileSandboxPolicy(params.permissions, cwd)
-                    : params.sandboxPolicy ?? before.sandboxPolicy,
+                    ? permissionProfileSandboxPolicy(params.permissions, cwd, runtimeWorkspaceRoots)
+                    : params.sandboxPolicy ?? (workspaceChanged
+                        ? inheritedSandboxPolicy(before.sandboxPolicy, cwd, runtimeWorkspaceRoots)
+                        : before.sandboxPolicy),
                 reasoningEffort,
                 reasoningSummary: params.summary === undefined ? before.reasoningSummary : params.summary,
                 collaborationMode: collaborationMode === null ? null : syncedCollaborationMode(collaborationMode, modelPickerId, reasoningEffort),