@astrosheep/square 0.3.5 → 0.3.7

package/dist/harness-codex.js

@@ -1,653 +1,119 @@
-import { spawn, spawnSync } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { SQUARE_IDENTITY } from './identity.js';
-import { reconcileInstall, reconcileUninstall, staleManagedRegistrations, } from './harness-lifecycle.js';
+import { stageReplacement } from './harness-stage.js';
 export const CODEX_HOOK_COMMAND = SQUARE_IDENTITY.hookCommand;
 export const SQUARE_CODEX_MARKER = SQUARE_IDENTITY.hookMarker;
 export const CODEX_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
 export const CODEX_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
+const LEGACY_MARKETPLACES = ['astrosheep-square'];
 export function codexMarketplaceRoot(homeDir) {
     return path.join(homeDir, '.square', 'codex', 'marketplaces', CODEX_MARKETPLACE_NAME);
 }
-export function codexPluginRoot(homeDir) {
-    return path.join(codexMarketplaceRoot(homeDir), 'plugins', SQUARE_IDENTITY.pluginName);
-}
-export function codexPluginHooksPath(homeDir) {
-    return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json');
-}
-function codexHome(homeDir) {
-    return process.env.CODEX_HOME?.trim() || path.join(homeDir, '.codex');
-}
-export function codexHomeHooksPath(homeDir) {
-    return path.join(codexHome(homeDir), 'hooks.json');
-}
-export function codexConfigPath(homeDir) {
-    return path.join(codexHome(homeDir), 'config.toml');
-}
-function managedHooksPath(homeDir) {
-    return path.join(homeDir, '.square', 'codex', 'hooks.json');
-}
-function sectionRange(lines, section) {
-    const escaped = section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const header = new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`);
-    const start = lines.findIndex((line) => header.test(line));
-    if (start < 0)
-        return undefined;
-    const next = lines.findIndex((line, index) => index > start && /^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(line));
-    return { start, end: next < 0 ? lines.length : next };
-}
-export function upsertTomlSectionKey(text, section, key, value) {
-    const lines = text === '' ? [] : text.replace(/\n$/, '').split('\n');
-    const range = sectionRange(lines, section);
-    const assignment = `${key} = ${value}`;
-    if (range === undefined) {
-        if (lines.length > 0 && lines.at(-1) !== '')
-            lines.push('');
-        lines.push(`[${section}]`, assignment);
-        return `${lines.join('\n')}\n`;
-    }
-    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const keyPattern = new RegExp(`^\\s*${escaped}\\s*=`);
-    const existing = lines.findIndex((line, index) => index > range.start && index < range.end && keyPattern.test(line));
-    if (existing < 0)
-        lines.splice(range.end, 0, assignment);
-    else
-        lines[existing] = assignment;
-    return `${lines.join('\n')}\n`;
-}
-function writeAtomic(filePath, contents) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temporary, contents, { mode: 0o600 });
-    fs.renameSync(temporary, filePath);
-}
-function writeJsonAtomic(filePath, value) {
-    writeAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-function backup(filePath) {
-    const backupPath = `${filePath}.square-bak`;
-    if (fs.existsSync(filePath) && !fs.existsSync(backupPath))
-        fs.copyFileSync(filePath, backupPath);
-}
-function requireSuccess(result, operation) {
-    if (result.status === 0)
-        return;
-    const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`;
-    throw new Error(`Codex ${operation} failed: ${detail}`);
-}
+export function codexPluginRoot(homeDir) { return path.join(codexMarketplaceRoot(homeDir), 'plugins', SQUARE_IDENTITY.pluginName); }
+export function codexPluginHooksPath(homeDir) { return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json'); }
+function codexHome(homeDir) { return path.join(homeDir, '.codex'); }
+export function codexHomeHooksPath(homeDir) { return path.join(codexHome(homeDir), 'hooks.json'); }
+export function codexConfigPath(homeDir) { return path.join(codexHome(homeDir), 'config.toml'); }
 function runCodex(homeDir, args) {
     const result = spawnSync(process.env.SQUARE_CODEX_BIN || 'codex', args, {
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            HOME: homeDir,
-            CODEX_HOME: codexHome(homeDir),
-        },
-        maxBuffer: 4 * 1024 * 1024,
-        timeout: 30_000,
+        encoding: 'utf8', env: { ...process.env, HOME: homeDir, CODEX_HOME: codexHome(homeDir) }, timeout: 30_000,
     });
     if (result.error)
         throw result.error;
-    return {
-        status: result.status ?? 1,
-        stdout: result.stdout || '',
-        stderr: result.stderr || '',
-    };
+    return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
 }
