@unblocklabs/unblock-codex-prompt 0.1.0 → 0.2.0

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.0.** 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,18 @@ 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 and 2026.9.4, including the newer parent-local context path. 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.
+one Codex adapter bundle (plus the parent-local context entry point on newer builds).
+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 +50,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.0.tgz --force --accept-capabilities
 ```
 
 Include the plugin in `plugins.allow` if applicable, then configure:
@@ -181,6 +185,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 +236,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.0
 ```
 
 Tests cover compilation, explicit refresh, native/private-body exclusion,
@@ -221,7 +245,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.0 --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

@@ -27,11 +27,11 @@ export declare function installAdapter(agentDir: string, plan: Awaited<ReturnTyp
 export declare function adapterStatus(agentDir: string): Promise<{
     installed: boolean;
     path?: never;
-    supportedVersion?: never;
+    minimumVersion?: never;
 } | {
     installed: boolean;
     path: string;
-    supportedVersion: string;
+    minimumVersion: string;
 }>;
 export declare function restoreAdapter(agentDir: string): Promise<void>;
 export {};

package/dist/adapter.js

@@ -1,12 +1,20 @@
 import { readFile, readdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
+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 { 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-[\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.
+const CONTEXT_HASHES = {
+    legacy: "1fb45c46c50a63f68e8b6bdfbc5d7ae2d323470c00db69779d159592868940bb",
+    parent: "5ee80edf3f3887e841def5d64896a3d27c35063f6d4803dceeb8b8bf07b654f0",
+    collaboration: "aea7e95ca43f0997b0a3f616f327132bfdd057bb731e6eead132fba21de3f981",
+};
 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) {
@@ -17,15 +25,39 @@ export async function readReceipt(agentDir) {
     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"))
+        !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)))
         throw new Error("Invalid adapter receipt");
     return { schema: 1, packageDir: value.packageDir, path: value.path, originalSha256: value.originalSha256, patchedSha256: value.patchedSha256 };
 }
 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");
+    if (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 find = (name) => {
+        const matches = functions.filter(node => 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(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)))
+            throw new Error("Unsupported Codex adapter shape: parameters");
+    }
+    for (const name of ["buildDefaultCollaborationInstructions", "buildCronCollaborationInstructions"]) {
+        if (find(name).params.length !== 0)
+            throw new Error("Unsupported Codex adapter shape: mode helpers");
+    }
+    const fingerprint = (fn) => sha256(source.slice(fn.start, fn.end));
+    if (fingerprint(collaboration) !== (parent ? CONTEXT_HASHES.collaboration : CONTEXT_HASHES.legacy) ||
+        (parent && fingerprint(parent) !== CONTEXT_HASHES.parent))
+        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,11 +72,15 @@ 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 = [
+        { 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;' }] : []),
+    ];
+    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;
 }
 export async function prepareAdapter(agentDir, agentId, suppliedDir) {
     await openclawRoot();
@@ -55,22 +91,25 @@ export async function prepareAdapter(agentDir, agentId, suppliedDir) {
     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 files = (await readdir(join(packageDir, "dist"))).filter(name => BUNDLE_NAME.test(name));
+    if (files.length !== 1)
         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 && receipt.path !== 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: ORIGINAL_SHA256, patchedSha256: sha256(patched) } };
+    return { path, current, original, patched, receipt: { schema: 1, packageDir, path, originalSha256: sha256(original), patchedSha256: sha256(patched) } };
 }
 export async function installAdapter(agentDir, plan) {
     const backup = await readOptional(backupPath(agentDir));
@@ -86,7 +125,7 @@ export async function adapterStatus(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 };
+    return { installed: current !== null && sha256(current) === receipt.patchedSha256, path: receipt.path, minimumVersion: MINIMUM_OPENCLAW };
 }
 export async function restoreAdapter(agentDir) {
     const receipt = await readReceipt(agentDir);

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

@@ -10,11 +10,13 @@ import { fetchPrompt, REMOTE_POLICY } from "./remote.js";
 import { readOptional } from "./manager.js";
 import { 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")
@@ -139,12 +157,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.0",
   "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.0",
   "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",