@unblocklabs/unblock-codex-prompt 0.1.0 → 0.2.1

package/README.md

@@ -1,7 +1,8 @@
 # Unblock Codex Prompt
 
 A small, explicit prompt-management bridge for dedicated OpenClaw Mac agents.
-**Version 0.1.0.** The frozen bridge is pinned to OpenClaw/Codex plugin 2026.9.2.
+**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
 
@@ -27,15 +28,22 @@ files use private permissions. Missing identity documents are recorded as absent
 
 ## Compatibility
 
-- Frozen bridge: **OpenClaw 2026.9.2 and @openclaw/codex 2026.9.2 only**. The exact
-  original adapter SHA-256 is checked before patching. Unknown builds are refused.
+- Frozen bridge: **OpenClaw and @openclaw/codex >=2026.9.2**. Reviewed layouts cover
+  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.
 - One target agent per installation. Other agents use upstream behavior. Native
   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. It is deliberately version-pinned, not upgrade-proof.
+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.
 Remote-node-only skills are not added; this is for dedicated local Mac agents.
@@ -46,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.1.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:
@@ -181,6 +189,26 @@ contents without a Gateway restart. Content-only updates report
 are not reset, and their adoption is not guaranteed. The plugin never restarts
 the Gateway automatically; revalidate this behavior when upgrading Codex.
 
+## Codex skills removal
+
+Codex lists every skill it finds in the managed Codex home, including skills from
+ChatGPT remote plugins that sync in on their own. `disabledCodexSkills` names the
+ones to remove: a plugin name removes all of that plugin's skills, and an exact
+skill name (`pages:write-page`, `imagegen`) removes one. It defaults to
+`["pages", "work-pets"]` (ChatGPT Pages and Pets). Other skills are untouched.
+
+```json
+"disabledCodexSkills": ["pages", "work-pets"]
+```
+
+The plugin scans `skills/` and `plugins/cache/` under the managed Codex home and
+writes one marked block of `[[skills.config]] name = "…" enabled = false` rules at
+the end of `config.toml`. It re-applies the block at Gateway startup, `sync`,
+`refresh`, and the daily refresh, so newly synced plugin skills are caught.
+Codex reads the rules when its app-server starts; running sessions keep their
+list until the Gateway or app-server restarts. Set `[]` to remove the block.
+`restore` also removes it. User-authored `[[skills.config]]` entries stay as written.
+
 ## Restore
 
 ```sh
@@ -212,7 +240,7 @@ without restoring leaves the frozen base but re-enables live injections.
 
 ```sh
 npm run preflight
-npm run release:check -- v0.1.0
+npm run release:check -- v0.2.1
 ```
 
 Tests cover compilation, explicit refresh, native/private-body exclusion,
@@ -221,7 +249,8 @@ pointer ownership and foreign edits. See [VALIDATION.md](VALIDATION.md) for live
 proof and limits.
 
 Install with
-`openclaw plugins install npm:@unblocklabs/unblock-codex-prompt@0.1.0 --accept-capabilities`.
+the packed archive above for an unreleased candidate. After publication, use
+`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/RELEASING.md

@@ -25,7 +25,7 @@ If first-package bootstrapping is needed, an authenticated owner can publish the
 reviewed version once with `npm publish --access public`, then configure trust:
 
 ```sh
-npm trust github @unblocklabs/unblock-codex-prompt --repo unblocklabs-ai/unblock-codex-prompt --file release.yml --yes
+npx --yes --package npm@12.0.2 npm trust github @unblocklabs/unblock-codex-prompt --repo unblocklabs-ai/unblock-codex-prompt --file release.yml --allow-publish --yes
 ```
 
 The Release workflow verifies the registry's tarball integrity against its own
@@ -33,6 +33,11 @@ packed artifact before accepting an already-published version. Different bytes
 fail the job. Subsequent new versions publish through OIDC with provenance; a
 local bootstrap publication does not have GitHub Actions provenance.
 
