@astrosheep/square 0.3.4 → 0.3.5

package/dist/harness.js

@@ -1,589 +1,109 @@
-import { spawn, 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';
-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;
-export const CLAUDE_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
-export const CLAUDE_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
-function sectionRange(lines, section) {
-    const header = new RegExp(`^\\s*\\[${section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]\\s*(?:#.*)?$`);
-    const start = lines.findIndex((line) => header.test(line));
-    if (start < 0)
-        return undefined;
-    let end = lines.length;
-    for (let index = start + 1; index < lines.length; index++) {
-        if (/^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    return { start, end };
-}
-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) {
-        if (lines.length > 0 && lines.at(-1) !== '')
-            lines.push('');
-        lines.push(`[${section}]`, assignment);
-        return `${lines.join('\n')}\n`;
-    }
-    const keyPattern = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=`);
-    const existing = lines.findIndex((line, index) => index > range.start && index < range.end && keyPattern.test(line));
-    if (existing >= 0) {
-        if (lines[existing] === assignment)
-            return text.endsWith('\n') ? text : `${text}\n`;
-        lines[existing] = assignment;
-    }
-    else {
-        lines.splice(range.end, 0, assignment);
-    }
-    return `${lines.join('\n')}\n`;
-}
-function isSquareGroup(group) {
-    if (group === null || typeof group !== 'object')
-        return false;
-    const handlers = group.hooks;
-    return (Array.isArray(handlers) &&
-        handlers.some((handler) => handler !== null &&
-            typeof handler === 'object' &&
-            (handler.command === CODEX_HOOK_COMMAND ||
-                handler.statusMessage === SQUARE_CODEX_MARKER)));
-}
-function writeJsonAtomic(filePath, value) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-    fs.renameSync(temp, filePath);
-}
-function writeTextAtomic(filePath, text) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temp, text, { mode: 0o600 });
-    fs.renameSync(temp, filePath);
-}
-function backupFile(filePath) {
-    if (!fs.existsSync(filePath))
-        return undefined;
-    const backup = `${filePath}.square-bak`;
-    if (!fs.existsSync(backup))
-        fs.copyFileSync(filePath, backup);
-    return backup;
-}
-export function codexMarketplaceRoot(homeDir) {
-    return path.join(homeDir, '.square', 'codex', 'marketplace');
-}
-export function codexPluginRoot(homeDir) {
-    return path.join(codexMarketplaceRoot(homeDir), 'plugins', 'square');
-}
-export function codexPluginHooksPath(homeDir) {
-    return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json');
-}
-function activeCodexHome(homeDir) {
-    return process.env['CODEX_HOME']?.trim() || path.join(homeDir, '.codex');
-}
-export function codexHomeHooksPath(homeDir) {
-    return path.join(activeCodexHome(homeDir), 'hooks.json');
-}
-export function codexConfigPath(homeDir) {
-    return path.join(activeCodexHome(homeDir), 'config.toml');
-}
-function legacyManagedHooksPath(homeDir) {
-    return path.join(homeDir, '.square', 'codex', 'hooks.json');
-}
-export function stripSquareCodexHooks(filePath) {
-    if (!fs.existsSync(filePath))
-        return false;
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`Invalid Codex hooks file: ${filePath}`);
-    }
-    const root = parsed;
-    const hooksValue = root['hooks'];
-    if (hooksValue === undefined)
-        return false;
-    if (hooksValue === null || typeof hooksValue !== 'object' || Array.isArray(hooksValue)) {
-        throw new Error(`Invalid Codex hooks map: ${filePath}`);
-    }
-    const hooks = hooksValue;
-    let changed = false;
-    for (const event of Object.keys(hooks)) {
-        const value = hooks[event];
-        if (!Array.isArray(value))
-            continue;
-        const next = value.filter((group) => !isSquareGroup(group));
-        if (next.length !== value.length) {
-            changed = true;
-            if (next.length === 0)
-                delete hooks[event];
-            else
-                hooks[event] = next;
-        }
-    }
-    if (!changed)
-        return false;
-    if (Object.keys(hooks).length === 0)
-        fs.rmSync(filePath, { force: true });
-    else
-        writeJsonAtomic(filePath, root);
-    return true;
-}
-function codexPluginSourcePath() {
-    return fileURLToPath(new URL('../codex-plugin/', import.meta.url));
-}
-function claudePluginSourcePath() {
-    return fileURLToPath(new URL('../skills/square/', import.meta.url));
-}
-function squareSkillSourcePath() {
-    return fileURLToPath(new URL('../skills/square/', import.meta.url));
-}
-function runClaudeCommand(homeDir, args) {
-    const result = spawnSync(process.env['SQUARE_CLAUDE_BIN'] || 'claude', args, {
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            HOME: homeDir,
-            CLAUDE_CONFIG_DIR: path.join(homeDir, '.claude'),
-        },
-        maxBuffer: 4 * 1024 * 1024,
-        timeout: 30_000,
-    });
-    if (result.error)
-        throw result.error;
-    return {
-        status: result.status ?? 1,
-        stdout: result.stdout || '',
-        stderr: result.stderr || '',
-    };
-}
-function runCodexCommand(homeDir, args) {
-    const result = spawnSync(process.env['SQUARE_CODEX_BIN'] || 'codex', args, {
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            HOME: homeDir,
-            CODEX_HOME: activeCodexHome(homeDir),
-        },
-        maxBuffer: 4 * 1024 * 1024,
-        timeout: 30_000,
-    });
-    if (result.error)
-        throw result.error;
-    return {
-        status: result.status ?? 1,
-        stdout: result.stdout || '',
-        stderr: result.stderr || '',
-    };
-}
-function requireCodexSuccess(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}`);
-}
-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 expectedPluginHooks(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';
-}
-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: activeCodexHome(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)
-                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 failForMessage = (message) => {
-            if (!message.error)
-                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 requestHooks = (id) => send({ id, method: 'hooks/list', params: { cwds: [process.cwd()] } });
-        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', (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;
-                let message;
-                try {
-                    message = JSON.parse(line);
-                }
-                catch {
-                    finish(new Error(`Codex hooks API returned invalid JSON: ${line}`));
-                    return;
-                }
-                if (failForMessage(message))
-                    return;
-                if (message.id === 0) {
-                    send({ method: 'initialized', params: {} });
-                    requestHooks(1);
-                    continue;
-                }
-                if (message.id === 1) {
-                    let hooks;
-                    try {
-                        hooks = pluginHooksFromList(message.result);
-                    }
-                    catch (error) {
-                        finish(error instanceof Error ? error : new Error(String(error)));
-                        return;
-                    }
-                    if (!trust) {
-                        finish(undefined, hooks);
-                        return;
-                    }
-                    if (!expectedPluginHooks(hooks)) {
-                        finish(new Error(`Codex discovered an unexpected hook set for ${CODEX_PLUGIN_ID}.`));
-                        return;
-                    }
-                    const updates = Object.fromEntries(hooks.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]));
-                    send({
-                        id: 2,
-                        method: 'config/batchWrite',
-                        params: {
-                            edits: [{ keyPath: 'hooks.state', value: updates, mergeStrategy: 'upsert' }],
-                            reloadUserConfig: true,
-                        },
-                    });
-                    continue;
-                }
-                if (message.id === 2) {
-                    requestHooks(3);
-                    continue;
-                }
-                if (message.id === 3) {
-                    try {
-                        finish(undefined, pluginHooksFromList(message.result));
-                    }
-                    catch (error) {
-                        finish(error instanceof Error ? error : new Error(String(error)));
-                    }
-                }
-            }
-        });
-        child.on('exit', (code) => {
-            if (!settled) {
-                finish(new Error(`Codex hooks API exited ${code ?? 'without status'}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
-            }
-        });
-        send({
-            id: 0,
-            method: 'initialize',
-            params: {
-                clientInfo: {
-                    name: SQUARE_IDENTITY.clientName,
-                    title: SQUARE_IDENTITY.productName,
-                    version: SQUARE_IDENTITY.packageVersion,
-                },
-            },
-        });
-    });
-}
-function claudeMarketplaceDocument() {
-    return {
-        name: CLAUDE_MARKETPLACE_NAME,
-        description: `${SQUARE_IDENTITY.productName} harness integrations`,
-        owner: { name: SQUARE_IDENTITY.productName },
-        plugins: [
-            {
-                name: SQUARE_IDENTITY.pluginName,
-                description: `Native Claude Code turn-boundary delivery for ${SQUARE_IDENTITY.productName}`,
-                source: './plugins/square',
-            },
-        ],
-    };
-}
-function marketplaceDocument() {
-    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 stageClaudePlugin(homeDir) {
-    const marketplaceRoot = path.join(homeDir, '.square', 'claude', 'marketplace');
-    const stage = `${marketplaceRoot}.${process.pid}.${Date.now()}.stage`;
-    const pluginRoot = path.join(stage, 'plugins', 'square');
-    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
-    fs.rmSync(stage, { recursive: true, force: true });
-    try {
-        fs.cpSync(claudePluginSourcePath(), pluginRoot, { recursive: true });
-        writeJsonAtomic(path.join(stage, '.claude-plugin', 'marketplace.json'), claudeMarketplaceDocument());
-        fs.rmSync(marketplaceRoot, { recursive: true, force: true });
-        fs.renameSync(stage, marketplaceRoot);
-    }
-    catch (error) {
-        fs.rmSync(stage, { recursive: true, force: true });
-        throw error;
-    }
-    return { marketplaceRoot, pluginRoot: path.join(marketplaceRoot, 'plugins', 'square') };
-}
-function stageCodexPlugin(homeDir) {
-    const marketplaceRoot = codexMarketplaceRoot(homeDir);
-    const parent = path.dirname(marketplaceRoot);
-    const stage = `${marketplaceRoot}.${process.pid}.${Date.now()}.stage`;
-    const pluginRoot = path.join(stage, 'plugins', 'square');
-    fs.mkdirSync(parent, { recursive: true });
-    fs.rmSync(stage, { recursive: true, force: true });
+import { doctorDeliveryHealth } from './delivery-health.js';
+import { CLAUDE_MARKETPLACE_NAME, CLAUDE_PLUGIN_ID, claudeHarness, doctorClaudePlugin, installClaudePlugin, uninstallClaudePlugin, } from './harness-claude.js';
+import { CODEX_HOOK_COMMAND, CODEX_MARKETPLACE_NAME, CODEX_PLUGIN_ID, SQUARE_CODEX_MARKER, codexHarness, codexConfigPath, codexHomeHooksPath, codexMarketplaceRoot, codexPluginHooksPath, codexPluginRoot, doctorCodexPlugin, installCodexPlugin, inspectCodexPluginHooks, stripSquareCodexHooks, uninstallCodexPlugin, upsertTomlSectionKey, } from './harness-codex.js';
+import { doctorHarnessLinks, installHarnessLinks, opencodeExtensionLink, piExtensionLink, skillLinks, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
+export { CLAUDE_MARKETPLACE_NAME, CLAUDE_PLUGIN_ID, CODEX_HOOK_COMMAND, CODEX_MARKETPLACE_NAME, CODEX_PLUGIN_ID, SQUARE_CODEX_MARKER, codexConfigPath, codexHomeHooksPath, codexMarketplaceRoot, codexPluginHooksPath, codexPluginRoot, doctorClaudePlugin, doctorCodexPlugin, installClaudePlugin, installCodexPlugin, inspectCodexPluginHooks, stripSquareCodexHooks, uninstallClaudePlugin, uninstallCodexPlugin, upsertTomlSectionKey, };
+function result(lines, notes = []) {
+    return { lines, notes };
+}
+async function doctorHost(label, inspect) {
     try {
-        fs.cpSync(codexPluginSourcePath(), pluginRoot, { recursive: true });
-        const stagedSkill = path.join(pluginRoot, 'skills', 'square', 'SKILL.md');
-        fs.mkdirSync(path.dirname(stagedSkill), { recursive: true });
-        fs.copyFileSync(path.join(squareSkillSourcePath(), 'SKILL.md'), stagedSkill);
-        writeJsonAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), marketplaceDocument());
-        fs.rmSync(marketplaceRoot, { recursive: true, force: true });
-        fs.renameSync(stage, marketplaceRoot);
+        return result(await inspect());
     }
     catch (error) {
-        fs.rmSync(stage, { recursive: true, force: true });
-        throw error;
+        return result([`○ ${label} doctor unavailable (${error instanceof Error ? error.message : String(error)})`]);
     }
-    return { marketplaceRoot, pluginRoot: codexPluginRoot(homeDir) };
-}
-function pluginHooksInstalled(filePath) {
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return (Array.isArray(parsed.hooks?.UserPromptSubmit) &&
-        parsed.hooks.UserPromptSubmit.some(isSquareGroup) &&
-        Array.isArray(parsed.hooks?.Stop) &&
-        parsed.hooks.Stop.some(isSquareGroup));
 }
-/** Install the Square Claude plugin and retire the skill-directory-only install. */
-export function installClaudePlugin(homeDir, run = runClaudeCommand) {
-    const staged = stageClaudePlugin(homeDir);
-    requireCodexSuccess(run(homeDir, ['plugin', 'marketplace', 'add', staged.marketplaceRoot]), 'Claude marketplace install');
-    requireCodexSuccess(run(homeDir, ['plugin', 'install', CLAUDE_PLUGIN_ID]), 'Claude plugin install');
-    requireCodexSuccess(run(homeDir, ['plugin', 'update', CLAUDE_PLUGIN_ID]), 'Claude plugin update');
-    const legacySkill = path.join(homeDir, '.claude', 'skills', 'square');
-    if (lstatMaybeForHarness(legacySkill)?.isSymbolicLink())
-        fs.rmSync(legacySkill, { force: true });
-    return staged;
+function openCodeLinks(homeDir) {
+    return [opencodeExtensionLink(homeDir), ...skillLinks(homeDir, ['.agents'])];
 }
-function lstatMaybeForHarness(target) {
-    try {
-        return fs.lstatSync(target);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    }
-}
-/** Install the Square Codex plugin and migrate away from direct home hook edits. */
-export async function installCodexPlugin(homeDir, run = runCodexCommand, hooksRuntime = inspectCodexPluginHooks) {
-    const configPath = codexConfigPath(homeDir);
-    const activeHooksPath = codexHomeHooksPath(homeDir);
-    const notes = [];
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    backupFile(configPath);
-    backupFile(activeHooksPath);
-    const configText = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
-    const normalizedConfig = configText === '' || configText.endsWith('\n') ? configText : `${configText}\n`;
-    const nextConfig = upsertTomlSectionKey(configText, 'features', 'hooks', 'true');
-    if (nextConfig !== normalizedConfig)
-        writeTextAtomic(configPath, nextConfig);
-    const staged = stageCodexPlugin(homeDir);
-    const marketplace = run(homeDir, [
-        'plugin',
-        'marketplace',
-        'add',
-        staged.marketplaceRoot,
-        '--json',
-    ]);
-    requireCodexSuccess(marketplace, 'marketplace install');
-    const installed = run(homeDir, ['plugin', 'add', CODEX_PLUGIN_ID, '--json']);
-    requireCodexSuccess(installed, 'plugin install');
-    let installedPath;
+function readableSquarePath(squarePath) {
+    if (squarePath === undefined)
+        return false;
     try {
-        const result = JSON.parse(installed.stdout);
-        if (typeof result.installedPath === 'string')
-            installedPath = result.installedPath;
+        return fs.statSync(squarePath).isFile() && (fs.accessSync(squarePath, fs.constants.R_OK), true);
     }
     catch {
-        notes.push('Codex installed the plugin but returned non-JSON output.');
-    }
-    const runtimeHooks = await hooksRuntime(homeDir, true);
-    if (!expectedPluginHooks(runtimeHooks)) {
-        throw new Error(`Codex did not discover both Square plugin hooks for ${CODEX_PLUGIN_ID}.`);
-    }
-    const untrusted = runtimeHooks.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(', ')}`);
-    }
-    try {
-        if (stripSquareCodexHooks(activeHooksPath))
-            notes.push(`Removed legacy Square handlers from ${activeHooksPath}.`);
-    }
-    catch (error) {
-        notes.push(`Legacy hooks were left untouched: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    fs.rmSync(legacyManagedHooksPath(homeDir), { force: true });
-    return {
-        configPath,
-        marketplaceRoot: staged.marketplaceRoot,
-        pluginRoot: staged.pluginRoot,
-        ...(installedPath ? { installedPath } : {}),
-        notes,
-    };
-}
-export function uninstallCodexPlugin(homeDir, run = runCodexCommand) {
-    const notes = [];
-    const removed = run(homeDir, ['plugin', 'remove', CODEX_PLUGIN_ID, '--json']);
-    requireCodexSuccess(removed, 'plugin removal');
-    const marketplace = run(homeDir, ['plugin', 'marketplace', 'remove', CODEX_MARKETPLACE_NAME, '--json']);
-    if (marketplace.status !== 0 && !marketplace.stderr.includes('is not configured or installed')) {
-        requireCodexSuccess(marketplace, 'marketplace removal');
-    }
-    const activeHooksPath = codexHomeHooksPath(homeDir);
-    if (stripSquareCodexHooks(activeHooksPath))
-        notes.push(`Removed legacy Square handlers from ${activeHooksPath}.`);
-    const marketplaceRoot = codexMarketplaceRoot(homeDir);
-    const managedHooksPath = legacyManagedHooksPath(homeDir);
-    fs.rmSync(marketplaceRoot, { recursive: true, force: true });
-    fs.rmSync(managedHooksPath, { force: true });
-    return { paths: [marketplaceRoot, activeHooksPath, managedHooksPath], notes };
-}
-export async function doctorCodexPlugin(homeDir, run = runCodexCommand, hooksRuntime = inspectCodexPluginHooks) {
-    const lines = [];
-    const configPath = codexConfigPath(homeDir);
-    const configText = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
-    const features = sectionRange(configText.split('\n'), 'features');
-    const hooksEnabled = features !== undefined &&
-        configText
-            .split('\n')
-            .slice(features.start + 1, features.end)
-            .some((line) => /^\s*hooks\s*=\s*true\s*(?:#.*)?$/.test(line));
-    lines.push(hooksEnabled ? `✓ features.hooks=true in ${configPath}` : `○ features.hooks missing in ${configPath}`);
-    const hooksPath = codexPluginHooksPath(homeDir);
-    if (!fs.existsSync(hooksPath)) {
-        lines.push(`○ Square plugin bundle missing ${codexPluginRoot(homeDir)}`);
-    }
-    else {
-        try {
-            lines.push(pluginHooksInstalled(hooksPath)
-                ? `✓ Square plugin hooks ${hooksPath}`
-                : `✕ Square plugin hooks incomplete ${hooksPath}`);
-        }
-        catch {
-            lines.push(`✕ invalid Square plugin hooks ${hooksPath}`);
-        }
-    }
-    const listed = run(homeDir, ['plugin', 'list', '--marketplace', CODEX_MARKETPLACE_NAME, '--json']);
-    if (listed.status !== 0) {
-        lines.push(`○ ${CODEX_PLUGIN_ID} unavailable (${listed.stderr.trim() || `exit ${listed.status}`})`);
-    }
-    else {
-        try {
-            const payload = JSON.parse(listed.stdout);
-            const plugin = payload.installed?.find((entry) => entry.pluginId === CODEX_PLUGIN_ID);
-            lines.push(plugin?.installed === true && plugin.enabled === true
-                ? `✓ ${CODEX_PLUGIN_ID} installed and enabled`
-                : `○ ${CODEX_PLUGIN_ID} is not installed and enabled`);
-        }
-        catch {
-            lines.push('✕ Codex returned invalid plugin inventory JSON');
-        }
-    }
-    try {
-        const runtimeHooks = await hooksRuntime(homeDir, false);
-        if (!expectedPluginHooks(runtimeHooks)) {
-            lines.push(`✕ Codex runtime did not discover both ${CODEX_PLUGIN_ID} hooks`);
-        }
-        else {
-            const untrusted = runtimeHooks.filter((hook) => hook.trustStatus !== 'trusted');
-            lines.push(untrusted.length === 0
-                ? `✓ ${CODEX_PLUGIN_ID} hooks trusted by Codex`
-                : `✕ ${untrusted.length} ${CODEX_PLUGIN_ID} hooks need trust`);
-        }
-    }
-    catch (error) {
-        lines.push(`✕ Codex hooks runtime unavailable (${error instanceof Error ? error.message : String(error)})`);
-    }
-    const activeHooksPath = codexHomeHooksPath(homeDir);
-    if (fs.existsSync(activeHooksPath)) {
-        try {
-            const parsed = JSON.parse(fs.readFileSync(activeHooksPath, 'utf8'));
-            const legacy = Object.values(parsed.hooks ?? {}).some((groups) => Array.isArray(groups) && groups.some(isSquareGroup));
-            if (legacy)
-                lines.push(`▲ legacy Square handlers still present in ${activeHooksPath}`);
-        }
-        catch {
-            lines.push(`✕ invalid hooks file ${activeHooksPath}`);
-        }
+        return false;
     }
-    return lines;
 }
+const TARGETS = [
+    {
+        name: 'skills',
+        capabilities: ['install', 'uninstall', 'doctor'],
+        install: ({ homeDir, force }) => result(installHarnessLinks(skillLinks(homeDir), force)),
+        uninstall: ({ homeDir }) => result(uninstallHarnessLinks(skillLinks(homeDir))),
+        doctor: ({ homeDir }) => result(doctorHarnessLinks(skillLinks(homeDir))),
+    },
+    {
+        name: 'claude',
+        capabilities: ['install', 'uninstall', 'doctor'],
+        async install({ homeDir }) {
+            const installed = await installClaudePlugin(homeDir);
+            return result([installed.marketplaceRoot, installed.pluginRoot]);
+        },
+        async uninstall({ homeDir }) {
+            const removed = await uninstallClaudePlugin(homeDir);
+            return result(removed.paths, removed.notes);
+        },
+        async doctor({ homeDir }) { return doctorHost('Claude', () => doctorClaudePlugin(homeDir)); },
+    },
+    {
+        name: 'codex',
+        capabilities: ['install', 'uninstall', 'doctor'],
+        async install({ homeDir }) {
+            const installed = await installCodexPlugin(homeDir);
+            const lines = [
+                installed.configPath,
+                installed.marketplaceRoot,
+                installed.pluginRoot,
+                installed.installedPath,
+            ].filter((line) => line !== undefined);
+            return result(lines, installed.notes);
+        },
+        async uninstall({ homeDir }) {
+            const removed = await uninstallCodexPlugin(homeDir);
+            return result(removed.paths, removed.notes);
+        },
+        async doctor({ homeDir }) { return doctorHost('Codex', () => doctorCodexPlugin(homeDir)); },
+    },
+    {
+        name: 'opencode',
+        capabilities: ['install', 'uninstall', 'doctor'],
+        install: ({ homeDir, force }) => result(installHarnessLinks(openCodeLinks(homeDir), force)),
+        uninstall: ({ homeDir }) => result(uninstallHarnessLinks(openCodeLinks(homeDir))),
+        doctor: ({ homeDir }) => result([...doctorHarnessLinks(openCodeLinks(homeDir)), verifyOpenCodeRuntime(homeDir)]),
+    },
+    {
+        name: 'pi',
+        capabilities: ['install', 'uninstall', 'doctor'],
+        install: ({ homeDir, force }) => result(installHarnessLinks([piExtensionLink(homeDir)], force)),
+        uninstall: ({ homeDir }) => result(uninstallHarnessLinks([piExtensionLink(homeDir)])),
+        doctor: ({ homeDir }) => result(doctorHarnessLinks([piExtensionLink(homeDir)])),
+    },
+    {
+        name: 'delivery',
+        capabilities: ['doctor'],
+        doctor: ({ squarePath }) => result(readableSquarePath(squarePath)
+            ? doctorDeliveryHealth(squarePath)
+            : ['○ delivery health skipped (no readable square path)']),
+    },
+];
+export function harnessTargets() {
+    return TARGETS;
+}
+export function requireHarnessCapability(target, action) {
+    const found = TARGETS.find((candidate) => candidate.name === target);
+    if (found === undefined || !found.capabilities.includes(action))
+        throw new Error(`Unsupported harness capability: ${action} ${target}`);
+    return found;
+}
+export async function executeHarnessTarget(targetName, action, context) {
+    const target = requireHarnessCapability(targetName, action);
+    const capability = target[action];
+    if (capability === undefined)
+        throw new Error(`Unsupported harness capability: ${action} ${targetName}`);
+    return capability(context);
+}
+export const harnessHosts = Object.freeze({ claude: claudeHarness, codex: codexHarness });