@unblocklabs/unblock-codex-prompt 0.2.0 → 0.2.1

package/README.md

@@ -1,7 +1,7 @@
 # Unblock Codex Prompt
 
 A small, explicit prompt-management bridge for dedicated OpenClaw Mac agents.
-**Version 0.2.0.** The frozen bridge supports OpenClaw/Codex 2026.9.2 and newer
+**Version 0.2.1.** The frozen bridge supports OpenClaw/Codex 2026.9.2 and newer
 stable releases with a compatible context-assembly layout.
 
 ## What you control
@@ -29,7 +29,8 @@ files use private permissions. Missing identity documents are recorded as absent
 ## Compatibility
 
 - Frozen bridge: **OpenClaw and @openclaw/codex >=2026.9.2**. Reviewed layouts cover
-  2026.9.2 and 2026.9.4, including the newer parent-local context path. Bundle names
+  2026.9.2, 2026.9.3, 2026.9.4 and 2026.9.8, including parent-local context and split
+  `dist/.setup/` bundles. Bundle names
   may change; fingerprints of the context-assembly functions must still match.
   Changed assembly is refused pending review, rather than patched blindly.
 - Managed local stdio Codex, agent-scoped home, no custom command/arguments.
@@ -37,8 +38,11 @@ files use private permissions. Missing identity documents are recorded as absent
   children may inherit the parent's frozen context.
 
 This bridge uses two private upstream seams because public prompt hooks cannot
-fix the dropped-context path: one skill-catalog builder and two entry points in
-one Codex adapter bundle (plus the parent-local context entry point on newer builds).
+fix the dropped-context path: one skill-catalog builder and guarded Codex context
+carriers. Newer builds also require parent-local suppression and removal of the
+separate thread-level skills append. The installer backs up and tracks every
+patched bundle; old single-file receipts remain restorable. Runtime module paths
+come from the loader's selected entry, never its temporary execution capture.
 It validates private seams and is not a promise of compatibility with unseen layouts.
 The catalog uses OpenClaw's eligibility, allowlist, visibility and size-limit
 logic. Session-specific and execution-directory skills are not snapshotted.
@@ -50,7 +54,7 @@ Remote-node-only skills are not added; this is for dedicated local Mac agents.
 npm ci
 npm run preflight
 npm pack
-openclaw plugins install ./unblocklabs-unblock-codex-prompt-0.2.0.tgz --force --accept-capabilities
+openclaw plugins install ./unblocklabs-unblock-codex-prompt-0.2.1.tgz --force --accept-capabilities
 ```
 
 Include the plugin in `plugins.allow` if applicable, then configure:
@@ -236,7 +240,7 @@ without restoring leaves the frozen base but re-enables live injections.
 
 ```sh
 npm run preflight