+Trusted publishing was configured during the 0.1.0 release. The trust-management
+command above uses npm 12 because the current registry requires explicit publish
+permissions; npm 11.13.0's older trust request was rejected. Normal CI publishing
+continues to use the pinned CLI in `release.yml`.
+
 ClawHub publishing is not configured.
 
 ## Release checklist

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,11 +40,13 @@ export declare function installAdapter(agentDir: string, plan: Awaited<ReturnTyp
 export declare function adapterStatus(agentDir: string): Promise<{
     installed: boolean;
     path?: never;
-    supportedVersion?: never;
+    paths?: never;
+    minimumVersion?: never;
 } | {
     installed: boolean;
     path: string;
-    supportedVersion: string;
+    paths: string[];
+    minimumVersion: string;
 }>;
 export declare function restoreAdapter(agentDir: string): Promise<void>;
 export {};

package/dist/adapter.js

@@ -1,31 +1,94 @@
-import { readFile, readdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { basename, isAbsolute, join, resolve } from "node:path";
+import { parse } from "acorn";
 import { readOptional, replaceFile, sha256 } from "./manager.js";
-import { SUPPORTED_OPENCLAW, openclawRoot } from "./compiler.js";
-const ORIGINAL_SHA256 = "344d4a6332d59b5eb1d7551d6d308563f339d5d2251809c8f25e8cec04ede342";
+import { openclawRoot } from "./compiler.js";
+import { assertSupportedVersion, MINIMUM_OPENCLAW } from "./compatibility.js";
 const MARKER = "// unblock-codex-prompt bridge v1";
-const developer = "function buildDeveloperInstructions(params, options = {}) {";
-const collaboration = "function buildTurnScopedCollaborationInstructions(params, options = {}) {";
+const BUNDLE_NAME = /^thread-(lifecycle|requests)-[\w-]+\.m?js$/u;
+const HASH = /^[a-f0-9]{64}$/u;
+// 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" ||
-        !("originalSha256" in value) || value.originalSha256 !== ORIGINAL_SHA256 ||
-        !("patchedSha256" in value) || typeof value.patchedSha256 !== "string" ||
-        value.path !== join(value.packageDir, "dist", "thread-lifecycle-DPK30jad.js"))
+    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) || source.split(developer).length !== 2 || source.split(collaboration).length !== 2)
-        throw new Error("Unsupported Codex adapter shape");
+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 = 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(fn => fn.node.id?.name === name);
+        if (matches.length !== 1)
+            throw new Error("Unsupported Codex adapter shape: " + name);
+        return matches[0];
+    };
+    const developer = find("buildDeveloperInstructions");
+    const collaboration = find("buildTurnScopedCollaborationInstructions");
+    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"]) {
+        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(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 && (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";
 const unblockPromptRequire = unblockPromptCreateRequire(import.meta.url);
@@ -40,65 +103,119 @@ function unblockFrozenPolicy(params) {
   return unblockPromptRequire(${JSON.stringify(runtimePath)}).readFrozenPolicy(${JSON.stringify(agentDir)});
 }
 `;
-    return prefix + source.replace(developer, `${developer}
-\tconst unblockPolicy = unblockFrozenPolicy(params);
-\tif (unblockPolicy !== null) return [unblockPolicy, params.extraSystemPrompt].filter(section => typeof section === "string" && section.trim()).join("\\n\\n");`)
-        .replace(collaboration, `${collaboration}
-\tif (unblockFrozenPolicy(params) !== null) return params.trigger === "cron" ? buildCronCollaborationInstructions() : buildDefaultCollaborationInstructions();`);
+    const insertions = [
+        { 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 };' }] : []),
+    ];
+    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");
     if (receipt && receipt.packageDir !== packageDir)
         throw new Error("Restore the previous adapter before changing Codex installations");
     const pkg = JSON.parse(await readFile(join(packageDir, "package.json"), "utf8"));
-    if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== "@openclaw/codex" || !("version" in pkg) || pkg.version !== SUPPORTED_OPENCLAW)
-        throw new Error(`Frozen bridge requires @openclaw/codex ${SUPPORTED_OPENCLAW}`);
-    const files = (await readdir(join(packageDir, "dist"))).filter(name => /^thread-lifecycle-[\w-]+\.js$/u.test(name));
-    if (files.length !== 1 || files[0] !== "thread-lifecycle-DPK30jad.js")
+    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 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 (original === null || sha256(original) !== ORIGINAL_SHA256)
-        throw new Error("Unknown Codex adapter bytes; 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: ORIGINAL_SHA256, patchedSha256: sha256(patched) } };
+    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");
+    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, supportedVersion: SUPPORTED_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/compatibility.d.ts

@@ -0,0 +1,2 @@
+export declare const MINIMUM_OPENCLAW = "2026.9.2";
+export declare function assertSupportedVersion(version: unknown, product: string): void;

package/dist/compatibility.js

@@ -0,0 +1,9 @@
+export const MINIMUM_OPENCLAW = "2026.9.2";
+export function assertSupportedVersion(version, product) {
+    const match = typeof version === "string" ? /^(\d+)\.(\d+)\.(\d+)(?:-\d+)?$/u.exec(version) : null;
+    const supported = match && (Number(match[1]) > 2026 ||
+        (Number(match[1]) === 2026 && (Number(match[2]) > 9 ||
+            (Number(match[2]) === 9 && Number(match[3]) >= 2))));
+    if (!supported)
+        throw new Error(`Frozen bridge requires ${product} >=${MINIMUM_OPENCLAW} (stable release)`);
+}

package/dist/compiler.d.ts

@@ -1,5 +1,4 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
-export declare const SUPPORTED_OPENCLAW = "2026.9.2";
 export declare function openclawRoot(): Promise<string>;
 export declare function buildSkillsCatalog(config: OpenClawConfig, agentId: string, workspaceDir: string): Promise<{
     prompt: string;

package/dist/compiler.js

@@ -2,7 +2,7 @@ import { readFile, readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { readOptional, sha256 } from "./manager.js";
-export const SUPPORTED_OPENCLAW = "2026.9.2";
+import { assertSupportedVersion } from "./compatibility.js";
 export async function openclawRoot() {
     let directory = dirname(fileURLToPath(import.meta.resolve("openclaw/plugin-sdk/agent-runtime")));
     for (;;) {
@@ -10,8 +10,7 @@ export async function openclawRoot() {
         if (source) {
             const pkg = JSON.parse(source);
             if (pkg && typeof pkg === "object" && "name" in pkg && pkg.name === "openclaw") {
-                if (!("version" in pkg) || pkg.version !== SUPPORTED_OPENCLAW)
-                    throw new Error(`Frozen bridge supports OpenClaw ${SUPPORTED_OPENCLAW} only; review upgrades before syncing`);
+                assertSupportedVersion("version" in pkg ? pkg.version : undefined, "OpenClaw");
                 return directory;
             }
         }
@@ -21,21 +20,23 @@ export async function openclawRoot() {
         directory = parent;
     }
 }
-// OpenClaw has no public catalog-building SDK. Pin this single internal export,
+// OpenClaw has no public catalog-building SDK. Validate this internal export,
 // retaining its eligibility, agent allowlist, prompt visibility and size limits.
 export async function buildSkillsCatalog(config, agentId, workspaceDir) {
     const dist = join(await openclawRoot(), "dist");
-    const names = (await readdir(dist)).filter(name => /^workspace-skill-prompt-[\w-]+\.js$/u.test(name));
+    const names = (await readdir(dist)).filter(name => /^workspace-skill-prompt-[\w-]+\.m?js$/u.test(name));
     if (names.length !== 1)
         throw new Error("Unsupported OpenClaw skills module layout");
     const path = join(dist, names[0]);
     const source = await readFile(path, "utf8");
-    if (!source.includes("buildSkillSnapshot as t"))
+    const exports = [...source.matchAll(/\bbuildSkillSnapshot as ([\w$]+)\b/gu)];
+    if (exports.length !== 1)
         throw new Error("Unsupported OpenClaw skills export");
     const module = await import(pathToFileURL(path).href);
-    if (typeof module.t !== "function")
+    const buildSnapshot = module[exports[0][1]];
+    if (typeof buildSnapshot !== "function")
         throw new Error("Missing OpenClaw skill snapshot builder");
-    const result = module.t(workspaceDir, { config, agentId });
+    const result = await buildSnapshot(workspaceDir, { config, agentId });
     if (!result || typeof result !== "object" || !("prompt" in result) || typeof result.prompt !== "string" ||
         !("resolvedSkills" in result) || !Array.isArray(result.resolvedSkills))
         throw new Error("Unsupported OpenClaw skill snapshot result");

package/dist/config.d.ts

@@ -1,10 +1,12 @@
 export declare const PLUGIN_ID = "unblock-codex-prompt";
+export declare const DEFAULT_DISABLED_CODEX_SKILLS: string[];
 export declare function parseConfig(raw: unknown): {
     agentId: string;
     agentName: string | undefined;
     frozenContext: boolean;
     promptUrl: string | undefined;
     suppressExplicitDelegationPrompt: boolean;
+    disabledCodexSkills: string[];
 };
 export declare function validatePromptUrl(value: string): URL;
 export declare function renderPrompt(template: string, agentName?: string): string;

package/dist/config.js

@@ -1,10 +1,12 @@
 export const PLUGIN_ID = "unblock-codex-prompt";
+// ChatGPT Pages and Pets skills reach Codex through remote plugins and do not apply to OpenClaw agents.
+export const DEFAULT_DISABLED_CODEX_SKILLS = ["pages", "work-pets"];
 export function parseConfig(raw) {
     const value = raw ?? {};
     if (typeof value !== "object" || Array.isArray(value))
         throw new Error("Plugin config must be an object");
     for (const key of Object.keys(value)) {
-        if (key !== "agentId" && key !== "agentName" && key !== "frozenContext" && key !== "promptUrl" && key !== "suppressExplicitDelegationPrompt")
+        if (key !== "agentId" && key !== "agentName" && key !== "frozenContext" && key !== "promptUrl" && key !== "suppressExplicitDelegationPrompt" && key !== "disabledCodexSkills")
             throw new Error(`Unknown plugin option: ${key}`);
     }
     const agentId = "agentId" in value ? value.agentId : "main";
@@ -32,7 +34,12 @@ export function parseConfig(raw) {
         throw new Error("suppressExplicitDelegationPrompt must be boolean");
     if (suppressExplicitDelegationPrompt && !frozenContext)
         throw new Error("suppressExplicitDelegationPrompt requires frozenContext");
-    return { agentId, agentName: agentName?.trim(), frozenContext, promptUrl, suppressExplicitDelegationPrompt };
+    const disabledCodexSkills = "disabledCodexSkills" in value ? value.disabledCodexSkills : DEFAULT_DISABLED_CODEX_SKILLS;
+    if (!Array.isArray(disabledCodexSkills) || disabledCodexSkills.length > 64 ||
+        disabledCodexSkills.some(entry => typeof entry !== "string" || !/^[\w.@:-]{1,128}$/u.test(entry)) || new Set(disabledCodexSkills).size !== disabledCodexSkills.length) {
+        throw new Error("disabledCodexSkills must be a list of up to 64 unique skill or plugin names");
+    }
+    return { agentId, agentName: agentName?.trim(), frozenContext, promptUrl, suppressExplicitDelegationPrompt, disabledCodexSkills: disabledCodexSkills };
 }
 export function validatePromptUrl(value) {
     const url = new URL(value);

package/dist/index.js

@@ -8,13 +8,15 @@ 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) {
     const failures = [];
     let catalog;
     let prompt;
-    // Attempt both independently, sequentially because they share the enrollment lock.
+    let skills;
+    // Attempt each independently, sequentially because they share the enrollment lock.
     if (target.settings.suppressExplicitDelegationPrompt) {
         try {
             catalog = await refreshCatalog(target.agentDir, { automatic });
@@ -32,9 +34,15 @@ async function refresh(target, automatic = false) {
             failures.push(error);
         }
     }
+    try {
+        skills = await refreshCodexSkills(target.agentDir, target.settings.disabledCodexSkills);
+    }
+    catch (error) {
+        failures.push(error);
+    }
     if (failures.length)
         throw new AggregateError(failures, "Refresh incomplete; failed components retain their installed data");
-    return { catalog, prompt };
+    return { catalog, prompt, skills };
 }
 async function resolveTarget(config) {
     const settings = parseConfig(config.plugins?.entries?.[PLUGIN_ID]?.config);
@@ -83,7 +91,7 @@ async function status(config) {
 export default definePluginEntry({
     id: PLUGIN_ID,
     name: "Unblock Codex Prompt",
-    description: "Explicitly compile a frozen Codex prompt with a narrow, version-pinned OpenClaw bridge.",
+    description: "Explicitly compile a frozen Codex prompt with a guarded OpenClaw bridge.",
     register(api) {
         let stopCatalogRefresh;
         // Registration/import stays read-only, including plugin inspection and CLI discovery.
@@ -94,11 +102,20 @@ export default definePluginEntry({
                 const result = await status(ctx.config);
                 ctx.logger.info(`${PLUGIN_ID}: ${JSON.stringify(result)}`);
                 const target = await resolveTarget(ctx.config);
-                if ((target.settings.suppressExplicitDelegationPrompt || target.settings.promptUrl) && result.enrolled) {
+                if (result.enrolled) {
+                    // Remote Codex plugins can add skills at any time; reconcile before app-servers start.
+                    try {
+                        ctx.logger.info(`${PLUGIN_ID}: codex skills ${JSON.stringify(await refreshCodexSkills(target.agentDir, target.settings.disabledCodexSkills))}`);
+                    }
+                    catch (error) {
+                        ctx.logger.error(`${PLUGIN_ID}: codex skills not applied: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                if (result.enrolled) {
                     const catalog = await catalogStatus(target.agentDir);
                     const remote = "remotePrompt" in result ? result.remotePrompt : null;
                     const checkedAt = remote && typeof remote === "object" && "checkedAt" in remote && typeof remote.checkedAt === "number" ? remote.checkedAt : 0;
-                    const nextAt = Math.min(target.settings.suppressExplicitDelegationPrompt ? catalog.nextRefreshAt ?? 0 : Infinity, target.settings.promptUrl ? checkedAt ? checkedAt + CATALOG_REFRESH_MS : 0 : Infinity);
+                    const nextAt = Math.min(target.settings.suppressExplicitDelegationPrompt ? catalog.nextRefreshAt ?? 0 : Infinity, target.settings.promptUrl ? checkedAt ? checkedAt + CATALOG_REFRESH_MS : 0 : Infinity, Date.now() + CATALOG_REFRESH_MS);
                     stopCatalogRefresh = startCatalogRefresh(async () => {
                         const refreshed = await refresh(target, true);
                         ctx.logger.info(`${PLUGIN_ID}: daily refresh ${JSON.stringify(refreshed)}`);
@@ -113,7 +130,8 @@ export default definePluginEntry({
             root.command("status").description("Inspect disk state without writing or claiming live adoption")
                 .action(async () => {
                 const target = await resolveTarget(config);
-                console.log(JSON.stringify({ ...await status(config), catalog: await catalogStatus(target.agentDir) }, null, 2));
+                console.log(JSON.stringify({ ...await status(config), catalog: await catalogStatus(target.agentDir),
+                    codexSkills: await codexSkillsStatus(target.agentDir, target.settings.disabledCodexSkills) }, null, 2));
             });
             root.command("refresh-catalog").description("Fetch fresh provider metadata and repair the managed delegation-policy catalog")
                 .action(async () => {
@@ -122,7 +140,7 @@ export default definePluginEntry({
                     throw new Error("Enable suppressExplicitDelegationPrompt before refreshing the catalog");
                 console.log(JSON.stringify(await refreshCatalog(target.agentDir), null, 2));
             });
-            root.command("refresh").description("Refresh remote prompt and enabled catalog without rereading frozen agent context")
+            root.command("refresh").description("Refresh remote prompt, enabled catalog and codex skills without rereading frozen agent context")
                 .action(async () => console.log(JSON.stringify(await refresh(await resolveTarget(config)), null, 2)));
             const sync = root.command("sync").description("Explicitly refresh the prompt snapshot and install the reviewed adapter")
                 .option("--adopt", "Take ownership of an existing custom prompt pointer")
@@ -130,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;
@@ -139,12 +162,14 @@ export default definePluginEntry({
                 const result = await syncPrompt({ ...target, prompt, ...compiled }, { adopt: options.adopt === true });
                 const adapter = plan ? await installAdapter(target.agentDir, plan) : undefined;
                 const catalog = target.settings.suppressExplicitDelegationPrompt ? await refreshCatalog(target.agentDir) : undefined;
-                console.log(JSON.stringify({ ...result, adapter, skillCount: compiled?.bundle.skillCount, remotePrompt: remote?.source, catalog }, null, 2));
+                const codexSkills = await refreshCodexSkills(target.agentDir, target.settings.disabledCodexSkills);
+                console.log(JSON.stringify({ ...result, adapter, skillCount: compiled?.bundle.skillCount, remotePrompt: remote?.source, catalog, codexSkills }, null, 2));
             });
             root.command("restore").description("Restore the original pointer; pause automatic management and retain files")
                 .action(async () => {
                 const target = await resolveTarget(config);
                 await restoreCatalog(target.agentDir);
+                await removeCodexSkills(target.agentDir);
                 await restoreAdapter(target.agentDir);
                 console.log(JSON.stringify(await restorePrompt({ ...target, prompt: "" }), null, 2));
             });

package/dist/skills.d.ts

@@ -0,0 +1,34 @@
+export type CodexSkill = {
+    name: string;
+    plugin: string | null;
+};
+/** Skills Codex loads from this agent's home: system, user and cached plugin skills (`plugin:skill`). */
+export declare function discoverCodexSkills(agentDir: string): Promise<CodexSkill[]>;
+/** A list entry names a skill exactly, or a plugin to disable all of its skills. */
+export declare function isListed(skill: CodexSkill, list: readonly string[]): boolean;
+/** `null` when nothing discovered is listed, so the config carries no empty block. */
+export declare function renderSkillsBlock(skills: readonly CodexSkill[], disable: readonly string[]): string | null;
+/** Replace, append or (with `null`) remove the managed block, always leaving it last in the file. */
+export declare function setSkillsBlock(source: string, block: string | null): string;
+/** Disable the listed skills in this agent's Codex home. New plugin skills are caught on the next refresh. */
+export declare function refreshCodexSkills(agentDir: string, disable: readonly string[]): Promise<{
+    skipped: boolean;
+    changed: boolean;
+    restartRequired?: never;
+    disabled?: never;
+    notFound?: never;
+} | {
+    changed: boolean;
+    restartRequired: boolean;
+    disabled: string[];
+    notFound: string[];
+    skipped?: never;
+}>;
+export declare function removeCodexSkills(agentDir: string): Promise<{
+    changed: boolean;
+}>;
+export declare function codexSkillsStatus(agentDir: string, disable: readonly string[]): Promise<{
+    managed: boolean;
+    configured: readonly string[];
+    disabled: string[];
+}>;

package/dist/skills.js

@@ -0,0 +1,181 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { getStaticTOMLValue, parseTOML } from "toml-eslint-parser";
+import { readOptional, replaceFile, withLock } from "./manager.js";
+// Codex loads every discovered skill unless a [[skills.config]] rule turns it off, and remote
+// plugins can add skills at any time. This block disables the listed skills and plugins by name,
+// the selector Codex applies to plugin skills (`plugin:skill`) as well as system skills.
+const BEGIN = "# BEGIN unblock-codex-prompt codex skills (managed; replaced on refresh)";
+const END = "# END unblock-codex-prompt codex skills";
+function files(agentDir) {
+    const home = join(resolve(agentDir), "codex-home");
+    return { home, config: join(home, "config.toml"), state: join(home, ".unblock-codex-prompt.json") };
+}
+function isMissing(error) {
+    return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function directories(path) {
+    try {
+        return (await readdir(path, { withFileTypes: true })).filter(entry => entry.isDirectory() && !entry.name.startsWith("."));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
+    }
+}
+/** Codex names a skill by its SKILL.md frontmatter `name`, falling back to the directory name. */
+function skillName(doc, directory) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(doc)?.[1] ?? "";
+    return /^name:\s*["']?(.+?)["']?\s*$/mu.exec(frontmatter)?.[1]?.trim() || directory;
+}
+async function skillsUnder(root, depth) {
+    const names = [];
+    for (const entry of await directories(root)) {
+        const directory = join(root, entry.name);
+        const doc = await readText(join(directory, "SKILL.md"));
+        if (doc !== null)
+            names.push(skillName(doc, entry.name));
+        else if (depth > 1)
+            names.push(...await skillsUnder(directory, depth - 1));
+    }
+    return names;
+}
+/** Skills Codex loads from this agent's home: system, user and cached plugin skills (`plugin:skill`). */
+export async function discoverCodexSkills(agentDir) {
+    const { home } = files(agentDir);
+    const found = [];
+    for (const name of await skillsUnder(join(home, "skills", ".system"), 1))
+        found.push({ name, plugin: null });
+    for (const name of await skillsUnder(join(home, "skills"), 1))
+        found.push({ name, plugin: null });
+    // Cache layout: plugins/cache/<marketplace>/<plugin>/<version>/.codex-plugin/plugin.json
+    const cache = join(home, "plugins", "cache");
+    for (const marketplace of await directories(cache)) {
+        for (const plugin of await directories(join(cache, marketplace.name))) {
+            for (const version of await directories(join(cache, marketplace.name, plugin.name))) {
+                const root = join(cache, marketplace.name, plugin.name, version.name);
+                const manifestText = await readText(join(root, ".codex-plugin", "plugin.json"));
+                if (manifestText === null)
+                    continue;
+                let manifest;
+                try {
+                    manifest = JSON.parse(manifestText);
+                }
+                catch {
+                    continue;
+                }
+                const record = manifest && typeof manifest === "object" ? manifest : {};
+                const namespace = typeof record.name === "string" && record.name ? record.name : plugin.name;
+                const roots = typeof record.skills === "string" ? [record.skills]
+                    : Array.isArray(record.skills) ? record.skills.filter((path) => typeof path === "string") : ["./skills/"];
+                for (const skillsRoot of roots) {
+                    for (const name of await skillsUnder(resolve(root, skillsRoot), 3))
+                        found.push({ name: `${namespace}:${name}`, plugin: namespace });
+                }
+            }
+        }
+    }
+    const unique = new Map(found.map(skill => [skill.name, skill]));
+    return [...unique.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** A list entry names a skill exactly, or a plugin to disable all of its skills. */
+export function isListed(skill, list) {
+    return list.includes(skill.name) || (skill.plugin !== null && list.includes(skill.plugin));
+}
+/** `null` when nothing discovered is listed, so the config carries no empty block. */
+export function renderSkillsBlock(skills, disable) {
+    const rules = skills.filter(skill => isListed(skill, disable))
+        .map(skill => `[[skills.config]]\nname = ${JSON.stringify(skill.name)}\nenabled = false\n`);
+    return rules.length ? [BEGIN, `# Disabled: ${disable.join(", ")}`, ...rules, END].join("\n") + "\n" : null;
+}
+function locateBlock(source) {
+    const begin = source.indexOf(BEGIN);
+    const end = source.indexOf(END);
+    if ((begin === -1) !== (end === -1) || end < begin || source.indexOf(BEGIN, begin + 1) !== -1) {
+        throw new Error("The managed codex skills block in config.toml is damaged; restore its BEGIN/END markers or remove it");
+    }
+    return begin === -1 ? null : { begin, end: end + END.length };
+}
+function skillRules(source) {
+    let config;
+    try {
+        config = getStaticTOMLValue(parseTOML(source, { tomlVersion: "1.0" }));
+    }
+    catch {
+        // Parser messages can include source snippets from credential-bearing TOML.
+        throw new Error("config.toml would be invalid with the managed skills block; is skills.config defined inline?");
+    }
+    const skills = config && typeof config === "object" ? config.skills : undefined;
+    const rules = skills && typeof skills === "object" ? skills.config : undefined;
+    return Array.isArray(rules) ? rules : [];
+}
+/** Replace, append or (with `null`) remove the managed block, always leaving it last in the file. */
+export function setSkillsBlock(source, block) {
+    const found = locateBlock(source);
+    let rest = source;
+    if (found) {
+        const after = source.slice(found.end).replace(/^\r?\n/u, "");
+        const before = source.slice(0, found.begin).replace(/\n+$/u, "\n");
+        rest = before === "\n" ? after : before + after;
+    }
+    const result = block === null ? rest : `${rest === "" ? "" : `${rest.replace(/\n*$/u, "\n")}\n`}${block}`;
+    if (block !== null) {
+        const expected = [...block.matchAll(/^name = (".*")\nenabled = (true|false)$/gmu)].map(match => `${JSON.parse(match[1])}=${match[2]}`);
+        const actual = skillRules(result).slice(-expected.length).map(rule => `${String(rule.name)}=${String(rule.enabled)}`);
+        if (expected.length && actual.join("\n") !== expected.join("\n"))
+            throw new Error("Managed skills rules did not parse as the last skills.config entries");
+    }
+    return result;
+}
+async function enrolled(agentDir) {
+    const source = await readOptional(files(agentDir).state);
+    if (source === null)
+        return false;
+    const state = JSON.parse(source);
+    return !!state && typeof state === "object" && "active" in state && state.active === true;
+}
+/** Disable the listed skills in this agent's Codex home. New plugin skills are caught on the next refresh. */
+export async function refreshCodexSkills(agentDir, disable) {
+    return withLock({ agentDir, prompt: "" }, async () => {
+        if (!await enrolled(agentDir))
+            return { skipped: true, changed: false };
+        const path = files(agentDir).config;
+        const current = await readOptional(path) ?? "";
+        const skills = await discoverCodexSkills(agentDir);
+        const changed = await replaceFile(path, current, setSkillsBlock(current, renderSkillsBlock(skills, disable)));
+        return {
+            changed,
+            // Codex reads skills config when its app-server starts; running sessions keep their list.
+            restartRequired: changed,
+            disabled: skills.filter(skill => isListed(skill, disable)).map(skill => skill.name),
+            notFound: disable.filter(entry => !skills.some(skill => isListed(skill, [entry]))),
+        };
+    });
+}
+export async function removeCodexSkills(agentDir) {
+    return withLock({ agentDir, prompt: "" }, async () => {
+        const path = files(agentDir).config;
+        const current = await readOptional(path);
+        if (current === null)
+            return { changed: false };
+        return { changed: await replaceFile(path, current, setSkillsBlock(current, null)) };
+    });
+}
+export async function codexSkillsStatus(agentDir, disable) {
+    const source = await readOptional(files(agentDir).config) ?? "";
+    const found = locateBlock(source);
+    const managed = found ? source.slice(found.begin, found.end) : "";
+    const disabled = [...managed.matchAll(/^name = (".*")\nenabled = false$/gmu)].map(match => JSON.parse(match[1]));
+    return { managed: found !== null, configured: disable, disabled };
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-codex-prompt",
   "name": "Unblock Codex Prompt",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Maintain an agent-scoped Codex base prompt and its model_instructions_file pointer.",
   "activation": { "onStartup": true },
   "configSchema": {
@@ -12,14 +12,16 @@
       "agentName": { "type": "string", "minLength": 1, "maxLength": 100 },
       "frozenContext": { "type": "boolean", "default": false },
       "promptUrl": { "type": "string", "format": "uri", "pattern": "^https://" },
-      "suppressExplicitDelegationPrompt": { "type": "boolean", "default": false }
+      "suppressExplicitDelegationPrompt": { "type": "boolean", "default": false },
+      "disabledCodexSkills": { "type": "array", "default": ["pages", "work-pets"], "maxItems": 64, "uniqueItems": true, "items": { "type": "string", "pattern": "^[\\w.@:-]{1,128}$" } }
     }
   },
   "uiHints": {
     "agentId": { "label": "OpenClaw agent ID", "help": "Only this agent's managed Codex home is modified. Defaults to main." },
     "agentName": { "label": "Agent name", "help": "Optional name in the shared prompt. Omit for a generic opening." },
-    "frozenContext": { "label": "Frozen context bridge", "help": "Opt in to the reviewed OpenClaw 2026.9.2 adapter. Initial setup requires explicit sync and activation. Local documents and skills stay frozen until another sync." },
+    "frozenContext": { "label": "Frozen context bridge", "help": "Opt in on OpenClaw/Codex >=2026.9.2 with a supported context-assembly layout. Initial setup requires explicit sync and activation. Local documents and skills stay frozen until another sync." },
     "promptUrl": { "label": "Fleet prompt endpoint", "help": "Public HTTPS plain-text endpoint with X-Prompt-Revision SHA-256. After initial sync, refreshed daily and when overdue on startup without refreshing agent context. Requires frozenContext; replaces both bundled policy files." },
-    "suppressExplicitDelegationPrompt": { "label": "Suppress conflicting Codex delegation policy", "help": "Manage a model_catalog_json override, refreshed from the configured provider daily and when overdue on startup. Requires frozenContext and an available provider env_key. Generated-file edits are replaced on refresh." }
+    "suppressExplicitDelegationPrompt": { "label": "Suppress conflicting Codex delegation policy", "help": "Manage a model_catalog_json override, refreshed from the configured provider daily and when overdue on startup. Requires frozenContext and an available provider env_key. Generated-file edits are replaced on refresh." },
+    "disabledCodexSkills": { "label": "Codex skills to remove", "help": "Plugin names (all of their skills) or exact skill names to disable in Codex's native skills list. Defaults to ChatGPT Pages and Pets. Applied through a managed [[skills.config]] block at startup, sync and daily refresh; other skills are untouched. Set [] to stop managing Codex skills." }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-codex-prompt",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Manage a shared Codex base prompt for an OpenClaw agent.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,7 +17,7 @@
     "release:check": "node scripts/check-release-version.mjs",
     "prepack": "npm run build"
   },
-  "dependencies": { "toml-eslint-parser": "^1.0.3" },
+  "dependencies": { "acorn": "^8.18.0", "toml-eslint-parser": "^1.0.3" },
   "devDependencies": {
     "@openclaw/plugin-inspector": "^0.3.25",
     "@types/node": "^22.0.0",