@uluops/setup 0.2.0 → 0.6.0

package/dist/commands/helpers.js

@@ -0,0 +1,274 @@
+import chalk from "chalk";
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+import { detect } from "../steps/detect.js";
+import { signup } from "../steps/signup.js";
+import { resolveApiKey } from "../steps/auth.js";
+import { installMcp } from "../steps/mcp.js";
+import { installAgents } from "../steps/agents.js";
+import { installCommands } from "../steps/commands.js";
+import { installMetrics } from "../steps/metrics.js";
+import { installCli, CLI_PACKAGE } from "../steps/cli.js";
+import { writeShellExport } from "../steps/shell.js";
+import { probeHookSupport } from "../lib/settings-merger.js";
+import { findProjectRoot, ASSETS_DIR } from "../lib/paths.js";
+import { getHealthTimeout } from "../lib/health.js";
+import { ok, warn, fail, info } from "../lib/display.js";
+/** Resolve API key via flag, env, file, signup, or interactive prompt. Returns env detection + key. */
+export async function initContext(opts) {
+    const env = await detect();
+    let apiKey;
+    try {
+        if (opts.signup) {
+            info("Create your UluOps account\n");
+            const auth = await signup();
+            apiKey = auth.apiKey;
+            ok(`Account created (${auth.email})`);
+            ok(`API key generated`);
+        }
+        else {
+            const auth = await resolveApiKey({
+                apiKeyFlag: opts.apiKey,
+                skipValidation: opts.skipValidation,
+                interactive: !opts.yes && !opts.apiKey && !process.env["ULUOPS_API_KEY"],
+            });
+            apiKey = auth.apiKey;
+            if (auth.email)
+                ok(`Key validated (${auth.email})`);
+            else if (opts.skipValidation)
+                ok("Key accepted (validation skipped)");
+            else
+                ok("Key validated");
+        }
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    return { env, apiKey };
+}
+/** Write MCP server entries to harness config and report warnings. */
+export async function configureMcpStep(profile, apiKey, opts) {
+    const res = await installMcp(profile, apiKey, opts.scope, opts.dryRun);
+    ok(`MCP config → ${res.configPath} (2 servers)`);
+    for (const w of res.packageWarnings)
+        warn(w);
+    return res;
+}
+/** Copy agent definitions from assets to harness directory. */
+export async function installAgentsDefs(profile, opts, prev) {
+    const res = await installAgents(profile, opts.localDefs, opts.dryRun, prev);
+    const parts = [];
+    if (res.copied > 0)
+        parts.push(`${res.copied} copied`);
+    if (res.skipped > 0)
+        parts.push(`${res.skipped} unchanged`);
+    if (res.removed > 0)
+        parts.push(`${res.removed} removed`);
+    const dest = opts.localDefs
+        ? "./uluops/agents/"
+        : `${profile.paths.agentsDir.replace(process.env["HOME"] ?? "", "~")}/`;
+    ok(`${res.files.length} agents → ${dest}${parts.length ? ` (${parts.join(", ")})` : ""}`);
+    return res;
+}
+/** Copy slash-command definitions from assets (Claude Code only). */
+export async function installCommandsDefs(profile, opts, prev) {
+    const res = await installCommands(profile, opts.localDefs, opts.dryRun, prev);
+    if (res.skippedReason === "not-supported") {
+        info(chalk.dim(`Commands not yet supported for ${profile.displayName} (coming soon)`));
+        return res;
+    }
+    const total = res.agentCommands + res.workflowCommands + res.pipelineCommands;
+    const parts = [];
+    if (total > 0)
+        parts.push(`${total} copied`);
+    if (res.skipped > 0)
+        parts.push(`${res.skipped} unchanged`);
+    if (res.removed > 0)
+        parts.push(`${res.removed} removed`);
+    const dest = opts.localDefs
+        ? "./uluops/commands/"
+        : `${profile.paths.commandsDir.replace(process.env["HOME"] ?? "", "~")}/`;
+    ok(`${res.files.length} commands → ${dest}${parts.length ? ` (${parts.join(", ")})` : ""}`);
+    return res;
+}
+/** Install agent-metrics hook and tool files (Claude Code only). */
+export async function configureMetricsStep(profile, opts) {
+    if (!profile.hooks) {
+        info(chalk.dim(`Metrics hooks not supported for ${profile.displayName}`));
+        return { toolFilesCopied: 0, hookConfigured: false, hooksInstalledVersion: null };
+    }
+    const probe = probeHookSupport();
+    if (probe.warning)
+        warn(probe.warning);
+    const res = await installMetrics(profile, opts.dryRun);
+    if (res.hookConfigured) {
+        const parts = [];
+        if (res.toolFilesCopied > 0)
+            parts.push(`${res.toolFilesCopied} files`);
+        parts.push("hook configured");
+        const toolPath = profile.paths.toolsDir?.replace(process.env["HOME"] ?? "", "~");
+        ok(`Agent metrics → ${toolPath}/ (${parts.join(", ")})`);
+    }
+    else {
+        warn("Agent metrics hook not configured (tool files not found)");
+    }
+    return res;
+}
+/**
+ * Decide whether to install `@uluops/cli` globally and do it (or not).
+ *
+ * Decision matrix:
+ * - `--no-cli` (opts.cli === false) → skip, no prompt
+ * - `--with-cli` (opts.withCli === true) → install, no prompt
+ * - Neither flag + non-interactive (--yes / --api-key / no TTY) → skip
+ * - Neither flag + interactive → prompt (default Y)
+ *
+ * Returns null when the step did not run (skipped). Returns a `CliInstallResult`
+ * when an install attempt was made, with details for the manifest.
+ */
+export async function configureCliStep(opts) {
+    if (opts.cli === false) {
+        info(chalk.dim(`Skipped global ${CLI_PACKAGE} install (--no-cli)`));
+        return null;
+    }
+    let shouldInstall;
+    if (opts.withCli === true) {
+        shouldInstall = true;
+    }
+    else {
+        const nonInteractive = opts.yes || !!opts.apiKey || !process.stdin.isTTY;
+        if (nonInteractive) {
+            info(chalk.dim(`Skipped global ${CLI_PACKAGE} install (non-interactive — pass --with-cli to install)`));
+            return null;
+        }
+        const { confirm } = await import("@inquirer/prompts");
+        shouldInstall = await confirm({
+            message: `Install ${CLI_PACKAGE} globally (provides the ${chalk.cyan("ulu")} command)?`,
+            default: true,
+        });
+        if (!shouldInstall) {
+            info(chalk.dim(`Skipped global ${CLI_PACKAGE} install`));
+            return null;
+        }
+    }
+    const res = await installCli({
+        dryRun: opts.dryRun,
+        executor: opts.executor,
+    });
+    if (opts.dryRun && !res.alreadyPresent) {
+        ok(`Would install ${CLI_PACKAGE} globally`);
+        return res;
+    }
+    if (res.alreadyPresent) {
+        ok(`${CLI_PACKAGE} already installed${res.version ? ` (${res.version})` : ""} — no change`);
+        return res;
+    }
+    if (res.installed) {
+        ok(`${CLI_PACKAGE} installed globally${res.version ? ` (${res.version})` : ""}`);
+        return res;
+    }
+    warn(`Could not install ${CLI_PACKAGE} globally — try ${chalk.cyan(`npm install -g ${CLI_PACKAGE}`)} manually`);
+    if (res.error) {
+        const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+        if (oneLine)
+            info(chalk.dim(`  ${oneLine}`));
+    }
+    return res;
+}
+/** Ping tracker and registry health endpoints. */
+export async function runHealthCheck(opts) {
+    if (!opts.skipValidation && !opts.dryRun) {
+        try {
+            const [trackerOk, registryOk] = await Promise.all([
+                checkEndpoint("https://api.uluops.ai/api/v1/health"),
+                checkEndpoint("https://api.uluops.ai/api/v1/registry/health"),
+            ]);
+            if (trackerOk && registryOk)
+                ok("Health check passed — both APIs reachable");
+            else
+                warn("Some APIs unreachable (MCP tools may have limited functionality)");
+        }
+        catch {
+            warn("Health check skipped (network issue)");
+        }
+    }
+}
+/** Optionally write ULUOPS_API_KEY export to shell profile. */
+export async function configureShell(env, apiKey, opts) {
+    let modified = false;
+    if (opts.shell && env.shellProfile) {
+        if (!opts.yes && !opts.dryRun) {
+            const confirmed = await confirmShellWrite(env.shellProfile);
+            if (!confirmed) {
+                warn("Skipped writing API key to shell profile");
+                return false;
+            }
+        }
+        await writeShellExport(env.shellProfile, apiKey, opts.dryRun);
+        ok(`ULUOPS_API_KEY added to ${env.shellProfile}`);
+        warn("API key stored in plaintext in shell profile. Consider rotating if shared machine.");
+        modified = true;
+    }
+    else if (opts.shell) {
+        warn("--shell requested but no supported shell detected ($SHELL). Skipping.");
+    }
+    return modified;
+}
+/** Interactive y/N confirmation before writing API key to shell profile. */
+export async function confirmShellWrite(profilePath) {
+    const readline = await import("node:readline/promises");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question(`Write ULUOPS_API_KEY to ${profilePath}? (y/N) `);
+    rl.close();
+    return answer.trim().toLowerCase() === "y";
+}
+/** Warn if existing agent files will be overwritten and prompt for confirmation. */
+export async function checkConflicts(profile, localDefs) {
+    const destDir = localDefs
+        ? join(await findProjectRoot(), "uluops", "agents")
+        : profile.paths.agentsDir;
+    const srcDir = join(ASSETS_DIR, profile.name, "agents");
+    let existingFiles;
+    let assetFiles;
+    try {
+        existingFiles = await readdir(destDir);
+        assetFiles = await readdir(srcDir);
+    }
+    catch {
+        return;
+    }
+    const conflicts = assetFiles.filter((f) => existingFiles.includes(f));
+    if (conflicts.length === 0)
+        return;
+    warn(`Found ${conflicts.length} existing agents that match UluOps definitions:`);
+    for (const f of conflicts.slice(0, 5)) {
+        info(`  ${f}`);
+    }
+    if (conflicts.length > 5) {
+        info(`  ... and ${conflicts.length - 5} more`);
+    }
+    console.log();
+    info("These will be overwritten.");
+    console.log();
+    const { confirm } = await import("@inquirer/prompts");
+    const proceed = await confirm({ message: "Continue?", default: true });
+    if (!proceed) {
+        process.exit(0);
+    }
+}
+/** Fetch a URL and return true if the response is OK, false on any failure. */
+async function checkEndpoint(url) {
+    try {
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(getHealthTimeout()),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,13 @@
+export declare function runSetup(opts: {
+    apiKey?: string;
+    signup: boolean;
+    scope: "global" | "local";
+    localDefs: boolean;
+    shell: boolean;
+    skipValidation: boolean;
+    dryRun: boolean;
+    yes: boolean;
+    harness: string;
+    withCli?: boolean;
+    cli?: boolean;
+}): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { join } from "node:path";
+import { loadManifest, saveManifest, } from "../lib/manifest.js";
+import { findProjectRoot } from "../lib/paths.js";
+import { info, printSetupSummary } from "../lib/display.js";
+import { getVersion } from "../lib/version.js";
+import { getProfile } from "../harnesses/index.js";
+import { initContext, checkConflicts, configureMcpStep, installAgentsDefs, installCommandsDefs, configureMetricsStep, configureCliStep, runHealthCheck, configureShell, } from "./helpers.js";
+export async function runSetup(opts) {
+    const version = await getVersion();
+    const profile = getProfile(opts.harness);
+    console.log();
+    console.log(`  ${chalk.dim("⟨u⟩")} ${chalk.cyan.bold("ulu")}${chalk.bold("·ops")}`);
+    console.log(`      ${chalk.dim("operating intelligence as infrastructure")}`);
+    console.log();
+    console.log(`  Setup v${version} — ${chalk.bold(profile.displayName)}`);
+    console.log();
+    if (opts.dryRun) {
+        info(chalk.dim("(dry run — no changes will be made)\n"));
+    }
+    const { env, apiKey } = await initContext(opts);
+    console.log();
+    // Load existing manifest for update detection
+    const existingManifest = await loadManifest();
+    const existingHarness = existingManifest?.harnesses[profile.name];
+    if (existingManifest && existingManifest.version !== version) {
+        info(`Updating ${chalk.dim(existingManifest.version)} → ${chalk.green(version)}`);
+        console.log();
+    }
+    else if (existingHarness) {
+        info(chalk.dim(`Already at v${version} — checking for changes`));
+        console.log();
+    }
+    // Check for conflicts on first install for this harness
+    if (!existingHarness && !opts.yes && !opts.dryRun) {
+        await checkConflicts(profile, opts.localDefs);
+    }
+    const mcpResult = await configureMcpStep(profile, apiKey, opts);
+    const agentsResult = await installAgentsDefs(profile, opts, existingHarness?.agents);
+    const commandsResult = await installCommandsDefs(profile, opts, existingHarness?.commands);
+    const metricsResult = await configureMetricsStep(profile, opts);
+    const cliResult = await configureCliStep({
+        withCli: opts.withCli,
+        cli: opts.cli,
+        yes: opts.yes,
+        apiKey: opts.apiKey,
+        dryRun: opts.dryRun,
+    });
+    await runHealthCheck(opts);
+    const shellModified = await configureShell(env, apiKey, opts);
+    // Save manifest
+    if (!opts.dryRun) {
+        const now = new Date().toISOString();
+        const harnessEntry = {
+            installedAt: now,
+            setupVersion: version,
+            mcpScope: opts.scope,
+            mcpConfigPath: mcpResult.configPath,
+            defsScope: opts.localDefs ? "local" : "global",
+            defsPath: opts.localDefs
+                ? join(await findProjectRoot(), "uluops")
+                : profile.paths.home,
+            agents: agentsResult.files,
+            commands: commandsResult.files,
+            hooksInstalled: metricsResult.hookConfigured,
+            hooksInstalledVersion: metricsResult.hooksInstalledVersion,
+        };
+        const manifest = existingManifest ?? {
+            version,
+            installedAt: now,
+            shellModified: false,
+            harnesses: {},
+        };
+        manifest.version = version;
+        manifest.installedAt = now;
+        manifest.shellModified = shellModified || manifest.shellModified;
+        manifest.harnesses[profile.name] = harnessEntry;
+        // Only flip cliInstalled to true when WE installed it (not when user-installed).
+        // Once true, persist across re-runs so uninstall remains symmetric — until the
+        // user explicitly removes it with --no-cli + uninstall, this manifest owns it.
+        if (cliResult && cliResult.installed && !cliResult.alreadyPresent) {
+            manifest.cliInstalled = true;
+            manifest.cliInstalledVersion = cliResult.version;
+        }
+        await saveManifest(manifest);
+    }
+    await printSetupSummary({
+        profile,
+        agentCount: agentsResult.files.length,
+        commandCount: commandsResult.files.length,
+        apiKey,
+    });
+}

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,3 @@
+export declare function runUninstall(opts: {
+    dryRun: boolean;
+}): Promise<void>;

package/dist/commands/uninstall.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import { loadManifest, deleteManifest, validateManifest, } from "../lib/manifest.js";
+import { uninstallMcp } from "../steps/mcp.js";
+import { uninstallAgents } from "../steps/agents.js";
+import { uninstallCommands } from "../steps/commands.js";
+import { removeShellExport } from "../steps/shell.js";
+import { uninstallMetrics } from "../steps/metrics.js";
+import { uninstallCli, CLI_PACKAGE } from "../steps/cli.js";
+import { ok, warn, fail, info } from "../lib/display.js";
+import { getVersion } from "../lib/version.js";
+import { getProfile } from "../harnesses/index.js";
+export async function runUninstall(opts) {
+    const version = await getVersion();
+    console.log();
+    console.log(`  ${chalk.dim("⟨u⟩")} ${chalk.cyan.bold("ulu")}${chalk.bold("·ops")} ${chalk.red("Uninstall")} v${version}`);
+    console.log();
+    if (opts.dryRun) {
+        info(chalk.dim("(dry run — no changes will be made)\n"));
+    }
+    const manifest = await loadManifest();
+    if (!manifest) {
+        warn("No manifest found — nothing to uninstall.");
+        return;
+    }
+    const validation = await validateManifest(manifest);
+    if (!validation.valid) {
+        fail("Manifest references paths that no longer exist:");
+        for (const err of validation.errors)
+            info(`  ${err}`);
+        console.log();
+        info("Uninstall may be incomplete. Proceeding with what's available.");
+        console.log();
+    }
+    if (validation.warnings.length > 0) {
+        for (const w of validation.warnings)
+            warn(w);
+        console.log();
+    }
+    for (const [harnessName, hm] of Object.entries(manifest.harnesses)) {
+        let profile;
+        try {
+            profile = getProfile(harnessName);
+        }
+        catch {
+            warn(`Unknown harness "${harnessName}" in manifest — skipping`);
+            continue;
+        }
+        info(chalk.bold(profile.displayName));
+        if (!opts.dryRun) {
+            const agentCount = await uninstallAgents(hm.agents, hm.defsPath);
+            ok(`Removed ${agentCount} agent(s)`);
+        }
+        else {
+            ok(`Would remove ${hm.agents.length} agent(s)`);
+        }
+        if (hm.commands.length > 0) {
+            if (!opts.dryRun) {
+                const cmdCount = await uninstallCommands(hm.commands, hm.defsPath);
+                ok(`Removed ${cmdCount} command(s)`);
+            }
+            else {
+                ok(`Would remove ${hm.commands.length} command(s)`);
+            }
+        }
+        if (!opts.dryRun) {
+            try {
+                await uninstallMcp(profile, hm.mcpConfigPath);
+                ok(`Removed MCP servers from ${hm.mcpConfigPath}`);
+            }
+            catch {
+                warn(`Could not remove MCP servers from ${hm.mcpConfigPath}`);
+            }
+        }
+        else {
+            ok(`Would remove MCP servers from ${hm.mcpConfigPath}`);
+        }
+        if (hm.hooksInstalled) {
+            if (!opts.dryRun) {
+                await uninstallMetrics(profile, false);
+                ok("Removed agent-metrics hook and tool files");
+            }
+            else {
+                ok("Would remove agent-metrics hook and tool files");
+            }
+        }
+        console.log();
+    }
+    // Remove global @uluops/cli if WE installed it (per manifest).
+    // We never auto-remove a user-installed CLI — manifest.cliInstalled gates this.
+    if (manifest.cliInstalled) {
+        const res = await uninstallCli({ dryRun: opts.dryRun });
+        if (opts.dryRun) {
+            ok(`Would remove ${CLI_PACKAGE} (global)`);
+        }
+        else if (res.removed) {
+            ok(`Removed ${CLI_PACKAGE} (global)`);
+        }
+        else {
+            warn(`Could not remove ${CLI_PACKAGE} (global) — try \`npm uninstall -g ${CLI_PACKAGE}\` manually`);
+            if (res.error) {
+                const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+                if (oneLine)
+                    info(`  ${oneLine}`);
+            }
+        }
+    }
+    // Remove shell export
+    if (manifest.shellModified) {
+        const { getShellProfile } = await import("../lib/paths.js");
+        const shellProfile = getShellProfile();
+        if (shellProfile && !opts.dryRun) {
+            await removeShellExport(shellProfile.path);
+            ok(`Removed export from ${shellProfile.path}`);
+        }
+        else if (shellProfile) {
+            ok(`Would remove export from ${shellProfile.path}`);
+        }
+    }
+    if (!opts.dryRun) {
+        await deleteManifest();
+        ok("Manifest deleted");
+    }
+    console.log();
+    info("UluOps has been removed. Restart your harness to complete.");
+    console.log();
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1 @@
+export declare function runVerify(): Promise<void>;

package/dist/commands/verify.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import { verify } from "../steps/verify.js";
+import { ok, fail, info } from "../lib/display.js";
+import { getVersion } from "../lib/version.js";
+export async function runVerify() {
+    const version = await getVersion();
+    console.log();
+    console.log(`  ${chalk.dim("⟨u⟩")} ${chalk.cyan.bold("ulu")}${chalk.bold("·ops")} Installation Check v${version}`);
+    console.log();
+    const result = await verify();
+    for (const check of result.checks) {
+        if (check.passed) {
+            ok(check.label);
+        }
+        else {
+            fail(`${check.label}${check.detail ? ` — ${check.detail}` : ""}`);
+        }
+    }
+    console.log();
+    if (result.ok) {
+        info(chalk.green("All checks passed."));
+    }
+    else {
+        info(chalk.red("Some checks failed. Run npx @uluops/setup to fix."));
+    }
+    console.log();
+    process.exit(result.ok ? 0 : 1);
+}

package/dist/harnesses/claude-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Claude Code Harness Profile
+ *
+ * Wraps existing config-merger.ts and settings-merger.ts logic
+ * behind the HarnessProfile abstraction.
+ */
+import { type HarnessProfile } from "./types.js";
+export declare const claudeCodeProfile: HarnessProfile;

package/dist/harnesses/claude-code.js

@@ -0,0 +1,74 @@
+/**
+ * Claude Code Harness Profile
+ *
+ * Wraps existing config-merger.ts and settings-merger.ts logic
+ * behind the HarnessProfile abstraction.
+ */
+import { join } from "node:path";
+import { ULUOPS_SERVERS, } from "./types.js";
+import { readConfig, mergeUluopsMcp, removeUluopsMcp, writeConfig, } from "../lib/config-merger.js";
+import { readSettings, writeSettings, mergeUluopsHook, removeUluopsHook, hasUluopsHook, } from "../lib/settings-merger.js";
+import { getClaudeHome, getClaudeJsonPath } from "../lib/paths.js";
+class ClaudeCodeMcpConfig {
+    async read(path) {
+        return readConfig(path);
+    }
+    merge(config, apiKey) {
+        return mergeUluopsMcp(config, apiKey);
+    }
+    remove(config) {
+        return removeUluopsMcp(config);
+    }
+    async write(path, config) {
+        await writeConfig(path, config);
+    }
+    check(config) {
+        const servers = config["mcpServers"];
+        if (!servers)
+            return false;
+        return ULUOPS_SERVERS.every((name) => name in servers);
+    }
+}
+class ClaudeCodeHooks {
+    async install(settingsPath, hookCommand, dryRun) {
+        if (dryRun)
+            return true;
+        const settings = await readSettings(settingsPath);
+        // Claude Code uses SubagentStop as the default event for auto-save
+        const merged = mergeUluopsHook(settings, hookCommand);
+        await writeSettings(settingsPath, merged);
+        return true;
+    }
+    async remove(settingsPath, dryRun) {
+        if (dryRun)
+            return;
+        const settings = await readSettings(settingsPath);
+        const cleaned = removeUluopsHook(settings);
+        await writeSettings(settingsPath, cleaned);
+    }
+    async check(settingsPath) {
+        const settings = await readSettings(settingsPath);
+        return hasUluopsHook(settings);
+    }
+}
+const home = getClaudeHome();
+export const claudeCodeProfile = {
+    name: "claude-code",
+    displayName: "Claude Code",
+    status: "stable",
+    homeDir: home,
+    agentFormat: "markdown",
+    factoryTarget: "claude-code",
+    agentExtension: ".md",
+    paths: {
+        home,
+        globalMcpConfig: getClaudeJsonPath(),
+        localMcpConfig: ".mcp.json",
+        agentsDir: join(home, "agents"),
+        commandsDir: join(home, "commands"),
+        settingsPath: join(home, "settings.json"),
+        toolsDir: join(home, "tools", "agent-metrics"),
+    },
+    mcpConfig: new ClaudeCodeMcpConfig(),
+    hooks: new ClaudeCodeHooks(),
+};

package/dist/harnesses/codex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Codex Harness Profile (Scaffold)
+ *
+ * Paths and metadata are verified from vendor docs.
+ * Codex uses TOML config with `mcp_servers` key (nested tables).
+ * Agent definitions are TOML, not markdown.
+ * Skills use a different path ($HOME/.agents/skills/) than agents (~/.codex/agents/).
+ *
+ * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
+ * until integration testing is complete.
+ *
+ * Will require `smol-toml` dependency when fully implemented.
+ */
+import type { HarnessProfile } from "./types.js";
+export declare const codexProfile: HarnessProfile;