-function packageAsset(relative) {
-    return fileURLToPath(new URL(relative, import.meta.url));
-}
-function isSquareGroup(group) {
-    if (group === null || typeof group !== 'object')
-        return false;
-    const hooks = group.hooks;
-    if (!Array.isArray(hooks))
-        return false;
-    return hooks.some((hook) => {
-        if (hook === null || typeof hook !== 'object')
-            return false;
-        const command = hook.command;
-        const statusMessage = hook.statusMessage;
-        return command === CODEX_HOOK_COMMAND || statusMessage === SQUARE_CODEX_MARKER;
-    });
+function requireSuccess(result, operation, allowMissing = false) {
+    if (result.status === 0 || (allowMissing && /not configured|not installed|not found/i.test(result.stderr)))
+        return;
+    throw new Error(`Codex ${operation} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
 }
-export function stripSquareCodexHooks(filePath) {
-    if (!fs.existsSync(filePath))
-        return false;
-    const root = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    if (root === null || typeof root !== 'object' || root.hooks === undefined || typeof root.hooks !== 'object') {
-        return false;
-    }
-    let changed = false;
-    for (const [event, groups] of Object.entries(root.hooks)) {
-        if (!Array.isArray(groups))
-            continue;
-        const remaining = groups.filter((group) => !isSquareGroup(group));
-        if (remaining.length === groups.length)
-            continue;
-        changed = true;
-        if (remaining.length === 0)
-            delete root.hooks[event];
-        else
-            root.hooks[event] = remaining;
-    }
-    if (!changed)
-        return false;
-    if (Object.keys(root.hooks).length === 0)
-        fs.rmSync(filePath, { force: true });
+export function upsertTomlSectionKey(text, section, key, value) {
+    const lines = text.replace(/\n$/, '').split('\n').filter((line, i) => line !== '' || i < text.length);
+    const header = `[${section}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0)
+        return `${text.trimEnd()}${text.trim() ? '\n\n' : ''}${header}\n${key} = ${value}\n`;
+    const end = lines.findIndex((line, i) => i > start && /^\s*\[[^\]]+\]/.test(line));
+    const stop = end < 0 ? lines.length : end;
+    const match = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&')}\\s*=`);
+    const existing = lines.findIndex((line, i) => i > start && i < stop && match.test(line));
+    if (existing < 0)
+        lines.splice(stop, 0, `${key} = ${value}`);
     else
-        writeJsonAtomic(filePath, root);
-    return true;
+        lines[existing] = `${key} = ${value}`;
+    return `${lines.join('\n')}\n`;
 }
-function codexMarketplaceDocument() {
-    return {
-        name: CODEX_MARKETPLACE_NAME,
-        interface: { displayName: SQUARE_IDENTITY.productName },
-        plugins: [
-            {
-                name: SQUARE_IDENTITY.pluginName,
-                source: { source: 'local', path: './plugins/square' },
-                policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
-                category: 'Developer Tools',
-            },
-        ],
-    };
+function writeAtomic(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temp, text, { mode: 0o600 });
+    fs.renameSync(temp, file);
 }
-function stageCodexBundle(_homeDir, marketplaceRoot) {
-    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    const stage = `${marketplaceRoot}.${token}.stage`;
-    const backupPath = `${marketplaceRoot}.${token}.previous`;
-    const pluginRoot = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
-    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
-    try {
-        fs.cpSync(packageAsset('../codex-plugin/'), pluginRoot, { recursive: true });
-        const skill = path.join(pluginRoot, 'skills', 'square', 'SKILL.md');
+export async function installCodexPlugin(homeDir, run = runCodex) {
+    const root = codexMarketplaceRoot(homeDir);
+    const config = codexConfigPath(homeDir);
+    const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const staged = stageReplacement(root, (stage) => {
+        const plugin = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
+        fs.cpSync(fileURLToPath(new URL('../codex-plugin/', import.meta.url)), plugin, { recursive: true });
+        const skill = path.join(plugin, 'skills', 'square', 'SKILL.md');
         fs.mkdirSync(path.dirname(skill), { recursive: true });
-        fs.copyFileSync(path.join(packageAsset('../skills/square/'), 'SKILL.md'), skill);
-        writeJsonAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), codexMarketplaceDocument());
-        if (fs.existsSync(marketplaceRoot))
-            fs.renameSync(marketplaceRoot, backupPath);
-        fs.renameSync(stage, marketplaceRoot);
-    }
-    catch (error) {
-        try {
-            fs.rmSync(stage, { recursive: true, force: true });
-        }
-        catch {
-            // Keep the source error; staging cleanup is best effort.
-        }
-        if (fs.existsSync(backupPath) && !fs.existsSync(marketplaceRoot)) {
-            fs.renameSync(backupPath, marketplaceRoot);
-        }
-        throw error;
-    }
-    return {
-        desired: {
-            marketplaceName: CODEX_MARKETPLACE_NAME,
-            marketplaceRoot,
-            pluginId: CODEX_PLUGIN_ID,
-        },
-        rollback() {
-            fs.rmSync(marketplaceRoot, { recursive: true, force: true });
-            if (fs.existsSync(backupPath))
-                fs.renameSync(backupPath, marketplaceRoot);
-        },
-        finalize() {
-            fs.rmSync(backupPath, { recursive: true, force: true });
-        },
-    };
-}
-function parseInventory(stdout) {
-    let payload;
-    try {
-        payload = JSON.parse(stdout);
-    }
-    catch {
-        throw new Error('Codex marketplace inventory returned invalid JSON.');
-    }
-    if (payload === null || typeof payload !== 'object' || !Array.isArray(payload.marketplaces)) {
-        throw new Error('Codex marketplace inventory is malformed.');
-    }
-    const marketplaces = payload.marketplaces.map(parseMarketplaceRegistration);
-    return { marketplaces };
-}
-function parseMarketplaceRegistration(value) {
-    if (value === null || typeof value !== 'object') {
-        throw new Error('Codex marketplace inventory entry is invalid.');
-    }
-    const entry = value;
-    if (typeof entry.name !== 'string' || typeof entry.root !== 'string') {
-        throw new Error('Codex marketplace inventory entry is malformed.');
-    }
-    const source = entry.marketplaceSource;
-    if (source === undefined)
-        return { name: entry.name, source: entry.root, local: false };
-    if (source === null || typeof source !== 'object')
-        throw new Error('Codex marketplace source is malformed.');
-    const marketplaceSource = source;
-    if (typeof marketplaceSource.sourceType !== 'string') {
-        throw new Error('Codex marketplace source is malformed.');
-    }
-    if (marketplaceSource.sourceType !== 'local') {
-        const stableSource = typeof marketplaceSource.source === 'string'
-            ? marketplaceSource.source
-            : entry.root;
-        return {
-            name: entry.name,
-            source: `${marketplaceSource.sourceType}:${stableSource}`,
-            local: false,
-        };
-    }
-    if (typeof marketplaceSource.source !== 'string') {
-        throw new Error('Codex local marketplace inventory entry is malformed.');
-    }
-    return { name: entry.name, source: marketplaceSource.source, local: true };
-}
-function pluginHooksFromList(result) {
-    const entries = result?.data;
-    if (!Array.isArray(entries))
-        throw new Error('Codex hooks/list returned invalid data.');
-    const hooks = [];
-    for (const entry of entries) {
-        if (!Array.isArray(entry.hooks))
-            continue;
-        for (const value of entry.hooks) {
-            if (value === null || typeof value !== 'object')
-                continue;
-            const hook = value;
-            if (hook.pluginId !== CODEX_PLUGIN_ID)
-                continue;
-            if (typeof hook.key !== 'string' ||
-                typeof hook.eventName !== 'string' ||
-                typeof hook.enabled !== 'boolean' ||
-                typeof hook.currentHash !== 'string' ||
-                typeof hook.trustStatus !== 'string') {
-                throw new Error('Codex hooks/list returned an invalid Square hook.');
-            }
-            hooks.push({
-                key: hook.key,
-                eventName: hook.eventName,
-                pluginId: CODEX_PLUGIN_ID,
-                enabled: hook.enabled,
-                currentHash: hook.currentHash,
-                trustStatus: hook.trustStatus,
-            });
-        }
-    }
-    return hooks;
-}
-function expectedHooks(hooks) {
-    if (hooks.length !== 2 || hooks.some((hook) => !hook.enabled))
-        return false;
-    const events = hooks.map((hook) => hook.eventName).sort();
-    return events[0] === 'stop' && events[1] === 'userPromptSubmit';
-}
-function trustUpdate(hooks) {
-    return Object.fromEntries(hooks.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]));
-}
-export function inspectCodexPluginHooks(homeDir, trust) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.env.SQUARE_CODEX_BIN || 'codex', ['app-server', '--stdio'], {
-            env: {
-                ...process.env,
-                HOME: homeDir,
-                CODEX_HOME: codexHome(homeDir),
-            },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const finish = (error, hooks) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            child.kill('SIGTERM');
-            if (error !== undefined)
-                reject(error);
-            else
-                resolve(hooks ?? []);
-        };
-        const timer = setTimeout(() => finish(new Error(`Codex hooks API timed out${stderr.trim() ? `: ${stderr.trim()}` : ''}`)), 30_000);
-        const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
-        const requestHooks = (id) => {
-            send({ id, method: 'hooks/list', params: { cwds: [process.cwd()] } });
-        };
-        const sendTrust = (hooks) => {
-            send({
-                id: 2,
-                method: 'config/batchWrite',
-                params: {
-                    edits: [{ keyPath: 'hooks.state', value: trustUpdate(hooks), mergeStrategy: 'upsert' }],
-                    reloadUserConfig: true,
-                },
-            });
-        };
-        const failForMessage = (message) => {
-            if (message.error === undefined)
-                return false;
-            const detail = typeof message.error.message === 'string'
-                ? message.error.message
-                : JSON.stringify(message.error);
-            finish(new Error(`Codex hooks API failed: ${detail}`));
-            return true;
-        };
-        const handleMessage = (message) => {
-            if (failForMessage(message))
-                return;
-            if (message.id === 0) {
-                send({ method: 'initialized', params: {} });
-                requestHooks(1);
-                return;
-            }
-            if (message.id === 1) {
-                const hooks = pluginHooksFromList(message.result);
-                if (!trust) {
-                    finish(undefined, hooks);
-                    return;
-                }
-                if (!expectedHooks(hooks)) {
-                    finish(new Error(`Codex discovered an unexpected hook set for ${CODEX_PLUGIN_ID}.`));
-                    return;
-                }
-                sendTrust(hooks);
-                return;
-            }
-            if (message.id === 2) {
-                requestHooks(3);
-                return;
-            }
-            if (message.id === 3)
-                finish(undefined, pluginHooksFromList(message.result));
-        };
-        const consumeStdout = (chunk) => {
-            stdout += String(chunk);
-            while (stdout.includes('\n')) {
-                const newline = stdout.indexOf('\n');
-                const line = stdout.slice(0, newline);
-                stdout = stdout.slice(newline + 1);
-                if (!line.trim())
-                    continue;
-                try {
-                    handleMessage(JSON.parse(line));
-                }
-                catch (error) {
-                    const diagnostic = error instanceof Error ? error : new Error(String(error));
-                    if (diagnostic instanceof SyntaxError) {
-                        finish(new Error(`Codex hooks API returned invalid JSON: ${line}`));
-                    }
-                    else {
-                        finish(diagnostic);
-                    }
-                    return;
-                }
-            }
-        };
-        child.on('error', (error) => finish(error));
-        child.stdin.on('error', (error) => finish(error));
-        child.stderr.on('data', (chunk) => {
-            stderr += String(chunk);
-        });
-        child.stdout.on('data', consumeStdout);
-        child.on('exit', (code) => {
-            if (!settled) {
-                const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
-                finish(new Error(`Codex hooks API exited ${code ?? 'without status'}${suffix}`));
-            }
-        });
-        send({
-            id: 0,
-            method: 'initialize',
-            params: {
-                clientInfo: {
-                    name: SQUARE_IDENTITY.clientName,
-                    title: SQUARE_IDENTITY.productName,
-                    version: SQUARE_IDENTITY.packageVersion,
-                },
-            },
-        });
+        fs.copyFileSync(path.join(fileURLToPath(new URL('../skills/square/', import.meta.url)), 'SKILL.md'), skill);
+        writeAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), `${JSON.stringify({ name: CODEX_MARKETPLACE_NAME, plugins: [{ name: SQUARE_IDENTITY.pluginName, source: { source: 'local', path: './plugins/square' } }] }, null, 2)}\n`);
     });
