@astrosheep/square 0.3.4 → 0.3.5

package/dist/cli/square-commands.js

@@ -0,0 +1,221 @@
+import { cmdActivity } from '../activity.js';
+import { loadSquare } from '../artifact.js';
+import { cmdCompact } from '../compact.js';
+import { SquareError, formatHardCap, validateParticipantName, } from '../model.js';
+import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withJoinNextOutput, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
+import { createSquare, execute } from '../square-application.js';
+import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
+function parseBuild(argv) {
+    const options = { force: false };
+    for (let index = 0; index < argv.length; index++) {
+        const flag = argv[index];
+        switch (flag) {
+            case '--cap':
+                options.hardCap = parseHardCap(requireValue(argv, index, flag));
+                index += 1;
+                break;
+            case '--template':
+                options.template = requireValue(argv, index, flag);
+                index += 1;
+                break;
+            case '--throttle':
+            case '--throttle-per-minute':
+                options.throttlePerMinute = parsePositiveInteger(requireValue(argv, index, flag), flag);
+                index += 1;
+                break;
+            case '--force':
+            case '-f':
+                options.force = true;
+                break;
+            default:
+                fail(`Unknown build option: ${flag}`);
+        }
+    }
+    if (options.template !== undefined && !/^[a-zA-Z0-9-]+$/.test(options.template)) {
+        fail('Invalid template name: only letters, digits, and hyphens allowed.');
+    }
+    if (options.hardCap === undefined)
+        fail('Missing required build option: --cap must be a positive integer or -1.');
+    if (options.throttlePerMinute !== undefined && options.throttlePerMinute <= 0) {
+        fail('Invalid build option: --throttle must be a positive integer.');
+    }
+    const snippet = readStdinSync();
+    if (snippet.trim() === '')
+        fail('Missing Markdown body snippet on stdin.');
+    return { options: options, snippet };
+}
+export const buildCommand = {
+    parse: (argv) => parseBuild(argv),
+    async execute(intent, context) {
+        await createSquare(context.squarePath, intent.options, intent.snippet);
+        const cap = formatHardCap(intent.options.hardCap);
+        const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
+        return withPathOutput(context.squarePath, ['✓ built', `  · cap ${cap === '-1' ? 'unlimited' : cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseJoin(argv, context) {
+    let lastN = 10;
+    for (let index = 0; index < argv.length; index++) {
+        if (argv[index] === '--last') {
+            lastN = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
+            index += 1;
+        }
+        else if (argv[index] === '--all') {
+            lastN = null;
+        }
+        else {
+            usage(context.command);
+        }
+    }
+    return { name: requireParticipant(context.name), lastN };
+}
+export const joinCommand = {
+    parse: parseJoin,
+    async execute(intent, context) {
+        validateParticipantName(intent.name);
+        try {
+            const committed = await execute(context.squarePath, { type: 'join', name: intent.name, now: nowMs() });
+            const joinedName = committed.result.joinedName;
+            const isRejoin = !committed.result.addParticipant;
+            const after = loadSquare(context.squarePath);
+            const preamble = after.preamble.at(-1) === '---' ? after.preamble.slice(0, -1) : after.preamble;
+            recordLocalJoin(joinedName, context.squarePath);
+            const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
+            const contextText = preamble.join('\n').trim();
+            const fallback = hasAutomaticDeliveryIdentity()
+                ? []
+                : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
+            const output = [
+                `● ${joinedName} stepped into the square`,
+                ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
+                ...(activities === '' ? [] : ['', 'recent activity', activities]),
+                ...(isRejoin ? [] : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} warmup`]),
+                ...fallback,
+            ].join('\n');
+            return withJoinNextOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
+        }
+        catch (error) {
+            if (!(error instanceof SquareError) || error.code !== 'conflict')
+                throw error;
+            const doc = loadSquare(context.squarePath);
+            const joinedName = resolveRosterName(doc, intent.name);
+            if (joinedName === undefined || !isCurrentlyJoined(doc.acts, joinedName))
+                throw error;
+            recordLocalJoin(joinedName, context.squarePath);
+            const fallback = hasAutomaticDeliveryIdentity()
+                ? ''
+                : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
+            return withJoinNextOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
+        }
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseActivity(argv, context) {
+    let force = false;
+    let noWait = false;
+    let beside;
+    let bell = false;
+    const bodyArgs = [];
+    for (let index = 0; index < argv.length; index++) {
+        const argument = argv[index];
+        if (argument === '-f' || argument === '--force')
+            force = true;
+        else if (argument === '--no-wait')
+            noWait = true;
+        else if (argument === '--beside') {
+            beside = requireValue(argv, index, argument);
+            index += 1;
+        }
+        else if (argument === '--bell')
+            bell = true;
+        else
+            bodyArgs.push(argument);
+    }
+    if (bell && beside !== undefined)
+        fail('Invalid act options: --beside and --bell are mutually exclusive.');
+    const reach = bell ? 'bell' : beside === undefined ? undefined : { beside };
+    if (bodyArgs.length !== 1) {
+        if (bodyArgs.length === 0) {
+            const piped = readPipedBodyFallback();
+            if (piped !== undefined)
+                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach };
+        }
+        fail("act requires a body argument (a quoted string or '-' with piped stdin)");
+    }
+    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach };
+}
+export const actCommand = {
+    parse: parseActivity,
+    async execute(intent, context) {
+        const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
+        await cmdActivity(context.squarePath, intent.name, intent.activity, resolveBody, {
+            force: intent.force,
+            noWait: intent.noWait,
+            reach: intent.reach,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} act --force${reachArg} -`,
+        });
+    },
+    present: () => { },
+};
+function parseDone(argv, context) {
+    if (argv.length > 1)
+        usage(context.command);
+    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : readPipedBodyFallback() };
+}
+export const doneCommand = {
+    parse: parseDone,
+    async execute(intent, context) {
+        const body = resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim();
+        const committed = await execute(context.squarePath, { type: 'done', name: intent.name, body, now: nowMs() });
+        const name = committed.acts[0].act.actor;
+        recordLocalDone(name, context.squarePath);
+        return withPathOutput(context.squarePath, `× ${name} steps out of the square — done · just now`, { participantCount: inSquareCount(loadSquare(context.squarePath)) });
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseHold(argv, context) {
+    if (argv.length > 1)
+        usage(context.command);
+    return { name: requireParticipant(context.name), body: argv[0] };
+}
+export const holdCommand = {
+    parse: parseHold,
+    async execute(intent, context) {
+        const committed = await execute(context.squarePath, { type: 'hold', actor: intent.name, body: resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim(), now: nowMs() });
+        const doc = loadSquare(context.squarePath);
+        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0].act), { participantCount: inSquareCount(doc), held: true });
+    },
+    present: (result) => process.stdout.write(result),
+};
+export const resumeCommand = {
+    parse(argv, context) {
+        if (argv.length !== 0)
+            usage(context.command);
+        return { name: requireParticipant(context.name) };
+    },
+    async execute(intent, context) {
+        const committed = await execute(context.squarePath, { type: 'resume', actor: intent.name, now: nowMs() });
+        const doc = loadSquare(context.squarePath);
+        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0].act), { participantCount: inSquareCount(doc) });
+    },
+    present: (result) => process.stdout.write(result),
+};
+export const compactCommand = {
+    parse(argv, context) {
+        let keep = 50;
+        for (let index = 0; index < argv.length; index++) {
+            if (argv[index] !== '--keep')
+                usage(context.command);
+            keep = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
+            index += 1;
+        }
+        return { keep };
+    },
+    async execute(intent, context) {
+        await cmdCompact(context.squarePath, intent);
+    },
+    present: () => { },
+};

package/dist/compact.js

@@ -1,9 +1,6 @@
-import fs from 'node:fs';
-import { loadSquare, renderArtifactAct } from './artifact.js';
 import { SquareError } from './model.js';
 import { withPathOutput } from './presentation.js';
-import { withSquareLock, writeSquareDoc } from './runtime.js';
-import { coreCompact } from './decisions.js';
+import { execute } from './square-application.js';
 function sidecarPath(squarePath) {
     return squarePath.replace(/\.md$/, '') + '.archive.md';
 }
@@ -12,20 +9,10 @@ export async function cmdCompact(squarePath, opts) {
         let archivedCount;
         let keptCount;
         const archive = sidecarPath(squarePath);
-        await withSquareLock(squarePath, () => {
-            const doc = loadSquare(squarePath);
-            const result = coreCompact(doc, opts.keep);
-            archivedCount = result.archived.length;
-            keptCount = result.doc.acts.length;
-            if (archivedCount > 0) {
-                const sidecarExists = fs.existsSync(archive);
-                const block = result.archived
-                    .map((act, index) => renderArtifactAct(act, { first: !sidecarExists && index === 0 }))
-                    .join('\n');
-                fs.appendFileSync(archive, block + '\n');
-                writeSquareDoc(squarePath, result.doc);
-            }
-        });
+        const committed = await execute(squarePath, { type: 'compact', keep: opts.keep, archivePath: archive });
+        const result = committed.result;
+        archivedCount = result.archived.length;
+        keptCount = result.doc.acts.length;
         const summary = ['✓ compacted', `  · archived ${archivedCount} acts`, `  · kept ${keptCount} acts`, ...(archivedCount > 0 ? [`  · sidecar ${archive}`] : [])].join('\n');
         process.stdout.write(withPathOutput(squarePath, summary));
     }

package/dist/harness-claude.js

@@ -0,0 +1,275 @@
+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';
+export const CLAUDE_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
+export const CLAUDE_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
+export function claudeMarketplaceRoot(homeDir) {
+    return path.join(homeDir, '.square', 'claude', 'marketplaces', CLAUDE_MARKETPLACE_NAME);
+}
+function packageAssets(relative) {
+    return fileURLToPath(new URL(relative, 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 requireSuccess(result, operation) {
+    if (result.status === 0)
+        return;
+    throw new Error(`Claude ${operation} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
+}
+function writeJsonAtomic(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, filePath);
+}
+function stageClaudeBundle(homeDir, marketplaceRoot) {
+    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+    const stage = `${marketplaceRoot}.${token}.stage`;
+    const backup = `${marketplaceRoot}.${token}.previous`;
+    const pluginRoot = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
+    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
+    try {
+        fs.cpSync(packageAssets('../skills/square/'), pluginRoot, { recursive: true });
+        writeJsonAtomic(path.join(stage, '.claude-plugin', 'marketplace.json'), {
+            name: CLAUDE_MARKETPLACE_NAME,
+            description: `${SQUARE_IDENTITY.productName} harness integrations`,
+            owner: { name: SQUARE_IDENTITY.productName },
+            plugins: [{ name: SQUARE_IDENTITY.pluginName, description: `Native Claude Code delivery for ${SQUARE_IDENTITY.productName}`, source: './plugins/square' }],
+        });
+        if (fs.existsSync(marketplaceRoot))
+            fs.renameSync(marketplaceRoot, backup);
+        fs.renameSync(stage, marketplaceRoot);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(stage, { recursive: true, force: true });
+        }
+        catch { }
+        if (fs.existsSync(backup) && !fs.existsSync(marketplaceRoot))
+            fs.renameSync(backup, marketplaceRoot);
+        throw error;
+    }
+    return {
+        desired: { marketplaceName: CLAUDE_MARKETPLACE_NAME, marketplaceRoot, pluginId: CLAUDE_PLUGIN_ID },
+        rollback() {
+            fs.rmSync(marketplaceRoot, { recursive: true, force: true });
+            if (fs.existsSync(backup))
+                fs.renameSync(backup, marketplaceRoot);
+        },
+        finalize() { fs.rmSync(backup, { recursive: true, force: true }); },
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+function isManagedSource(managedRoot, source) {
+    const relative = path.relative(path.resolve(managedRoot), path.resolve(source));
+    return relative === '' || (relative !== '..' &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+function isCurrentManagedMarketplace(marketplace, managedRoot) {
+    return marketplace.name === CLAUDE_MARKETPLACE_NAME &&
+        marketplace.local &&
+        isManagedSource(managedRoot, marketplace.source);
+}
+function parseClaudeMarketplaceRegistration(value) {
+    if (!isRecord(value)) {
+        throw new Error('Claude marketplace inventory entry is invalid.');
+    }
+    const name = value.name;
+    const source = value.source;
+    const installLocation = value.installLocation;
+    if (typeof name !== 'string' ||
+        typeof source !== 'string' ||
+        typeof installLocation !== 'string') {
+        throw new Error('Claude marketplace inventory entry is malformed.');
+    }
+    if (source === 'directory') {
+        const sourcePath = value.path;
+        if (typeof sourcePath !== 'string') {
+            throw new Error('Claude directory marketplace entry is malformed.');
+        }
+        return { name, source: sourcePath, local: true };
+    }
+    const stableSource = typeof value.repo === 'string' ? value.repo : name;
+    return { name, source: `${source}:${stableSource}`, local: false };
+}
+function parseInventory(stdout) {
+    try {
+        const payload = JSON.parse(stdout);
+        if (!Array.isArray(payload)) {
+            throw new Error('Claude marketplace inventory must be a JSON array.');
+        }
+        const marketplaces = payload.map(parseClaudeMarketplaceRegistration);
+        return { marketplaces };
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+function parseClaudePluginInventory(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        throw new Error('Claude plugin inventory returned invalid JSON.');
+    }
+}
+function isVerifiedClaudePlugin(entry) {
+    if (!isRecord(entry))
+        return false;
+    return entry.id === CLAUDE_PLUGIN_ID &&
+        entry.enabled === true &&
+        entry.version === SQUARE_IDENTITY.packageVersion;
+}
+function claudeProtocol(run) {
+    return {
+        host: 'claude',
+        marketplaceName: CLAUDE_MARKETPLACE_NAME,
+        pluginId: CLAUDE_PLUGIN_ID,
+        managedRoot: (homeDir) => path.join(homeDir, '.square', 'claude'),
+        stageBundle: stageClaudeBundle,
+        inspectInventory(homeDir) {
+            const result = run(homeDir, ['plugin', 'marketplace', 'list', '--json']);
+            requireSuccess(result, 'marketplace inventory');
+            return parseInventory(result.stdout);
+        },
+        registerMarketplace(homeDir, desired) {
+            const result = run(homeDir, ['plugin', 'marketplace', 'add', desired.marketplaceRoot]);
+            requireSuccess(result, 'marketplace install');
+        },
+        installOrUpdate(homeDir, desired) {
+            requireSuccess(run(homeDir, ['plugin', 'install', desired.pluginId]), 'plugin install');
+            requireSuccess(run(homeDir, ['plugin', 'update', desired.pluginId]), 'plugin update');
+        },
+        verifyPluginAndHooks(homeDir, desired) {
+            const hooksPath = path.join(desired.marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName, 'hooks', 'hooks.json');
+            if (!fs.existsSync(hooksPath)) {
+                throw new Error(`Claude plugin hooks missing from ${desired.marketplaceRoot}`);
+            }
+            const listed = run(homeDir, ['plugin', 'list', '--json']);
+            requireSuccess(listed, 'plugin inventory');
+            const plugins = parseClaudePluginInventory(listed.stdout);
+            if (!plugins.some(isVerifiedClaudePlugin)) {
+                throw new Error(`Claude did not verify ${CLAUDE_PLUGIN_ID} as installed and enabled.`);
+            }
+        },
+        removePlugin(homeDir, pluginId) {
+            const result = run(homeDir, ['plugin', 'remove', pluginId]);
+            const isMissing = result.stderr.includes('is not configured or installed');
+            if (result.status !== 0 && !isMissing) {
+                requireSuccess(result, 'plugin removal');
+            }
+        },
+        removeMarketplace(homeDir, marketplaceName) {
+            const result = run(homeDir, ['plugin', 'marketplace', 'remove', marketplaceName]);
+            const isMissing = result.stderr.includes('is not configured or installed');
+            if (result.status !== 0 && !isMissing) {
+                requireSuccess(result, 'marketplace removal');
+            }
+        },
+        removeManagedSource(source) {
+            fs.rmSync(source, { recursive: true, force: true });
+        },
+        retireDirectDelivery(homeDir) {
+            const legacySkill = path.join(homeDir, '.claude', 'skills', 'square');
+            try {
+                if (fs.lstatSync(legacySkill).isSymbolicLink()) {
+                    fs.rmSync(legacySkill, { force: true });
+                }
+            }
+            catch { }
+        },
+        removeManagedRoot(homeDir) {
+            fs.rmSync(path.join(homeDir, '.square', 'claude'), { recursive: true, force: true });
+        },
+    };
+}
+export async function installClaudePlugin(homeDir, run = runClaudeCommand) {
+    const protocol = claudeProtocol(run);
+    const inventory = await reconcileInstall(homeDir, protocol);
+    const managedRoot = protocol.managedRoot(homeDir);
+    const marketplaceRoot = inventory.marketplaces.find((entry) => isCurrentManagedMarketplace(entry, managedRoot))?.source ?? claudeMarketplaceRoot(homeDir);
+    const pluginRoot = path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
+    return { marketplaceRoot, pluginRoot };
+}
+export async function uninstallClaudePlugin(homeDir, run = runClaudeCommand) {
+    const base = claudeProtocol(run);
+    const protocol = {
+        ...base,
+        async inspectInventory(currentHome) {
+            const inventory = await base.inspectInventory(currentHome);
+            const managedRoot = base.managedRoot(currentHome);
+            const hasManagedMarketplace = inventory.marketplaces.some((entry) => entry.local && isManagedSource(managedRoot, entry.source));
+            if (hasManagedMarketplace)
+                return inventory;
+            const fallback = {
+                name: CLAUDE_MARKETPLACE_NAME,
+                source: claudeMarketplaceRoot(currentHome),
+                local: true,
+                pluginIds: [CLAUDE_PLUGIN_ID],
+            };
+            return { marketplaces: [...inventory.marketplaces, fallback] };
+        },
+    };
+    await reconcileUninstall(homeDir, protocol);
+    return { paths: [claudeMarketplaceRoot(homeDir)], notes: [] };
+}
+export async function doctorClaudePlugin(homeDir, run = runClaudeCommand) {
+    const protocol = claudeProtocol(run);
+    const inventory = await protocol.inspectInventory(homeDir);
+    const managedRoot = protocol.managedRoot(homeDir);
+    const current = inventory.marketplaces.find((entry) => isCurrentManagedMarketplace(entry, managedRoot));
+    const root = current?.source ?? claudeMarketplaceRoot(homeDir);
+    const desired = {
+        marketplaceName: CLAUDE_MARKETPLACE_NAME,
+        marketplaceRoot: root,
+        pluginId: CLAUDE_PLUGIN_ID,
+    };
+    const stale = staleManagedRegistrations(inventory, managedRoot, desired);
+    let pluginStatus;
+    const listed = run(homeDir, ['plugin', 'list', '--json']);
+    if (listed.status !== 0) {
+        pluginStatus = `○ ${CLAUDE_PLUGIN_ID} plugin inventory unavailable`;
+    }
+    else {
+        try {
+            const plugins = parseClaudePluginInventory(listed.stdout);
+            const valid = plugins.some(isVerifiedClaudePlugin);
+            pluginStatus = valid
+                ? `✓ ${CLAUDE_PLUGIN_ID} installed, enabled, and version ${SQUARE_IDENTITY.packageVersion}`
+                : `○ ${CLAUDE_PLUGIN_ID} is not installed, enabled, and version ${SQUARE_IDENTITY.packageVersion}`;
+        }
+        catch {
+            pluginStatus = `○ ${CLAUDE_PLUGIN_ID} plugin inventory unavailable`;
+        }
+    }
+    const bundlePath = path.join(root, 'plugins', SQUARE_IDENTITY.pluginName);
+    const bundleStatus = fs.existsSync(bundlePath)
+        ? `✓ Square Claude plugin bundle ${root}`
+        : `○ Square Claude plugin bundle missing ${root}`;
+    const marketplaceStatus = current !== undefined
+        ? `✓ ${CLAUDE_PLUGIN_ID} marketplace registered`
+        : `○ ${CLAUDE_PLUGIN_ID} marketplace is not registered`;
+    return [
+        bundleStatus,
+        marketplaceStatus,
+        pluginStatus,
+        ...(stale.length === 0 ? [] : [`✕ ${stale.length} stale Square marketplace registration(s)`]),
+    ];
+}
+export const claudeHarness = Object.freeze({ install: installClaudePlugin, uninstall: uninstallClaudePlugin, doctor: doctorClaudePlugin });