-npm run release:check -- v0.2.0
+npm run release:check -- v0.2.1
 ```
 
 Tests cover compilation, explicit refresh, native/private-body exclusion,
@@ -246,7 +250,7 @@ proof and limits.
 
 Install with
 the packed archive above for an unreleased candidate. After publication, use
-`openclaw plugins install npm:@unblocklabs/unblock-codex-prompt@0.2.0 --accept-capabilities`.
+`openclaw plugins install npm:@unblocklabs/unblock-codex-prompt@0.2.1 --accept-capabilities`.
 The existing [GitHub Release workflow](RELEASING.md) publishes npm only when a
 GitHub Release is published. Normal pushes do not release the package.
 

package/dist/adapter.d.ts

@@ -1,24 +1,37 @@
-type Receipt = {
-    schema: 1;
-    packageDir: string;
+type AdapterFile = {
     path: string;
     originalSha256: string;
     patchedSha256: string;
+    previousPatchedSha256?: string;
+};
+type Receipt = ({
+    schema: 1;
+    packageDir: string;
+} & AdapterFile) | {
+    schema: 2;
+    packageDir: string;
+    files: AdapterFile[];
 };
 export declare function readReceipt(agentDir: string): Promise<Receipt | null>;
-export declare function patchAdapterSource(source: string, agentDir: string, agentId: string, runtimePath: string): string;
-export declare function prepareAdapter(agentDir: string, agentId: string, suppliedDir?: string): Promise<{
-    path: string;
-    current: string;
-    original: string;
-    patched: string;
+export declare function patchAdapterSources(sources: string[], agentDir: string, agentId: string, runtimePath: string): string[];
+export declare function prepareAdapter(agentDir: string, agentId: string, suppliedDir: string | undefined, runtimePath: string): Promise<{
+    files: {
+        patched: string;
+        path: string;
+        current: string;
+        original: string;
+    }[];
     receipt: {
-        schema: 1;
+        schema: 2;
         packageDir: string;
-        path: string;
-        originalSha256: string;
-        patchedSha256: string;
+        files: {
+            previousPatchedSha256?: string;
+            path: string;
+            originalSha256: string;
+            patchedSha256: string;
+        }[];
     };
+    previousReceipt: string | null;
 }>;
 export declare function installAdapter(agentDir: string, plan: Awaited<ReturnType<typeof prepareAdapter>>): Promise<{
     adapterChanged: boolean;
@@ -27,10 +40,12 @@ export declare function installAdapter(agentDir: string, plan: Awaited<ReturnTyp
 export declare function adapterStatus(agentDir: string): Promise<{
     installed: boolean;
     path?: never;
+    paths?: never;
     minimumVersion?: never;
 } | {
     installed: boolean;
     path: string;
+    paths: string[];
     minimumVersion: string;
 }>;
 export declare function restoreAdapter(agentDir: string): Promise<void>;

package/dist/adapter.js

@@ -1,62 +1,93 @@
-import { readFile, readdir } from "node:fs/promises";
+import { lstat, readFile, readdir } from "node:fs/promises";
 import { basename, isAbsolute, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { parse } from "acorn";
 import { readOptional, replaceFile, sha256 } from "./manager.js";
 import { openclawRoot } from "./compiler.js";
 import { assertSupportedVersion, MINIMUM_OPENCLAW } from "./compatibility.js";
 const MARKER = "// unblock-codex-prompt bridge v1";
-const BUNDLE_NAME = /^thread-lifecycle-[\w-]+\.m?js$/u;
+const BUNDLE_NAME = /^thread-(lifecycle|requests)-[\w-]+\.m?js$/u;
 const HASH = /^[a-f0-9]{64}$/u;
-// Fingerprint only the context-assembly seams, not release-specific bundle names
-// or unrelated code. New releases can use either reviewed layout unchanged.
+// Reviewed context carriers, independent of release-specific bundle names.
 const CONTEXT_HASHES = {
     legacy: "1fb45c46c50a63f68e8b6bdfbc5d7ae2d323470c00db69779d159592868940bb",
     parent: "5ee80edf3f3887e841def5d64896a3d27c35063f6d4803dceeb8b8bf07b654f0",
+    splitParent: "6515e383260e0edd4379a2e694d9b066ddb02a79b55fd7494bf7f85affee72c6",
     collaboration: "aea7e95ca43f0997b0a3f616f327132bfdd057bb731e6eead132fba21de3f981",
+    legacyThread: "703a32a0b18eacd45a9fd3d68c04a13527bdbeaae50a11a6b76768b84b99a9ed",
+    thread: "3aa4c414cb449cdb9167e6ed2df9397559176310ce7cff882652bd669ac8cee8",
 };
 function receiptPath(agentDir) { return join(agentDir, "codex-home", ".unblock-codex-prompt-adapter.json"); }
-function backupPath(agentDir) { return join(agentDir, "codex-home", ".unblock-codex-prompt-adapter-original.js"); }
-export async function readReceipt(agentDir) {
-    const source = await readOptional(receiptPath(agentDir));
+function receiptFiles(receipt) { return receipt.schema === 1 ? [receipt] : receipt.files; }
+function backupPath(agentDir, file, legacy = false) {
+    return join(agentDir, "codex-home", legacy ? ".unblock-codex-prompt-adapter-original.js" : ".unblock-codex-prompt-adapter-original-" + basename(file.path));
+}
+function ownsSource(file, source) {
+    if (source === null)
+        return false;
+    const hash = sha256(source);
+    return hash === file.originalSha256 || hash === file.patchedSha256 || hash === file.previousPatchedSha256;
+}
+function parseReceipt(source) {
     if (source === null)
         return null;
     const value = JSON.parse(source);
-    if (!value || typeof value !== "object" || !("schema" in value) || value.schema !== 1 ||
-        !("packageDir" in value) || typeof value.packageDir !== "string" ||
-        !("path" in value) || typeof value.path !== "string" ||
-        !isAbsolute(value.packageDir) || !BUNDLE_NAME.test(basename(value.path)) ||
-        !("originalSha256" in value) || typeof value.originalSha256 !== "string" || !HASH.test(value.originalSha256) ||
-        !("patchedSha256" in value) || typeof value.patchedSha256 !== "string" || !HASH.test(value.patchedSha256) ||
-        value.path !== join(value.packageDir, "dist", basename(value.path)))
+    if (!value || typeof value !== "object" || !("schema" in value) || (value.schema !== 1 && value.schema !== 2) ||
+        !("packageDir" in value) || typeof value.packageDir !== "string" || !isAbsolute(value.packageDir))
+        throw new Error("Invalid adapter receipt");
+    const packageDir = value.packageDir;
+    const entries = value.schema === 1 ? [value] : "files" in value && Array.isArray(value.files) ? value.files : [];
+    if (!entries.length)
         throw new Error("Invalid adapter receipt");
-    return { schema: 1, packageDir: value.packageDir, path: value.path, originalSha256: value.originalSha256, patchedSha256: value.patchedSha256 };
+    const files = entries.map((entry) => {
+        if (!entry || typeof entry !== "object" || !("path" in entry) || typeof entry.path !== "string" ||
+            !BUNDLE_NAME.test(basename(entry.path)) ||
+            ![join(packageDir, "dist", basename(entry.path)), ...(value.schema === 2 ? [join(packageDir, "dist", ".setup", basename(entry.path))] : [])].includes(entry.path) ||
+            (value.schema === 1 && !basename(entry.path).startsWith("thread-lifecycle-")) ||
+            !("originalSha256" in entry) || typeof entry.originalSha256 !== "string" || !HASH.test(entry.originalSha256) ||
+            !("patchedSha256" in entry) || typeof entry.patchedSha256 !== "string" || !HASH.test(entry.patchedSha256))
+            throw new Error("Invalid adapter receipt");
+        const previous = "previousPatchedSha256" in entry ? entry.previousPatchedSha256 : undefined;
+        if (previous !== undefined && (typeof previous !== "string" || !HASH.test(previous)))
+            throw new Error("Invalid adapter receipt");
+        return { path: entry.path, originalSha256: entry.originalSha256, patchedSha256: entry.patchedSha256,
+            ...(typeof previous === "string" ? { previousPatchedSha256: previous } : {}) };
+    });
+    if (new Set(files.map(file => basename(file.path))).size !== files.length)
+        throw new Error("Invalid adapter receipt");
+    return value.schema === 1 ? { schema: 1, packageDir, ...files[0] } : { schema: 2, packageDir, files };
 }
-export function patchAdapterSource(source, agentDir, agentId, runtimePath) {
-    if (source.includes(MARKER))
+export async function readReceipt(agentDir) { return parseReceipt(await readOptional(receiptPath(agentDir))); }
+export function patchAdapterSources(sources, agentDir, agentId, runtimePath) {
+    if (sources.some(source => source.includes(MARKER)))
         throw new Error("Unsupported Codex adapter shape: already patched");
-    const functions = parse(source, { ecmaVersion: "latest", sourceType: "module" }).body.filter(node => node.type === "FunctionDeclaration");
+    const functions = sources.flatMap((source, bundle) => parse(source, { ecmaVersion: "latest", sourceType: "module" }).body
+        .filter(node => node.type === "FunctionDeclaration").map(node => ({ node, bundle })));
     const find = (name) => {
-        const matches = functions.filter(node => node.id?.name === name);
+        const matches = functions.filter(fn => fn.node.id?.name === name);
         if (matches.length !== 1)
-            throw new Error(`Unsupported Codex adapter shape: ${name}`);
+            throw new Error("Unsupported Codex adapter shape: " + name);
         return matches[0];
     };
     const developer = find("buildDeveloperInstructions");
     const collaboration = find("buildTurnScopedCollaborationInstructions");
-    const parent = functions.some(node => node.id?.name === "buildCodexParentLocalInstructions") ? find("buildCodexParentLocalInstructions") : null;
-    for (const fn of [developer, collaboration, ...(parent ? [parent] : [])]) {
-        if (fn.async || fn.generator || fn.params.length !== 2 || fn.params[0]?.type !== "Identifier" || fn.params[0].name !== "params" ||
-            !/^(options|options\s*=\s*\{\})$/u.test(source.slice(fn.params[1].start, fn.params[1].end)))
+    const parent = functions.some(fn => fn.node.id?.name === "buildCodexParentLocalInstructions") ? find("buildCodexParentLocalInstructions") : null;
+    const thread = functions.some(fn => fn.node.id?.name === "buildCodexThreadConfiguration") ? find("buildCodexThreadConfiguration") : null;
+    for (const { node, bundle } of [developer, collaboration, ...(parent ? [parent] : []), ...(thread ? [thread] : [])]) {
+        if (node.async || node.generator || node.params.length !== 2 || node.params[0]?.type !== "Identifier" || node.params[0].name !== "params" ||
+            !/^(options|options\s*=\s*\{\})$/u.test(sources[bundle].slice(node.params[1].start, node.params[1].end)))
             throw new Error("Unsupported Codex adapter shape: parameters");
     }
     for (const name of ["buildDefaultCollaborationInstructions", "buildCronCollaborationInstructions"]) {
-        if (find(name).params.length !== 0)
+        const helper = find(name);
+        if (helper.node.params.length !== 0 || helper.bundle !== collaboration.bundle)
             throw new Error("Unsupported Codex adapter shape: mode helpers");
     }
-    const fingerprint = (fn) => sha256(source.slice(fn.start, fn.end));
+    const fingerprint = (fn) => sha256(sources[fn.bundle].slice(fn.node.start, fn.node.end));
+    const split = parent !== null && fingerprint(parent) === CONTEXT_HASHES.splitParent;
     if (fingerprint(collaboration) !== (parent ? CONTEXT_HASHES.collaboration : CONTEXT_HASHES.legacy) ||
-        (parent && fingerprint(parent) !== CONTEXT_HASHES.parent))
+        (parent && (parent.bundle !== collaboration.bundle || ![CONTEXT_HASHES.parent, CONTEXT_HASHES.splitParent].includes(fingerprint(parent)))) ||
+        (thread && thread.bundle !== developer.bundle) ||
+        (split ? !thread || fingerprint(thread) !== CONTEXT_HASHES.thread : thread !== null && fingerprint(thread) !== CONTEXT_HASHES.legacyThread))
         throw new Error("Unsupported Codex context assembly; review the changed upstream functions before syncing");
     const prefix = `${MARKER}
 import { createRequire as unblockPromptCreateRequire } from "node:module";