-}
-function codexProtocol(run, hooksRuntime, notes, installed) {
-    const inspectInventory = (homeDir) => {
-        const result = run(homeDir, ['plugin', 'marketplace', 'list', '--json']);
-        requireSuccess(result, 'marketplace inventory');
-        return parseInventory(result.stdout);
-    };
-    const stageBundle = (homeDir, marketplaceRoot) => {
-        const config = codexConfigPath(homeDir);
-        const hooks = codexHomeHooksPath(homeDir);
-        backup(config);
-        backup(hooks);
-        const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const notes = [];
+    try {
         writeAtomic(config, upsertTomlSectionKey(current, 'features', 'hooks', 'true'));
-        return stageCodexBundle(homeDir, marketplaceRoot);
-    };
-    const registerMarketplace = (homeDir, marketplaceRoot) => {
-        const result = run(homeDir, ['plugin', 'marketplace', 'add', marketplaceRoot, '--json']);
-        requireSuccess(result, 'marketplace install');
-    };
-    const installOrUpdate = (homeDir, pluginId) => {
-        const result = run(homeDir, ['plugin', 'add', pluginId, '--json']);
-        requireSuccess(result, 'plugin install');
+        requireSuccess(run(homeDir, ['plugin', 'marketplace', 'add', root, '--json']), 'marketplace install', true);
+        const installed = run(homeDir, ['plugin', 'add', CODEX_PLUGIN_ID, '--json']);
+        requireSuccess(installed, 'plugin install');
+        let installedPath;
         try {
-            const payload = JSON.parse(result.stdout);
-            if (typeof payload.installedPath === 'string')
-                installed.path = payload.installedPath;
+            const value = JSON.parse(installed.stdout).installedPath;
+            if (typeof value === 'string')
+                installedPath = value;
         }
         catch {
-            notes.push('Codex installed the plugin but returned non-JSON output.');
+            notes.push('Codex returned non-JSON installation output.');
         }
-    };
-    const verifyPluginAndHooks = async (homeDir, marketplaceName, pluginId) => {
-        const listed = run(homeDir, ['plugin', 'list', '--marketplace', marketplaceName, '--json']);
-        requireSuccess(listed, 'plugin inventory');
-        let entries;
-        try {
-            entries = JSON.parse(listed.stdout).installed;
-        }
-        catch {
-            throw new Error('Codex plugin inventory returned invalid JSON.');
-        }
-        const installedAndEnabled = Array.isArray(entries) && entries.some((entry) => {
-            if (entry === null || typeof entry !== 'object')
-                return false;
-            const plugin = entry;
-            return plugin.pluginId === pluginId && plugin.installed === true && plugin.enabled === true;
-        });
-        if (!installedAndEnabled) {
-            throw new Error(`Codex did not verify ${pluginId} as installed and enabled.`);
-        }
-        const hooks = await hooksRuntime(homeDir, true);
-        if (!expectedHooks(hooks)) {
-            throw new Error(`Codex did not discover both Square plugin hooks for ${pluginId}.`);
-        }
-        const untrusted = hooks.filter((hook) => hook.trustStatus !== 'trusted');
-        if (untrusted.length > 0) {
-            throw new Error(`Codex did not trust Square plugin hooks: ${untrusted.map((hook) => hook.key).join(', ')}`);
-        }
-    };
-    const removePlugin = (homeDir, pluginId) => {
-        const result = run(homeDir, ['plugin', 'remove', pluginId, '--json']);
-        if (result.status !== 0 && !result.stderr.includes('is not configured or installed')) {
-            requireSuccess(result, 'plugin removal');
-        }
-    };
-    const removeMarketplace = (homeDir, marketplaceName) => {
-        const result = run(homeDir, ['plugin', 'marketplace', 'remove', marketplaceName, '--json']);
-        if (result.status !== 0 && !result.stderr.includes('is not configured or installed')) {
-            requireSuccess(result, 'marketplace removal');
-        }
-    };
-    const retireDirectDelivery = (homeDir) => {
-        const hooks = codexHomeHooksPath(homeDir);
-        try {
-            if (stripSquareCodexHooks(hooks))
-                notes.push(`Removed legacy Square handlers from ${hooks}.`);
-        }
-        catch (error) {
-            notes.push(`Legacy hooks were left untouched: ${error instanceof Error ? error.message : String(error)}`);
+        for (const marketplace of LEGACY_MARKETPLACES) {
+            const pluginId = `${SQUARE_IDENTITY.pluginName}@${marketplace}`;
+            if (!current.includes(`[marketplaces.${marketplace}]`) && !current.includes(`[plugins."${pluginId}"]`))
+                continue;
+            requireSuccess(run(homeDir, ['plugin', 'remove', pluginId, '--json']), 'legacy plugin removal', true);
+            requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', marketplace, '--json']), 'legacy marketplace removal', true);
+            notes.push(`retired ${pluginId}`);
         }
-        fs.rmSync(managedHooksPath(homeDir), { force: true });
-    };
-    return {
-        host: 'codex',
-        marketplaceName: CODEX_MARKETPLACE_NAME,
-        pluginId: CODEX_PLUGIN_ID,
-        managedRoot: (homeDir) => path.join(homeDir, '.square', 'codex'),
-        stageBundle,
-        inspectInventory,
-        registerMarketplace(homeDir, desired) {
-            registerMarketplace(homeDir, desired.marketplaceRoot);
-        },
-        installOrUpdate(homeDir, desired) {
-            installOrUpdate(homeDir, desired.pluginId);
-        },
-        verifyPluginAndHooks(homeDir, desired) {
-            return verifyPluginAndHooks(homeDir, desired.marketplaceName, desired.pluginId);
-        },
-        removePlugin(homeDir, pluginId) {
-            removePlugin(homeDir, pluginId);
-        },
-        removeMarketplace(homeDir, marketplaceName) {
-            removeMarketplace(homeDir, marketplaceName);
-        },
-        removeManagedSource(source) {
-            fs.rmSync(source, { recursive: true, force: true });
-        },
-        retireDirectDelivery,
-        removeManagedRoot(homeDir) {
-            fs.rmSync(path.join(homeDir, '.square', 'codex'), { recursive: true, force: true });
-        },
-    };
-}
-function isManagedMarketplace(homeDir, registration) {
-    if (!registration.local)
-        return false;
-    const root = path.join(homeDir, '.square', 'codex');
-    const relative = path.relative(path.resolve(root), path.resolve(registration.source));
-    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
-}
-function marketplaceRootFromInventory(homeDir, inventory) {
-    return inventory.marketplaces.find((entry) => entry.name === CODEX_MARKETPLACE_NAME && isManagedMarketplace(homeDir, entry))?.source ?? codexMarketplaceRoot(homeDir);
-}
-export async function installCodexPlugin(homeDir, run = runCodex, hooksRuntime = inspectCodexPluginHooks) {
-    const notes = [];
-    const installed = {};
-    const protocol = codexProtocol(run, hooksRuntime, notes, installed);
-    const inventory = await reconcileInstall(homeDir, protocol);
-    const marketplaceRoot = marketplaceRootFromInventory(homeDir, inventory);
-    return {
-        configPath: codexConfigPath(homeDir),
-        marketplaceRoot,
-        pluginRoot: path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName),
-        ...(installed.path === undefined ? {} : { installedPath: installed.path }),
-        notes,
-    };
-}
-export async function uninstallCodexPlugin(homeDir, run = runCodex) {
-    const notes = [];
-    const base = codexProtocol(run, async () => [], notes, {});
-    const protocol = {
-        ...base,
-        async inspectInventory(currentHome) {
-            const inventory = await base.inspectInventory(currentHome);
-            if (inventory.marketplaces.some((entry) => isManagedMarketplace(currentHome, entry))) {
-                return inventory;
-            }
-            return {
-                marketplaces: [
-                    ...inventory.marketplaces,
-                    {
-                        name: CODEX_MARKETPLACE_NAME,
-                        source: codexMarketplaceRoot(currentHome),
-                        local: true,
-                        pluginIds: [CODEX_PLUGIN_ID],
-                    },
-                ],
-            };
-        },
-    };
-    await reconcileUninstall(homeDir, protocol);
-    const root = codexMarketplaceRoot(homeDir);
-    fs.rmSync(root, { recursive: true, force: true });
-    fs.rmSync(managedHooksPath(homeDir), { force: true });
-    return { paths: [root, codexHomeHooksPath(homeDir), managedHooksPath(homeDir)], notes };
-}
-function pluginHooksInstalled(filePath) {
-    try {
-        const contents = fs.readFileSync(filePath, 'utf8');
-        const hooks = JSON.parse(contents);
-        return Array.isArray(hooks.hooks?.UserPromptSubmit) && Array.isArray(hooks.hooks?.Stop);
-    }
-    catch {
-        return false;
-    }
-}
-function codexPluginStatus(homeDir, run) {
-    const listed = run(homeDir, ['plugin', 'list', '--marketplace', CODEX_MARKETPLACE_NAME, '--json']);
-    if (listed.status !== 0)
-        return `○ ${CODEX_PLUGIN_ID} unavailable`;
-    try {
-        const payload = JSON.parse(listed.stdout);
-        const plugin = payload.installed?.find((item) => item.pluginId === CODEX_PLUGIN_ID);
-        return plugin?.installed === true && plugin.enabled === true
-            ? `✓ ${CODEX_PLUGIN_ID} installed and enabled`
-            : `○ ${CODEX_PLUGIN_ID} is not installed and enabled`;
+        staged.finalize();
+        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir), ...(installedPath ? { installedPath } : {}), notes };
     }
