@pasko70/pibo 2.1.1 → 2.2.0

package/dist/agent-runtime/profile-validation.js

@@ -55,17 +55,23 @@ export function validateAgentRuntimeProfileCapabilities(profile, capabilities) {
     if (enabledSkills.length > 0) {
         pushUnsupportedDeliveryDiagnostic(diagnostics, capabilities.skills, "runtime_skills_unsupported", "skills", `Profile "${profile.profileName}" selects skills`);
     }
-    if (enabledContextFiles.length > 0 || profile.autoContextFiles) {
+    if (enabledContextFiles.length > 0) {
         pushUnsupportedDeliveryDiagnostic(diagnostics, capabilities.context, "runtime_context_unsupported", "contextFiles", `Profile "${profile.profileName}" selects managed or automatic context`);
     }
-    if (profile.autoContextFiles
-        && capabilities.context.support === "materialized"
-        && !capabilities.context.modes.includes("native-project-discovery")) {
+    if (profile.nativeSubagents !== undefined && typeof profile.nativeSubagents !== "boolean") {
         diagnostics.push({
             severity: "error",
-            code: "runtime_auto_context_discovery_unsupported",
-            message: `Runtime "${profile.runtimeInstanceId}" materializes explicit context but does not support automatic AGENTS.md / CLAUDE.md discovery. Disable automatic context or choose a runtime that declares native-project-discovery.`,
-            path: "autoContextFiles",
+            code: "runtime_native_subagents_invalid",
+            message: `Profile "${profile.profileName}" must set nativeSubagents to a boolean when provided.`,
+            path: "nativeSubagents",
+        });
+    }
+    else if (profile.nativeSubagents !== undefined && !capabilities.nativeSubagents.configurable) {
+        diagnostics.push({
+            severity: "error",
+            code: "runtime_native_subagents_not_configurable",
+            message: `Runtime "${profile.runtimeInstanceId}" does not allow profiles to override native subagents.`,
+            path: "nativeSubagents",
         });
     }
     const reasoningValues = [

package/dist/agent-runtime/resource-files.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { chmod, copyFile, lstat, mkdir, readdir, realpath, } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+import { protectPrivatePathsSync } from "../core/private-path.js";
 function safeSegment(value) {
     const normalized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 96) || "resource";
     const hash = createHash("sha256").update(value).digest("hex").slice(0, 10);
@@ -10,9 +11,10 @@ function isInside(root, candidate) {
     const child = relative(root, candidate);
     return child === "" || (!child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child));
 }
-async function ensurePrivateDirectory(path) {
-    await mkdir(path, { recursive: true, mode: 0o700 });
-    await chmod(path, 0o700);
+async function ensurePrivateDirectories(paths) {
+    for (const path of paths)
+        await mkdir(path, { recursive: true, mode: 0o700 });
+    protectPrivatePathsSync(paths.map((path) => ({ path, kind: "directory" })));
 }
 export async function createAgentRuntimeResourcePaths(rootDir, input) {
     const root = join(rootDir, safeSegment(input.runtimeInstanceId), safeSegment(input.piboSessionId), safeSegment(input.sessionGeneration));
@@ -24,8 +26,7 @@ export async function createAgentRuntimeResourcePaths(rootDir, input) {
         config: join(root, "config"),
         protocol: join(root, "protocol"),
     };
-    for (const path of Object.values(paths))
-        await ensurePrivateDirectory(path);
+    await ensurePrivateDirectories(Object.values(paths));
     return paths;
 }
 async function copySkillEntry(source, destination, sourceRoot, budget) {
@@ -44,6 +45,10 @@ async function copySkillEntry(source, destination, sourceRoot, budget) {
         budget.activeDirectories.add(canonical);
         try {
             await mkdir(destination, { recursive: true, mode: metadata.mode & 0o777 });
+            if (process.platform === "win32")
+                budget.privateWindowsPaths.push({ path: destination, kind: "directory" });
+            else
+                await chmod(destination, 0o700);
             for (const entry of await readdir(source)) {
                 await copySkillEntry(join(source, entry), join(destination, entry), sourceRoot, budget);
             }
@@ -63,7 +68,13 @@ async function copySkillEntry(source, destination, sourceRoot, budget) {
         throw new Error(`Skill exceeds the ${budget.maxBytes}-byte materialization limit.`);
     await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
     await copyFile(source, destination);
-    await chmod(destination, metadata.mode & 0o777);
+    if (process.platform === "win32") {
+        budget.privateWindowsPaths.push({ path: dirname(destination), kind: "directory" }, { path: destination, kind: "file" });
+    }
+    else {
+        await chmod(dirname(destination), 0o700);
+        await chmod(destination, metadata.mode & 0o777);
+    }
 }
 export async function copyAgentRuntimeSkillDirectory(skill, destinationRoot, limits) {
     const sourceFile = await realpath(skill.sourcePath);
@@ -75,13 +86,18 @@ export async function copyAgentRuntimeSkillDirectory(skill, destinationRoot, lim
         maxFiles: limits.maxFiles,
         maxBytes: limits.maxBytes,
         activeDirectories: new Set(),
+        privateWindowsPaths: [],
     };
+    let target;
     if (basename(sourceFile).toUpperCase() === "SKILL.MD") {
         await copySkillEntry(sourceRoot, destination, sourceRoot, budget);
-        return join(destination, relative(sourceRoot, sourceFile));
+        target = join(destination, relative(sourceRoot, sourceFile));
+    }
+    else {
+        target = join(destination, "SKILL.md");
+        await copySkillEntry(sourceFile, target, sourceRoot, budget);
     }
-    await ensurePrivateDirectory(destination);
-    const target = join(destination, "SKILL.md");
-    await copySkillEntry(sourceFile, target, sourceRoot, budget);
+    if (process.platform === "win32")
+        protectPrivatePathsSync(budget.privateWindowsPaths);
     return target;
 }

package/dist/agent-runtime/resource-service.js

@@ -1,7 +1,9 @@
-import { chmod, readFile, rm, stat, writeFile, } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { readFile, readlink, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { PIBO_APP_CONTEXT } from "../app-context.js";
 import { piboHomePath } from "../core/pibo-home.js";
+import { protectPrivatePathsSync } from "../core/private-path.js";
 import { DEFAULT_USER_TIMEZONE } from "../core/user-settings.js";
 import { isHttpServer, loadConfigUnresolved, } from "../mcp/config.js";
 import { redactMcpRuntimeError as redactResourceError, scopePiboMcpServerConfig, verifyPiboMcpServer, } from "../mcp/runtime-session.js";
@@ -39,6 +41,170 @@ function slug(value) {
 function resolveProfilePath(cwd, path) {
     return isAbsolute(path) ? path : resolve(cwd, path);
 }
+function comparablePath(path) {
+    const normalized = resolve(path);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function comparableFileName(path) {
+    const name = basename(path);
+    return process.platform === "win32" ? name.toLowerCase() : name;
+}
+function samePath(left, right) {
+    return comparablePath(left) === comparablePath(right);
+}
+function isWithin(parent, child) {
+    const selected = relative(comparablePath(parent), comparablePath(child));
+    return selected === "" || (!selected.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)
+        && selected !== ".."
+        && !isAbsolute(selected));
+}
+async function linkedAncestorPath(path) {
+    const suffix = [];
+    let current = resolve(path);
+    while (true) {
+        const target = await readlink(current).catch(() => undefined);
+        if (target) {
+            const targetPath = isAbsolute(target) ? target : resolve(dirname(current), target);
+            return resolve(targetPath, ...suffix);
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        suffix.unshift(basename(current));
+        current = parent;
+    }
+}
+async function canonicalPath(path) {
+    const resolved = resolve(path);
+    const canonical = await realpath(resolved).catch(() => undefined);
+    if (canonical)
+        return canonical;
+    const linked = await linkedAncestorPath(resolved);
+    return linked ? await realpath(linked).catch(() => linked) : resolved;
+}
+function ancestorDirectories(cwd, boundary, includeBoundary = true) {
+    const directories = [];
+    let current = cwd;
+    while (true) {
+        const atBoundary = boundary !== undefined && samePath(current, boundary);
+        if (!atBoundary || includeBoundary)
+            directories.push(current);
+        if (atBoundary)
+            break;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return directories;
+}
+async function findNearestGitRoot(cwd) {
+    for (const directory of ancestorDirectories(cwd)) {
+        const marker = join(directory, ".git");
+        const markerStat = await stat(marker).catch(() => undefined);
+        if (markerStat)
+            return directory;
+    }
+    return undefined;
+}
+async function contextFileAncestorDirectories(cwd, strategy) {
+    if (strategy === "codex-project") {
+        const projectRoot = await findNearestGitRoot(cwd);
+        return projectRoot ? ancestorDirectories(cwd, projectRoot) : [cwd];
+    }
+    if (strategy === "omp-project") {
+        const home = resolve(homedir());
+        const projectRoot = await findNearestGitRoot(cwd);
+        const cwdUnderHome = isWithin(home, cwd);
+        const projectUnderHome = projectRoot !== undefined && isWithin(home, projectRoot);
+        if (projectRoot && !(cwdUnderHome && projectUnderHome))
+            return ancestorDirectories(cwd, projectRoot);
+        if (cwdUnderHome)
+            return ancestorDirectories(cwd, home, false);
+        return ancestorDirectories(cwd);
+    }
+    return ancestorDirectories(cwd);
+}
+async function nearestRelativeAncestorDirectories(cwd, strategy) {
+    if (strategy !== "omp-project")
+        return ancestorDirectories(cwd);
+    const projectRoot = await findNearestGitRoot(cwd);
+    return projectRoot ? ancestorDirectories(cwd, projectRoot) : ancestorDirectories(cwd);
+}
+async function everyRelativeAncestorDirectories(cwd, strategy) {
+    if (strategy !== "omp-project")
+        return ancestorDirectories(cwd);
+    const projectRoot = await findNearestGitRoot(cwd);
+    if (projectRoot)
+        return ancestorDirectories(cwd, projectRoot);
+    const home = resolve(homedir());
+    return isWithin(home, cwd) ? ancestorDirectories(cwd, home, false) : ancestorDirectories(cwd);
+}
+async function realFilePath(path) {
+    const candidate = await realpath(path).catch(() => undefined);
+    if (!candidate)
+        return undefined;
+    const metadata = await stat(candidate).catch(() => undefined);
+    return metadata?.isFile() ? candidate : undefined;
+}
+async function firstExistingPath(directories, relativePath) {
+    for (const directory of directories) {
+        const candidate = await realFilePath(join(directory, relativePath));
+        if (candidate)
+            return candidate;
+    }
+    return undefined;
+}
+async function isKnownNativeDiscoveredContextFile(sourcePath, cwdInput, strategy, knownFileNames, knownUserRelativePaths, knownCwdRelativePaths, knownRelativePaths, knownAncestorRelativePaths) {
+    const cwd = await canonicalPath(cwdInput);
+    const sourceRealPath = await canonicalPath(sourcePath);
+    for (const relativePath of knownUserRelativePaths) {
+        const candidate = await realFilePath(join(homedir(), relativePath));
+        if (candidate && samePath(candidate, sourceRealPath))
+            return true;
+    }
+    for (const relativePath of knownCwdRelativePaths) {
+        const candidate = await realFilePath(join(cwd, relativePath));
+        if (candidate && samePath(candidate, sourceRealPath))
+            return true;
+    }
+    const nearestDirectories = await nearestRelativeAncestorDirectories(cwd, strategy);
+    for (const relativePath of knownRelativePaths) {
+        const candidate = await firstExistingPath(nearestDirectories, relativePath);
+        if (candidate && samePath(candidate, sourceRealPath))
+            return true;
+    }
+    const everyDirectories = await everyRelativeAncestorDirectories(cwd, strategy);
+    for (const relativePath of knownAncestorRelativePaths) {
+        for (const directory of everyDirectories) {
+            const candidate = await realFilePath(join(directory, relativePath));
+            if (candidate && samePath(candidate, sourceRealPath))
+                return true;
+        }
+        if (strategy === "omp-project") {
+            const userCandidate = await realFilePath(join(homedir(), relativePath));
+            if (userCandidate && samePath(userCandidate, sourceRealPath))
+                return true;
+        }
+    }
+    const sourceName = comparableFileName(sourceRealPath);
+    if (!knownFileNames.some((name) => comparableFileName(name) === sourceName))
+        return false;
+    const sourceDirectory = dirname(sourceRealPath);
+    for (const directory of await contextFileAncestorDirectories(cwd, strategy)) {
+        if (!samePath(directory, sourceDirectory))
+            continue;
+        if (strategy === "omp-project" && basename(directory).startsWith("."))
+            return false;
+        for (const fileName of knownFileNames) {
+            const candidate = await realFilePath(join(directory, fileName));
+            if (candidate)
+                return samePath(candidate, sourceRealPath);
+        }
+        return false;
+    }
+    return false;
+}
 function deliveryMode(delivery) {
     if (delivery.support === "mcp")
         return `mcp:${delivery.transports.join(",")}`;
@@ -196,6 +362,23 @@ class RuntimeResourceSession {
         this.assertActive();
         return structuredClone(this.resolvedMcpConfigs);
     }
+    recordAdapterDelivery(reports, diagnostics = []) {
+        this.assertActive();
+        const replacements = new Map();
+        for (const report of reports) {
+            if (replacements.has(report.contributionId)) {
+                throw new Error(`Adapter reported runtime resource contribution "${report.contributionId}" more than once.`);
+            }
+            replacements.set(report.contributionId, { ...report });
+        }
+        this.delivery = this.delivery.map((report) => replacements.get(report.contributionId) ?? report);
+        const known = new Set(this.delivery.map((report) => report.contributionId));
+        for (const report of replacements.values()) {
+            if (!known.has(report.contributionId))
+                this.delivery.push(report);
+        }
+        this.diagnostics.push(...diagnostics.map((diagnostic) => ({ ...diagnostic })));
+    }
     getInspection() {
         this.assertActive();
         return {
@@ -309,7 +492,12 @@ class RuntimeResourceSession {
         this.diagnostics.push({ severity: "error", code: "runtime_mcp_configuration_failed", message, contributionId });
     }
     async prepareContext() {
-        if (this.input.profile.autoContextFiles) {
+        const contextCwd = await canonicalPath(this.input.cwd);
+        const automaticContextEnabled = this.input.capabilities.contextDiscovery.supported
+            && (this.input.capabilities.contextDiscovery.configurable
+                ? this.input.profile.autoContextFiles
+                : this.input.capabilities.contextDiscovery.enabledByDefault);
+        if (automaticContextEnabled) {
             this.requiredContributionIds.add("context:automatic-project-files");
             this.context.push({
                 id: "context:automatic-project-files",
@@ -327,9 +515,11 @@ class RuntimeResourceSession {
                 continue;
             const id = `context:${file.key ?? file.path}`;
             this.requiredContributionIds.add(id);
-            const sourcePath = resolveProfilePath(this.input.cwd, file.path);
+            const sourcePath = resolveProfilePath(contextCwd, file.path);
             try {
                 const content = await readFile(sourcePath, "utf8");
+                const nativeDiscovered = automaticContextEnabled
+                    && await isKnownNativeDiscoveredContextFile(sourcePath, contextCwd, this.input.capabilities.contextDiscovery.strategy, this.input.capabilities.contextDiscovery.knownFileNames ?? [], this.input.capabilities.contextDiscovery.knownUserRelativePaths ?? [], this.input.capabilities.contextDiscovery.knownCwdRelativePaths ?? [], this.input.capabilities.contextDiscovery.knownRelativePaths ?? [], this.input.capabilities.contextDiscovery.knownAncestorRelativePaths ?? []);
                 this.context.push({
                     id,
                     kind: "context-file",
@@ -341,6 +531,7 @@ class RuntimeResourceSession {
                     path: sourcePath,
                     sourcePath,
                     content,
+                    ...(nativeDiscovered ? { nativeDiscovered: true } : {}),
                 });
             }
             catch (error) {
@@ -406,8 +597,9 @@ class RuntimeResourceSession {
         }
     }
     async materialize() {
+        const privateFiles = [];
         const materializeSkills = this.input.capabilities.skills.support === "materialized" && this.skills.length > 0;
-        const materializeContext = this.input.capabilities.context.support === "materialized" && this.context.some((item) => item.content !== undefined);
+        const materializeContext = this.input.capabilities.context.support === "materialized" && this.context.some((item) => item.content !== undefined && !item.nativeDiscovered);
         const materializeMcp = this.mcpServers.some((server) => server.scoped !== undefined);
         if (!materializeSkills && !materializeContext && !materializeMcp)
             return;
@@ -431,12 +623,12 @@ class RuntimeResourceSession {
         if (materializeContext) {
             let materializedIndex = 0;
             for (const contribution of this.context) {
-                if (contribution.content === undefined)
+                if (contribution.content === undefined || contribution.nativeDiscovered)
                     continue;
                 const target = join(this.paths.context, `${String(materializedIndex++).padStart(3, "0")}-${slug(contribution.label)}.md`);
                 try {
                     await writeFile(target, contribution.content, { encoding: "utf8", mode: 0o600 });
-                    await chmod(target, 0o600);
+                    privateFiles.push(target);
                     contribution.materializedPath = target;
                 }
                 catch (error) {
@@ -456,12 +648,13 @@ class RuntimeResourceSession {
             }
             const configPath = join(this.paths.config, MCP_CONFIG_FILE);
             await writeFile(configPath, `${JSON.stringify({ mcpServers: materializedConfigs }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-            await chmod(configPath, 0o600);
+            privateFiles.push(configPath);
             this.adapterEnvironment.MCP_CONFIG_PATH = configPath;
             this.adapterEnvironment.MCP_NO_DAEMON = "1";
             this.adapterEnvironment.MCP_STRICT_ENV = "true";
             this.adapterEnvironment.PIBO_MCP_ISOLATED_ENV = "1";
         }
+        protectPrivatePathsSync(privateFiles.map((path) => ({ path, kind: "file" })));
     }
     async verifyMcpServers() {
         const shouldVerify = this.input.verifyMcp !== false;
@@ -504,6 +697,17 @@ class RuntimeResourceSession {
         }
         for (const contribution of this.context) {
             const failure = this.diagnosticFor(contribution.id);
+            if (contribution.nativeDiscovered) {
+                this.delivery.push({
+                    contributionId: contribution.id,
+                    status: failure ? "failed" : "delivered",
+                    mode: "native-project-discovery",
+                    fidelity: failure ? "none" : "exact",
+                    target: contribution.sourcePath ?? contribution.path,
+                    ...(failure ? { diagnostic: failure } : {}),
+                });
+                continue;
+            }
             if (contribution.id === ENABLED_MCP_CONTEXT_ID
                 && this.input.capabilities.mcp.externalServers.support === "mcp") {
                 this.delivery.push({
@@ -516,8 +720,8 @@ class RuntimeResourceSession {
                 });
                 continue;
             }
-            if (contribution.kind === "automatic" && this.input.capabilities.context.support === "materialized") {
-                const supportsNativeDiscovery = this.input.capabilities.context.modes.includes("native-project-discovery");
+            if (contribution.kind === "automatic") {
+                const supportsNativeDiscovery = this.input.capabilities.contextDiscovery.supported;
                 this.delivery.push(supportsNativeDiscovery
                     ? {
                         contributionId: contribution.id,
@@ -531,7 +735,7 @@ class RuntimeResourceSession {
                         status: "unsupported",
                         mode: "unsupported:auto-context-discovery",
                         fidelity: "none",
-                        diagnostic: "This runtime materializes explicit context but does not declare native-project-discovery for automatic AGENTS.md / CLAUDE.md context.",
+                        diagnostic: "This runtime does not declare automatic native project-context discovery.",
                     });
                 continue;
             }
@@ -542,8 +746,7 @@ class RuntimeResourceSession {
                     ? contribution.materializedPath
                     : contribution.path ?? contribution.sourcePath ?? this.input.cwd,
                 failure,
-                fidelity: contribution.kind === "automatic" ? "equivalent" : "exact",
-                modeOverride: contribution.kind === "automatic" ? "native-discovery" : undefined,
+                fidelity: "exact",
             }));
         }
         for (const server of this.mcpServers) {

package/dist/agent-runtimes/codex-native/adapter.js

@@ -12,6 +12,7 @@ import { CodexNativeRequestController } from "./requests.js";
 import { CodexNativeResourceDelivery } from "./resource-delivery.js";
 import { CODEX_NATIVE_MODEL_OPTIONS_SCHEMA, CODEX_NATIVE_MODEL_PROVIDER_ID, CODEX_NATIVE_REASONING_VALUES, CodexNativeSessionSettingsController, parseCodexNativeProfileOptions, readCodexNativeModelCatalog, readCodexNativePersistedSettings, toAgentRuntimeModelCatalog, } from "./models.js";
 import { CodexNativeAuthController } from "./auth.js";
+import { injectPortableHistoryIntoCodex } from "./portable-history.js";
 export { CODEX_NATIVE_ADAPTER_ID } from "./thread.js";
 export const CODEX_NATIVE_ADAPTER_VERSION = "1.0.0";
 function codexNativeCapabilities(structuredUserInput) {
@@ -57,6 +58,19 @@ function codexNativeCapabilities(structuredUserInput) {
         },
         skills: { support: "materialized", modes: ["codex-extra-roots"] },
         context: { support: "materialized", modes: ["native-project-discovery", "codex-developer-instructions"] },
+        contextDiscovery: {
+            supported: true,
+            configurable: false,
+            enabledByDefault: true,
+            strategy: "codex-project",
+            knownFileNames: ["AGENTS.override.md", "AGENTS.md"],
+        },
+        nativeSubagents: {
+            supported: true,
+            configurable: true,
+            enabledByDefault: true,
+        },
+        historyImport: true,
         auth: {
             status: true,
             methods: [
@@ -81,7 +95,7 @@ function codexNativeCapabilities(structuredUserInput) {
             structuredUserInput,
         },
         maintenance: {
-            compaction: false,
+            compaction: true,
             contextUsage: true,
             history: true,
             health: true,
@@ -228,6 +242,22 @@ export class CodexNativeThreadSession {
                 this.assertIdle();
                 return this.settings.setModel(model);
             },
+            compact: async (customInstructions) => await this.runIdleOperation(async () => {
+                const customInstructionsRequested = Boolean(customInstructions?.trim());
+                if (customInstructionsRequested) {
+                    this.emit({
+                        type: "warning",
+                        message: "Native Codex compaction owns its summary and cannot apply custom Pibo compaction instructions; the native compaction is continuing without them.",
+                    });
+                }
+                await this.turns.compact();
+                this.updateBindingFromCurrentThread();
+                return {
+                    native: true,
+                    method: "thread/compact/start",
+                    customInstructionsApplied: !customInstructionsRequested,
+                };
+            }),
             respondToApproval: (requestId, decision) => this.requests.respondToApproval(requestId, decision),
             respondToUserInput: (requestId, answers) => this.requests.respondToUserInput(requestId, answers),
         };
@@ -696,6 +726,7 @@ export class CodexNativeAgentRuntimeAdapter {
             workspace: input.workspace,
             portableTools: input.services?.portableTools,
             resources: input.services?.resources,
+            nativeSubagentsEnabled: input.profile.nativeSubagents,
         };
         const startProcessBundle = async (processGeneration) => {
             let delivery;
@@ -774,6 +805,12 @@ export class CodexNativeAgentRuntimeAdapter {
                     throw error;
                 throw new Error("Codex could not initialize every selected MCP server.");
             }
+            if (input.historyHandoff?.mode === "import") {
+                if (binding.state === "bound") {
+                    throw new Error("Native Codex portable history import requires a new thread.");
+                }
+                await injectPortableHistoryIntoCodex(process.client, threads.thread.id, input.historyHandoff.history);
+            }
             settings.attachThread(threads.thread.id, threads.configuration);
             await resourceDelivery.verifyThread(process.client, threads.thread.id);
             return new CodexNativeThreadSession(this.instanceId, process, threads, settings, resourceDelivery, bindingForThread({

package/dist/agent-runtimes/codex-native/auth.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { AgentRuntimeAuthError } from "../../agent-runtime/errors.js";
+import { protectPrivateTreeSync } from "../../core/private-path.js";
 export const CODEX_NATIVE_AUTH_PROVIDER_ID = "openai-codex";
 export const CODEX_NATIVE_AUTH_PROVIDER_DISPLAY_NAME = "OpenAI for native Codex";
 const CODEX_DEVICE_METHOD = { id: "device_code", completion: "notification" };
@@ -298,7 +299,7 @@ export class CodexNativeAuthController {
             if (flow.timer)
                 clearTimeout(flow.timer);
             flow.unsubscribe?.();
-            await flow.process?.close();
+            await this.closeProcess(flow.process);
             flow.process = undefined;
         }));
     }
@@ -378,7 +379,7 @@ export class CodexNativeAuthController {
         }
         catch (error) {
             unsubscribe?.();
-            await process?.close().catch(() => { });
+            await this.closeProcess(process).catch(() => { });
             if (error instanceof AgentRuntimeAuthError)
                 throw error;
             throw operationFailure("device login start");
@@ -428,7 +429,17 @@ export class CodexNativeAuthController {
                 flow.timer = undefined;
                 flow.unsubscribe?.();
                 flow.unsubscribe = undefined;
-                await flow.process?.close().catch(() => { });
+                try {
+                    await this.closeProcess(flow.process);
+                }
+                catch {
+                    flow.terminal = {
+                        providerId: flow.providerId,
+                        state: "failed",
+                        configured: false,
+                        message: "Native Codex login state could not be secured. Start a new login.",
+                    };
+                }
                 flow.process = undefined;
             })();
         }
@@ -456,8 +467,18 @@ export class CodexNativeAuthController {
             return await operation(process);
         }
         finally {
+            await this.closeProcess(process);
+        }
+    }
+    async closeProcess(process) {
+        if (!process)
+            return;
+        try {
             await process.close();
         }
+        finally {
+            protectPrivateTreeSync(process.paths.codexHome);
+        }
     }
     latestFlow() {
         return [...this.flows.values()].at(-1);

package/dist/agent-runtimes/codex-native/portable-history.js

@@ -0,0 +1,73 @@
+function jsonString(value) {
+    try {
+        return JSON.stringify(value ?? null);
+    }
+    catch {
+        return JSON.stringify({ portableFallback: "History value was not JSON serializable." });
+    }
+}
+function textFromEntry(entry) {
+    if (entry.type === "session_info")
+        return entry.name;
+    if (typeof entry.content === "string")
+        return entry.content;
+    return entry.content.flatMap((part) => {
+        if (part.type === "text" || part.type === "reasoning")
+            return [part.text];
+        return [];
+    }).join("\n");
+}
+function responseItems(entry) {
+    if (entry.type === "session_info") {
+        return [{
+                type: "message",
+                role: "developer",
+                content: [{ type: "input_text", text: `[Pibo portable session information]\n${entry.name}` }],
+            }];
+    }
+    if (entry.role === "tool") {
+        return [{
+                type: "function_call_output",
+                call_id: entry.toolCallId ?? entry.id,
+                output: typeof entry.content === "string" ? entry.content : jsonString(entry.result),
+            }];
+    }
+    if (entry.role === "assistant") {
+        const items = [];
+        const text = textFromEntry(entry);
+        if (text) {
+            items.push({
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text }],
+            });
+        }
+        if (Array.isArray(entry.content)) {
+            for (const part of entry.content) {
+                if (part.type !== "tool_call")
+                    continue;
+                items.push({
+                    type: "function_call",
+                    name: part.toolName,
+                    arguments: jsonString(part.input),
+                    call_id: part.toolCallId,
+                });
+            }
+        }
+        return items;
+    }
+    const text = textFromEntry(entry);
+    if (!text)
+        return [];
+    return [{
+            type: "message",
+            role: entry.role === "system" ? "developer" : "user",
+            content: [{ type: "input_text", text }],
+        }];
+}
+export async function injectPortableHistoryIntoCodex(client, threadId, history) {
+    const items = history.entries.flatMap(responseItems);
+    if (items.length === 0)
+        return;
+    await client.request("thread/inject_items", { threadId, items });
+}