@@ -73,18 +104,27 @@ function unblockFrozenPolicy(params) {
 }
 `;
     const insertions = [
-        { at: developer.body.start + 1, text: '\n\tconst unblockPolicy = unblockFrozenPolicy(params);\n\tif (unblockPolicy !== null) return [unblockPolicy, params.gitCoauthorPrompt, params.extraSystemPrompt].filter(section => typeof section === "string" && section.trim()).join("\\n\\n");' },
-        { at: collaboration.body.start + 1, text: '\n\tif (unblockFrozenPolicy(params) !== null) return params.trigger === "cron" ? buildCronCollaborationInstructions() : buildDefaultCollaborationInstructions();' },
-        ...(parent ? [{ at: parent.body.start + 1, text: '\n\tif (unblockFrozenPolicy(params) !== null) return params.trigger === "cron" ? buildCronCollaborationInstructions() : null;' }] : []),
+        { fn: developer, text: '\n\tconst unblockPolicy = unblockFrozenPolicy(params);\n\tif (unblockPolicy !== null) return [unblockPolicy, params.gitCoauthorPrompt, params.extraSystemPrompt].filter(section => typeof section === "string" && section.trim()).join("\\n\\n");' },
+        { fn: collaboration, text: '\n\tif (unblockFrozenPolicy(params) !== null) return params.trigger === "cron" ? buildCronCollaborationInstructions() : buildDefaultCollaborationInstructions();' },
+        ...(parent ? [{ fn: parent, text: '\n\tif (unblockFrozenPolicy(params) !== null) return params.trigger === "cron" ? buildCronCollaborationInstructions() : null;' }] : []),
+        // 2026.9.8 moved skills to the start/resume/fork carrier, outside developer policy.
+        ...(split && thread ? [{ fn: thread, text: '\n\tif (unblockFrozenPolicy(params) !== null) options = { ...options, skillsInstructions: undefined };' }] : []),
     ];
-    let patched = source;
-    for (const { at, text } of insertions.sort((a, b) => b.at - a.at))
-        patched = patched.slice(0, at) + text + patched.slice(at);
-    return prefix + patched;
+    return sources.map((source, bundle) => {
+        const edits = insertions.filter(edit => edit.fn.bundle === bundle).sort((a, b) => b.fn.node.body.start - a.fn.node.body.start);
+        for (const { fn, text } of edits) {
+            const at = fn.node.body.start + 1;
+            source = source.slice(0, at) + text + source.slice(at);
+        }
+        return edits.length ? prefix + source : source;
+    });
 }
-export async function prepareAdapter(agentDir, agentId, suppliedDir) {
+export async function prepareAdapter(agentDir, agentId, suppliedDir, runtimePath) {
     await openclawRoot();
-    const receipt = await readReceipt(agentDir);
+    if (!isAbsolute(runtimePath) || await readOptional(runtimePath) === null)
+        throw new Error("Missing durable plugin runtime");
+    const previousReceipt = await readOptional(receiptPath(agentDir));
+    const receipt = parseReceipt(previousReceipt);
     const packageDir = suppliedDir ? resolve(suppliedDir) : receipt?.packageDir;
     if (!packageDir)
         throw new Error("First frozen sync requires --codex-plugin-dir from openclaw plugins inspect codex --json");
@@ -94,50 +134,88 @@ export async function prepareAdapter(agentDir, agentId, suppliedDir) {
     if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== "@openclaw/codex")
         throw new Error("Expected the official @openclaw/codex package");
     assertSupportedVersion("version" in pkg ? pkg.version : undefined, "@openclaw/codex");
-    const files = (await readdir(join(packageDir, "dist"))).filter(name => BUNDLE_NAME.test(name));
-    if (files.length !== 1)
+    const dist = join(packageDir, "dist");
+    if (!(await lstat(dist)).isDirectory())
         throw new Error("Unsupported Codex bundle layout");
-    const path = join(packageDir, "dist", files[0]);
-    const current = await readOptional(path);
-    if (current === null)
-        throw new Error("Missing Codex adapter");
-    const original = receipt ? await readOptional(backupPath(agentDir)) : current;
-    if (receipt && receipt.path !== path)
+    const entries = await readdir(dist, { withFileTypes: true });
+    const setup = entries.find(entry => entry.name === ".setup");
+    if (setup && !setup.isDirectory())
+        throw new Error("Unsupported Codex bundle layout");
+    const paths = entries.filter(entry => BUNDLE_NAME.test(entry.name)).map(entry => join(dist, entry.name));
+    if (setup)
+        paths.push(...(await readdir(join(dist, ".setup"))).filter(name => BUNDLE_NAME.test(name)).map(name => join(dist, ".setup", name)));
+    paths.sort();
+    if (!paths.length || (receipt && receiptFiles(receipt).some(file => !paths.includes(file.path))))
+        throw new Error("Unsupported Codex bundle layout; restore before changing installations");
+    const bundles = await Promise.all(paths.map(async (path) => {
+        const current = await readOptional(path);
+        if (current === null)
+            throw new Error("Missing Codex adapter");
+        const file = receipt && receiptFiles(receipt).find(file => file.path === path);
+        const original = file ? await readOptional(backupPath(agentDir, file, receipt?.schema === 1)) : current;
+        if (original === null || (file && sha256(original) !== file.originalSha256))
+            throw new Error("Codex adapter backup invalid; refusing to patch");
+        if (file && !ownsSource(file, current))
+            throw new Error("Codex adapter changed by another writer; refusing to overwrite");
+        return { path, current, original };
+    }));
+    const patches = patchAdapterSources(bundles.map(bundle => bundle.original), agentDir, agentId, runtimePath);
+    const files = bundles.flatMap((bundle, index) => {
+        const patched = patches[index];
+        return patched === bundle.original ? [] : [{ ...bundle, patched }];
+    });
+    if (receipt && (files.length !== receiptFiles(receipt).length || files.some(file => !receiptFiles(receipt).some(previous => previous.path === file.path))))
         throw new Error("Codex adapter path changed; restore before changing installations");
-    if (original === null || (receipt && sha256(original) !== receipt.originalSha256))
-        throw new Error("Codex adapter backup invalid; refusing to patch");
-    if (receipt && sha256(current) !== receipt.patchedSha256 && current !== original)
-        throw new Error("Codex adapter changed by another writer; refusing to overwrite");
-    const patched = patchAdapterSource(original, agentDir, agentId, fileURLToPath(new URL("./runtime.js", import.meta.url)));
-    return { path, current, original, patched, receipt: { schema: 1, packageDir, path, originalSha256: sha256(original), patchedSha256: sha256(patched) } };
+    const nextReceipt = { schema: 2, packageDir, files: files.map(file => ({
+            path: file.path, originalSha256: sha256(file.original), patchedSha256: sha256(file.patched),
+            // Receipt-first upgrades must remain recoverable if source swapping is interrupted.
+            ...(file.current !== file.original && file.current !== file.patched ? { previousPatchedSha256: sha256(file.current) } : {}),
+        })) };
+    return { files, receipt: nextReceipt, previousReceipt };
 }
 export async function installAdapter(agentDir, plan) {
-    const backup = await readOptional(backupPath(agentDir));
-    if (backup !== null && backup !== plan.original)
-        throw new Error("Foreign adapter backup");
-    await replaceFile(backupPath(agentDir), backup, plan.original);
-    // Receipt first allows crash recovery; source swap is atomic and guarded.
-    await replaceFile(receiptPath(agentDir), await readOptional(receiptPath(agentDir)), `${JSON.stringify(plan.receipt, null, 2)}\n`);
-    return { adapterChanged: await replaceFile(plan.path, plan.current, plan.patched), restartRequired: true };
+    // Validate every target before any bundle changes; retain exact backups for recovery.
+    const backups = await Promise.all(plan.files.map(async (file) => {
+        const path = backupPath(agentDir, file);
+        const backup = await readOptional(path);
+        if (backup !== null && backup !== file.original)
+            throw new Error("Foreign adapter backup");
+        if (await readOptional(file.path) !== file.current)
+            throw new Error("Concurrent adapter edit; refusing to overwrite");
+        return { path, backup, original: file.original };
+    }));
+    for (const backup of backups)
+        await replaceFile(backup.path, backup.backup, backup.original);
+    await replaceFile(receiptPath(agentDir), plan.previousReceipt, JSON.stringify(plan.receipt, null, 2) + "\n");
+    let adapterChanged = false;
+    for (const file of plan.files)
+        adapterChanged = await replaceFile(file.path, file.current, file.patched) || adapterChanged;
+    return { adapterChanged, restartRequired: true };
 }
 export async function adapterStatus(agentDir) {
     const receipt = await readReceipt(agentDir);
     if (!receipt)
         return { installed: false };
-    const current = await readOptional(receipt.path);
-    return { installed: current !== null && sha256(current) === receipt.patchedSha256, path: receipt.path, minimumVersion: MINIMUM_OPENCLAW };
+    const files = receiptFiles(receipt);
+    const installed = (await Promise.all(files.map(async (file) => {
+        const current = await readOptional(file.path);
+        return current !== null && sha256(current) === file.patchedSha256;
+    }))).every(Boolean);
+    return { installed, path: files[0].path, paths: files.map(file => file.path), minimumVersion: MINIMUM_OPENCLAW };
 }
 export async function restoreAdapter(agentDir) {
     const receipt = await readReceipt(agentDir);
     if (!receipt)
         return;
-    const current = await readOptional(receipt.path);
-    const original = await readOptional(backupPath(agentDir));
-    if (original === null || sha256(original) !== receipt.originalSha256)
-        throw new Error("Adapter backup invalid");
-    if (current === original)
-        return;
-    if (current === null || sha256(current) !== receipt.patchedSha256)
-        throw new Error("Foreign adapter edit; refusing restore");
-    await replaceFile(receipt.path, current, original);
+    const files = await Promise.all(receiptFiles(receipt).map(async (file) => {
+        const current = await readOptional(file.path);
+        const original = await readOptional(backupPath(agentDir, file, receipt.schema === 1));
+        if (original === null || sha256(original) !== file.originalSha256)
+            throw new Error("Adapter backup invalid");
+        if (!ownsSource(file, current))
+            throw new Error("Foreign adapter edit; refusing restore");
+        return { path: file.path, current, original };
+    }));
+    for (const file of files)
+        await replaceFile(file.path, file.current, file.original);
 }

package/dist/index.js

@@ -8,7 +8,7 @@ import { buildSkillsCatalog, compilePrompt } from "./compiler.js";
 import { readFrozenPolicy } from "./runtime.js";
 import { fetchPrompt, REMOTE_POLICY } from "./remote.js";
 import { readOptional } from "./manager.js";
-import { join } from "node:path";
+import { basename, dirname, isAbsolute, join } from "node:path";
 import { CATALOG_REFRESH_MS, catalogStatus, refreshCatalog, restoreCatalog, startCatalogRefresh } from "./catalog.js";
 import { codexSkillsStatus, refreshCodexSkills, removeCodexSkills } from "./skills.js";
 async function refresh(target, automatic = false) {
@@ -148,7 +148,12 @@ export default definePluginEntry({
             sync.action(async () => {
                 const target = await resolveTarget(config);
                 const options = sync.opts();
-                const plan = target.settings.frozenContext ? await prepareAdapter(target.agentDir, target.settings.agentId, options.codexPluginDir) : null;
+                // Captured import.meta.url paths expire with the CLI. Older hosts expose the
+                // published dist/index.js via source; newer hosts select it via runtimeSource.
+                const source = "runtimeSource" in api && typeof api.runtimeSource === "string" ? api.runtimeSource : api.source;
+                if (target.settings.frozenContext && (!isAbsolute(source) || basename(source) !== "index.js"))
+                    throw new Error("Frozen sync requires the packaged plugin runtime entry");
+                const plan = target.settings.frozenContext ? await prepareAdapter(target.agentDir, target.settings.agentId, options.codexPluginDir, join(dirname(source), "runtime.js")) : null;
                 const remote = target.settings.promptUrl ? await fetchPrompt(target.settings.promptUrl) : null;
                 const prompt = remote?.prompt ?? await bundledPrompt(target.settings.agentName);
                 const compiled = target.settings.frozenContext ? await compilePrompt(prompt, remote ? REMOTE_POLICY : await readFile(new URL("../prompts/developer.md", import.meta.url), "utf8"), target.workspaceDir, await buildSkillsCatalog(config, target.settings.agentId, target.workspaceDir)) : null;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-codex-prompt",
   "name": "Unblock Codex Prompt",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Maintain an agent-scoped Codex base prompt and its model_instructions_file pointer.",
   "activation": { "onStartup": true },
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-codex-prompt",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Manage a shared Codex base prompt for an OpenClaw agent.",
   "type": "module",
   "main": "./dist/index.js",