-    catch {
-        return `○ ${CODEX_PLUGIN_ID} unavailable`;
+    catch (error) {
+        staged.rollback();
+        throw error;
     }
 }
-async function codexHookStatus(homeDir, hooksRuntime) {
-    try {
-        const hooks = await hooksRuntime(homeDir, false);
-        const trusted = hooks.every((hook) => hook.trustStatus === 'trusted');
-        return expectedHooks(hooks) && trusted
-            ? `✓ ${CODEX_PLUGIN_ID} hooks trusted by Codex`
-            : `✕ Codex runtime did not discover both ${CODEX_PLUGIN_ID} hooks`;
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        return `✕ Codex hooks runtime unavailable (${detail})`;
+export async function uninstallCodexPlugin(homeDir, run = runCodex) {
+    requireSuccess(run(homeDir, ['plugin', 'remove', CODEX_PLUGIN_ID, '--json']), 'plugin removal', true);
+    requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', CODEX_MARKETPLACE_NAME, '--json']), 'marketplace removal', true);
+    for (const marketplace of LEGACY_MARKETPLACES) {
+        requireSuccess(run(homeDir, ['plugin', 'remove', `${SQUARE_IDENTITY.pluginName}@${marketplace}`, '--json']), 'legacy plugin removal', true);
+        requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', marketplace, '--json']), 'legacy marketplace removal', true);
     }
+    const root = codexMarketplaceRoot(homeDir);
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(codexHomeHooksPath(homeDir), { force: true });
+    return { paths: [root, codexConfigPath(homeDir), codexHomeHooksPath(homeDir)], notes: [] };
 }
-export async function doctorCodexPlugin(homeDir, run = runCodex, hooksRuntime = inspectCodexPluginHooks) {
-    const protocol = codexProtocol(run, hooksRuntime, [], {});
-    const inventory = await protocol.inspectInventory(homeDir);
-    const marketplaceRoot = marketplaceRootFromInventory(homeDir, inventory);
-    const stale = staleManagedRegistrations(inventory, protocol.managedRoot(homeDir), {
-        marketplaceName: CODEX_MARKETPLACE_NAME,
-        marketplaceRoot,
-        pluginId: CODEX_PLUGIN_ID,
-    });
-    const current = inventory.marketplaces.some((entry) => entry.name === CODEX_MARKETPLACE_NAME && isManagedMarketplace(homeDir, entry));
+export async function doctorCodexPlugin(homeDir, run = runCodex) {
+    const root = codexMarketplaceRoot(homeDir);
     const config = codexConfigPath(homeDir);
-    const configText = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
-    const bundleRoot = path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
-    const bundleHooks = path.join(bundleRoot, 'hooks', 'hooks.json');
-    const lines = [
-        /^hooks = true$/m.test(configText)
-            ? `✓ features.hooks=true in ${config}`
-            : `○ features.hooks missing in ${config}`,
-        pluginHooksInstalled(bundleHooks)
-            ? `✓ Square plugin hooks ${bundleHooks}`
-            : `○ Square plugin bundle missing ${bundleRoot}`,
-        current
-            ? `✓ ${CODEX_PLUGIN_ID} marketplace registered`
-            : `○ ${CODEX_PLUGIN_ID} marketplace is not registered`,
-        codexPluginStatus(homeDir, run),
-        await codexHookStatus(homeDir, hooksRuntime),
+    const listed = run(homeDir, ['plugin', 'list', '--json']);
+    return [
+        /^hooks\s*=\s*true$/m.test(fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '') ? `✓ features.hooks=true in ${config}` : `○ features.hooks missing in ${config}`,
+        fs.existsSync(codexPluginHooksPath(homeDir)) ? `✓ Square plugin hooks ${codexPluginHooksPath(homeDir)}` : `○ Square plugin bundle missing ${root}`,
+        listed.status === 0 && listed.stdout.includes(CODEX_PLUGIN_ID) ? `✓ ${CODEX_PLUGIN_ID} installed` : `○ ${CODEX_PLUGIN_ID} unavailable`,
     ];
-    if (stale.length > 0)
-        lines.push(`✕ ${stale.length} stale Square marketplace registration(s)`);
-    return lines;
 }
-export const codexHarness = Object.freeze({
-    install: installCodexPlugin,
-    uninstall: uninstallCodexPlugin,
-    doctor: doctorCodexPlugin,
-});