@tiny-fish/cli 0.25.2-next.220 → 0.25.2-next.222

package/README.md

@@ -10,6 +10,25 @@ npm install -g @tiny-fish/cli
 
 Requires Node.js 24+.
 
+### Connect your agents
+
+The recommended way in: run `connect` with no arguments.
+
+```bash
+npx -y @tiny-fish/cli@latest connect
+```
+
+It detects the agent configs on your machine (Claude Code, Codex, Cursor, Grok, Hermes,
+OpenClaw, OpenCode) and opens a checklist with everything pre-selected. Press enter to connect
+them all, or use the arrow keys and space to narrow the set first; `q` cancels without touching
+anything. Terminals without raw-key support get a numbered prompt instead.
+
+Without a terminal (agents, CI), bare `connect` behaves exactly like `tinyfish connect --all`
+and says so on its first line: every detected harness that can authenticate headlessly (via
+`TINYFISH_API_KEY` or `--api-key`) is connected, the rest are skipped with a fix command.
+`tinyfish connect --all` itself is unchanged and skips the picker; `--dry-run`, `--uninstall`
+and `--skip-launch` still require it.
+
 ### Connect Claude Code
 
 Add TinyFish MCP and the global `use-tinyfish` web skill, authenticate the CLI, and start the

package/dist/commands/connect.js

@@ -63,11 +63,12 @@ async function connectNativeMcpClient(client, options) {
         const useKeyAuth = !!keyedAdd;
         if (options.keyAuthOnly && !useKeyAuth) {
             // No keyAuth at all is structural (Hermes); a missing flag is just an old install.
-            throw new Error(client.keyAuth
-                ? `This ${client.displayName} install cannot take a TinyFish API key, and signing in ` +
-                    `needs a terminal. Update it, then re-run: tinyfish connect ${client.connectClient}`
-                : `${client.displayName} cannot take a TinyFish API key, and signing in needs a ` +
-                    `terminal. Run: tinyfish connect ${client.connectClient}`);
+            if (client.keyAuth) {
+                throw new ConnectStepError(`This ${client.displayName} install cannot take a TinyFish API key, and signing in ` +
+                    `needs a terminal. Update it, then re-run: tinyfish connect ${client.connectClient}`, "harness_too_old");
+            }
+            throw new Error(`${client.displayName} cannot take a TinyFish API key, and signing in needs a ` +
+                `terminal. Run: tinyfish connect ${client.connectClient}`);
         }
         telemetry.track("checkpoint", { phase: "prerequisite_ok" });
         state.stage = "registration_cleanup";
@@ -417,7 +418,7 @@ export function registerConnect(program) {
     program
         .command("connect")
         .description("Connect TinyFish to an AI agent")
-        .argument("[client]", "Agent client to connect (claude-code, codex, cursor, grok, hermes, openclaw, or opencode)")
+        .argument("[client]", "Agent client to connect (claude-code, codex, cursor, grok, hermes, openclaw, or opencode); omit to pick from the agents detected on this machine")
         .option("--all", "Detect and connect every supported harness found on this machine")
         .option("--dry-run", "Print planned writes per harness without touching anything (--all only)")
         .option("--uninstall", "Remove TinyFish entries written by connect --all")
@@ -476,7 +477,24 @@ export function registerConnect(program) {
             throw new Error("--dry-run, --uninstall and --skip-launch are only supported with --all.");
         }
         if (!client) {
-            throw new Error("Pass a client (claude-code, codex, cursor, grok, hermes, openclaw, opencode) or --all.");
+            if (options.launch) {
+                throw new Error("--launch is not supported with --all. Connect a single client to launch it.");
+            }
+            const humanInitiated = detectHumanInitiated();
+            if (!humanInitiated) {
+                errLine("No terminal detected: connecting every detected harness (same as tinyfish connect --all).");
+            }
+            const exitCode = await runConnectAll({
+                apiKey: options.apiKey,
+                mcpUrl,
+                dryRun: false,
+                uninstall: false,
+                pick: humanInitiated,
+            });
+            // Preserve the 130 runGuarded set on Ctrl+C.
+            if (!process.exitCode)
+                process.exitCode = exitCode;
+            return;
         }
         const connectOptions = {
             apiKey: options.apiKey,

package/dist/lib/connect-all.d.ts

@@ -5,5 +5,7 @@ export interface ConnectAllOptions {
     uninstall: boolean;
     /** Skip the end-of-install agent launch (finale still prints the ask). */
     noLaunch?: boolean;
+    /** Bare connect: offer the checkbox picker over the detected harnesses. */
+    pick?: boolean;
 }
 export declare function runConnectAll(opts: ConnectAllOptions): Promise<number>;

package/dist/lib/connect-all.js

@@ -1,30 +1,27 @@
 import * as readline from "node:readline/promises";
 import spawn from "cross-spawn";
 import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
-import { validatedApiKey } from "./auth.js";
+import { loadConfig, validatedApiKey } from "./auth.js";
 import { installTinyFishCli, } from "./cli-install.js";
 import { NATIVE_MCP_CLIENTS } from "./connect-clients.js";
 import { ensureCliAuthenticated, TINYFISH_CLI_NOT_FOUND_MESSAGE } from "./connect-auth.js";
 import { commandNotFound, ConnectInterruptedError, ConnectStepError, finishSetupCommand, throwIfInterrupted, } from "./connect-runtime.js";
-import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, ALL_HARNESSES, } from "./harness-detect.js";
+import { pickHarnesses } from "./connect-picker.js";
+import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, } from "./harness-detect.js";
 import { detectHumanInitiated } from "./harness.js";
 import { emitNotice } from "./notice.js";
 import { removeCursorMcpServer, planCursorWrite } from "./cursor-config.js";
 import { errLine, outLine } from "./output.js";
 import { sendSetupCompleted } from "./setup-telemetry.js";
 import { verifyMcpAuth, verifyMcpHealth } from "./verify.js";
-const DISPLAY_NAMES = {
-    "claude-code": "Claude Code",
-    codex: "Codex",
-    cursor: "Cursor",
-    grok: "Grok",
-    hermes: "Hermes",
-    openclaw: "OpenClaw",
-    opencode: "OpenCode",
-};
 // `codex mcp add` succeeds unauthenticated; OAuth lands at first tool use.
 // TODO(PF-3580): connect now probes Codex sign-in, so this over-warns a signed-in install.
 const AUTH_DEFERRED_AT_INSTALL = new Set(["codex"]);
+// A probe that exits non-zero is an install so old the subcommand is missing entirely.
+const TOO_OLD_REASONS = new Set([
+    "harness_too_old",
+    "harness_command_unsupported",
+]);
 const AUTH_CHECK_CAPABLE = new Set(["cursor", "openclaw"]);
 // Descriptor-derived so a harness that cannot carry a key is skipped, not failed, when headless.
 // Cursor and OpenClaw hold the key themselves rather than handing it to a harness `mcp add`.
@@ -194,6 +191,15 @@ async function processHarness(detection, opts, prompt, hoistedCliInstall) {
         });
     }
     catch (e) {
+        // Both reasons carry the same "flag not listed" message; the upgrade nudge is in it.
+        if (e instanceof ConnectStepError && TOO_OLD_REASONS.has(e.failureReason)) {
+            return {
+                ...base,
+                outcome: "harness_too_old",
+                errorMessage: e.message,
+                fixCommand: `tinyfish connect ${harness}`,
+            };
+        }
         return {
             ...base,
             outcome: "failed",
@@ -241,6 +247,9 @@ function summaryLine(result, uninstall) {
             : "no stored credentials and no terminal to sign in";
         return `… ${name} — skipped, ${why}. Fix: ${result.fixCommand}`;
     }
+    if (result.outcome === "deselected") {
+        return `… ${name} — skipped, not selected. Fix: ${result.fixCommand}`;
+    }
     if (result.outcome === "uninstall_pointer") {
         return `… ${name} — not removed automatically (config is owned by ${name}). Run: ${result.fixCommand}`;
     }
@@ -255,6 +264,9 @@ function summaryLine(result, uninstall) {
     if (result.outcome === "interrupted") {
         return `✗ ${name} — interrupted before finishing. Fix: ${result.fixCommand}`;
     }
+    if (result.outcome === "harness_too_old") {
+        return `… ${name} — needs a newer ${name}: ${result.errorMessage} Fix, once upgraded: ${result.fixCommand}`;
+    }
     if (result.outcome === "failed") {
         return `✗ ${name} — install failed: ${result.errorMessage}. Fix: ${result.fixCommand}`;
     }
@@ -288,7 +300,10 @@ function computeExitCode(results) {
     if (detected.length === 0)
         return 1;
     // Only real install attempts count toward the success/failure denominator.
-    const attempted = detected.filter((r) => r.outcome === "installed" || r.outcome === "failed" || r.outcome === "interrupted");
+    const attempted = detected.filter((r) => r.outcome === "installed" ||
+        r.outcome === "failed" ||
+        r.outcome === "harness_too_old" ||
+        r.outcome === "interrupted");
     if (attempted.length === 0)
         return 0;
     return attempted.some((r) => r.outcome === "installed") ? 0 : 1;
@@ -384,9 +399,26 @@ export async function runConnectAll(opts) {
         }
         : undefined;
     const detections = detectInstalledHarnesses();
+    let deselected = new Set();
+    let mode = "all";
+    // Before willAttempt/cliNeeded: a cursor-only pick must not hoist the CLI.
+    // A stale config dir has no binary to connect, so never offer it as a choice.
+    const offerable = detections.filter((d) => d.detected && !isStaleConfig(d));
+    if (opts.pick && offerable.length > 0) {
+        const connected = new Set(Object.keys(loadConfig().connect ?? {}));
+        const pick = await pickHarnesses(offerable, connected, { prompt });
+        mode = pick.mode;
+        if (pick.selection === "cancel") {
+            // Before summary and telemetry: an explicit nothing is not a setup.
+            outLine("Nothing installed. Run: tinyfish connect --all or tinyfish connect <client>");
+            return 0;
+        }
+        const chosen = new Set(pick.selection);
+        deselected = new Set(offerable.filter((d) => !chosen.has(d.harness)).map((d) => d.harness));
+    }
     const gateKey = validatedApiKey(opts.apiKey);
     // Mirrors processHarness's skip gate: a skipped harness installs nothing today.
-    const willAttempt = (harness) => isTTY || (!!gateKey && KEY_AUTH_CAPABLE.has(harness));
+    const willAttempt = (harness) => !deselected.has(harness) && (isTTY || (!!gateKey && KEY_AUTH_CAPABLE.has(harness)));
     // Machine-global, so once per invocation; cursor's connect never installs it.
     const cliNeeded = !opts.dryRun &&
         !opts.uninstall &&
@@ -408,9 +440,21 @@ export async function runConnectAll(opts) {
         };
     }
     const results = [];
-    for (const [index, detection] of detections.entries()) {
+    const stepTotal = detections.length - deselected.size;
+    let step = 0;
+    for (const detection of detections) {
         const { harness } = detection;
-        errLine(`step ${index + 1} of ${detections.length} — ${DISPLAY_NAMES[harness]}`);
+        if (deselected.has(harness)) {
+            results.push({
+                ...detection,
+                installed: false,
+                outcome: "deselected",
+                fixCommand: `tinyfish connect ${harness}`,
+            });
+            continue;
+        }
+        step += 1;
+        errLine(`step ${step} of ${stepTotal} — ${DISPLAY_NAMES[harness]}`);
         let result;
         try {
             result = await processHarness(detection, opts, prompt, takeHoistedCli);
@@ -432,7 +476,7 @@ export async function runConnectAll(opts) {
         if (result.outcome === "interrupted")
             break;
     }
-    // The interrupt break truncates `results`; pad so the 5-entry telemetry schema still parses.
+    // The interrupt break truncates `results`; pad so the one-row-per-harness schema still parses.
     for (const detection of detections) {
         if (results.some((r) => r.harness === detection.harness))
             continue;
@@ -483,7 +527,7 @@ export async function runConnectAll(opts) {
             verify_depth: r.verifyDepth ?? null,
             verify_ok: r.verifyOk ?? null,
         }));
-        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey));
+        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey), mode);
         // After the summary and before the launch, which is where the user is reading.
         emitNotice();
     }

package/dist/lib/connect-picker.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from "node:stream";
+import { type Harness, type HarnessDetection } from "./harness-detect.js";
+export type PickSelection = Harness[] | "cancel";
+export interface PickResult {
+    selection: PickSelection;
+    mode: "pick" | "pick_numeric";
+}
+export type PickerStdin = Readable & {
+    setRawMode?: (raw: boolean) => unknown;
+};
+export interface PickerIo {
+    stdin?: PickerStdin;
+    write?: (text: string) => void;
+    prompt?: (question: string) => Promise<string>;
+}
+export declare function pickHarnesses(detections: HarnessDetection[], connectedBefore: ReadonlySet<string>, io?: PickerIo): Promise<PickResult>;

package/dist/lib/connect-picker.js

@@ -0,0 +1,136 @@
+import * as readline from "node:readline";
+import { HARNESS_DISPLAY_NAMES } from "./harness-detect.js";
+const KEY_HELP = "  ↑↓ move   space toggle one   a none/all   q cancel";
+function header(count) {
+    return `Found ${count} agent config${count === 1 ? "" : "s"} on this machine.\n\n`;
+}
+function connectedNote(item) {
+    return item.connectedBefore ? "  (previously connected)" : "";
+}
+function enterHint(checkedCount, total) {
+    if (checkedCount === 0)
+        return "press enter to cancel";
+    if (checkedCount === total)
+        return `press enter to connect all ${total}`;
+    return `press enter to connect ${checkedCount} of ${total}`;
+}
+function frame(items, checked, cursor) {
+    const rows = items.map((item, i) => `  ${i === cursor ? ">" : " "} [${checked[i] ? "x" : " "}] ${item.name}${connectedNote(item)}`);
+    const count = checked.filter(Boolean).length;
+    return [...rows, "", `  ${enterHint(count, items.length)}`, KEY_HELP, ""].join("\n");
+}
+async function pickWithKeys(items, stdin, write) {
+    const checked = items.map(() => true);
+    let cursor = 0;
+    let painted = 0;
+    const paint = () => {
+        const text = frame(items, checked, cursor);
+        write((painted > 0 ? `\u001b[${painted}A\u001b[0J` : "") + text);
+        painted = items.length + 3;
+    };
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let onKeypress;
+    try {
+        write(header(items.length));
+        paint();
+        return await new Promise((resolve, reject) => {
+            onKeypress = (_chunk, key = {}) => {
+                try {
+                    const name = key.name ?? "";
+                    // Raw mode eats terminal SIGINT, so Ctrl+C arrives only here.
+                    if ((key.ctrl && (name === "c" || name === "d")) || name === "q" || name === "escape") {
+                        resolve("cancel");
+                        return;
+                    }
+                    if (name === "return" || name === "enter") {
+                        const picked = items.filter((_, i) => checked[i]).map((item) => item.harness);
+                        resolve(picked.length > 0 ? picked : "cancel");
+                        return;
+                    }
+                    if (name === "up" || name === "k")
+                        cursor = (cursor + items.length - 1) % items.length;
+                    else if (name === "down" || name === "j")
+                        cursor = (cursor + 1) % items.length;
+                    else if (name === "space")
+                        checked[cursor] = !checked[cursor];
+                    else if (name === "a")
+                        checked.fill(!checked.every(Boolean));
+                    paint();
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            stdin.on("keypress", onKeypress);
+        });
+    }
+    finally {
+        // Restore before any child spawn can inherit raw stdin (PF-3635).
+        if (onKeypress)
+            stdin.removeListener("keypress", onKeypress);
+        stdin.setRawMode(false);
+        stdin.pause();
+    }
+}
+function numberedRows(items) {
+    return (items.map((item, i) => `  [${i + 1}] ${item.name}${connectedNote(item)}`).join("\n") + "\n");
+}
+function parseSubset(answer, items) {
+    const tokens = answer.split(/[\s,]+/).filter(Boolean);
+    if (tokens.length === 0)
+        return undefined;
+    const picked = new Set();
+    for (const token of tokens) {
+        if (!/^\d+$/.test(token))
+            return undefined;
+        const index = Number.parseInt(token, 10);
+        if (index < 1 || index > items.length)
+            return undefined;
+        picked.add(index - 1);
+    }
+    return items.filter((_, i) => picked.has(i)).map((item) => item.harness);
+}
+async function pickWithNumbers(items, prompt, write) {
+    write(header(items.length) + numberedRows(items));
+    const question = `Press enter to connect all ${items.length}, numbers for a subset (e.g. 1,3), or n to cancel: `;
+    // One re-prompt on garbage, then cancel; never a loop.
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let answer;
+        try {
+            answer = (await prompt(question)).trim();
+        }
+        catch {
+            // Closed stdin: every later question would throw too.
+            return "cancel";
+        }
+        if (answer === "")
+            return items.map((item) => item.harness);
+        if (/^[nq]$/i.test(answer))
+            return "cancel";
+        const subset = parseSubset(answer, items);
+        if (subset)
+            return subset;
+    }
+    return "cancel";
+}
+export async function pickHarnesses(detections, connectedBefore, io = {}) {
+    const items = detections
+        .filter((detection) => detection.detected)
+        .map((detection) => ({
+        harness: detection.harness,
+        name: HARNESS_DISPLAY_NAMES[detection.harness],
+        connectedBefore: connectedBefore.has(detection.harness),
+    }));
+    const stdin = io.stdin ?? process.stdin;
+    const write = io.write ?? ((text) => void process.stderr.write(text));
+    if (typeof stdin.setRawMode !== "function") {
+        // No prompt means nothing to ask; keep --all semantics.
+        const selection = io.prompt
+            ? await pickWithNumbers(items, io.prompt, write)
+            : items.map((item) => item.harness);
+        return { selection, mode: "pick_numeric" };
+    }
+    return { selection: await pickWithKeys(items, stdin, write), mode: "pick" };
+}

package/dist/lib/connect-runtime.d.ts

@@ -4,7 +4,7 @@ export type AgentClient = "claude-code" | "codex" | "cursor" | "grok" | "hermes"
 type ConnectStage = "started" | "checkpoint" | "completed" | "failed" | "aborted" | "post_install_failed";
 type ConnectFailureStage = "prerequisite_check" | "registration_cleanup" | "registration" | "registration_or_authentication" | "client_oauth" | "cli_install" | "skill_install" | "authentication" | "walkthrough_launch";
 export declare const CONNECT_FAILURE_REASONS: readonly ["harness_not_installed", "harness_command_unsupported", "harness_too_old", "command_not_found", "timeout", "spawn_error", "nonzero_exit", "invalid_config", "user_abandoned", "process_terminated", "unexpected_error"];
-type ConnectFailureReason = (typeof CONNECT_FAILURE_REASONS)[number];
+export type ConnectFailureReason = (typeof CONNECT_FAILURE_REASONS)[number];
 export type ConnectAuthMode = Exclude<AuthMode, AuthMode.Unknown> | "deferred";
 type ConnectCheckpoint = "prerequisite_ok" | "registered" | "oauth_done" | "cli_installed" | "skill_installed" | "authenticated";
 /** Ctrl+C killed a setup child — abandonment, not error. */

package/dist/lib/harness-detect.d.ts

@@ -1,5 +1,6 @@
 export declare const ALL_HARNESSES: readonly ["claude-code", "codex", "cursor", "grok", "hermes", "openclaw", "opencode"];
 export type Harness = (typeof ALL_HARNESSES)[number];
+export declare const HARNESS_DISPLAY_NAMES: Record<Harness, string>;
 export declare enum Registered {
     Yes = "yes",
     No = "no",

package/dist/lib/harness-detect.js

@@ -11,6 +11,15 @@ export const ALL_HARNESSES = [
     "openclaw",
     "opencode",
 ];
+export const HARNESS_DISPLAY_NAMES = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    cursor: "Cursor",
+    grok: "Grok",
+    hermes: "Hermes",
+    openclaw: "OpenClaw",
+    opencode: "OpenCode",
+};
 // Values are the wire contract; the report schema derives from these.
 export var Registered;
 (function (Registered) {

package/dist/lib/setup-telemetry.d.ts

@@ -60,13 +60,19 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
         verify_ok: z.ZodNullable<z.ZodBoolean>;
     }, z.core.$strip>>;
     cli_version: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        pick: "pick";
+        pick_numeric: "pick_numeric";
+    }>>;
 }, z.core.$strip>;
 export type SetupCompletedPayload = z.infer<typeof setupCompletedPayloadSchema>;
 export type HarnessResult = z.infer<typeof harnessResultSchema>;
+export type SetupMode = NonNullable<SetupCompletedPayload["mode"]>;
 export type UpgradeOutcome = "updated" | "failed" | "interrupted";
 /** Step selection; "updated" means every selected step ran. */
 export type UpgradeScope = "both" | "cli" | "skill";
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export declare function sendUpgradeCompleted(fromVersion: string, toVersion: string | null, outcome: UpgradeOutcome, scope: UpgradeScope, apiKey?: string): Promise<void>;
-export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string): Promise<void>;
+export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string, mode?: SetupMode): Promise<void>;
 export {};

package/dist/lib/setup-telemetry.js

@@ -109,6 +109,8 @@ export const setupCompletedPayloadSchema = z.object({
         message: "expected one result per harness",
     }),
     cli_version: z.string(),
+    // Segments picker runs from --all runs; the server field shipped first.
+    mode: z.enum(["all", "pick", "pick_numeric"]).optional(),
 });
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scope, apiKey) {
@@ -126,7 +128,7 @@ export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scop
         apiKey,
     });
 }
-export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
+export async function sendSetupCompleted(mcpUrl, harnesses, apiKey, mode) {
     // Ahead of the parse so an opt-out run prints no telemetry debug.
     if (telemetryDisabled())
         return;
@@ -134,7 +136,11 @@ export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
     let body;
     try {
         // Parse inside try — schema violation must not crash finished setup.
-        const payload = setupCompletedPayloadSchema.parse({ harnesses, cli_version: CLI_VERSION });
+        const payload = setupCompletedPayloadSchema.parse({
+            harnesses,
+            cli_version: CLI_VERSION,
+            ...(mode ? { mode } : {}),
+        });
         endpoint = new URL("/api/cli/connect-event", mcpUrl).toString();
         body = JSON.stringify({ event: "setup_completed", ...payload });
     }

package/dist/lib/skill-install.js

@@ -8,7 +8,6 @@ import { commandNotFound, spawnStepError, throwIfInterrupted } from "./connect-r
 import { CLI_AGENT_IDENTITY } from "./constants.js";
 import { errLine } from "./output.js";
 // Supports Hermes without node:util.styleText, so the installer still runs on Node 20.11.
-// A bump must re-verify SKILL_AGENT_DISPLAY_NAMES against `skills list --json`.
 const SKILLS_CLI_PACKAGE = "skills@1.5.15";
 const TINYFISH_WEB_SKILL_SOURCE = "tinyfish-io/tinyfish-cookbook";
 const TINYFISH_WEB_SKILL = "use-tinyfish";
@@ -45,35 +44,23 @@ const SKILL_ALREADY_CURRENT_PATTERN = /All global skills are up to date/;
 // A lock entry with no recorded hash is untrackable, so `skills` reports it as skipped rather
 // than failed. Left undetected that reads as "up to date" while nothing was refreshed.
 const SKILL_UNCHECKABLE_PATTERN = /cannot be checked automatically/;
-// `skills list --json` reports display names, never slugs (verified on 1.5.15).
-const SKILL_AGENT_DISPLAY_NAMES = {
-    "claude-code": "Claude Code",
-    codex: "Codex",
-    cursor: "Cursor",
-    "hermes-agent": "Hermes Agent",
-    opencode: "OpenCode",
-};
-const skillListSchema = z.array(z.object({ name: z.string(), agents: z.array(z.string()) }));
+const skillListSchema = z.array(z.object({ name: z.string() }));
 // `add` exits 0 on per-skill failure; the piped list is the verdict.
-function failedListVerdict(skillAgents) {
+function failedListVerdict() {
     const list = spawn.sync("npx", ["-y", SKILLS_CLI_PACKAGE, "list", "--global", "--json"], {
         encoding: "utf8",
         env: skillSpawnEnv(),
         maxBuffer: STEP_MAX_BUFFER,
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
-    const verified = !list.error && list.status === 0 && verifiedForAgents(list.stdout ?? "", skillAgents);
+    const verified = !list.error && list.status === 0 && skillListed(list.stdout ?? "");
     return verified ? null : list;
 }
-// `list` folds in every agent's dir, so name-only matches stale copies.
-function verifiedForAgents(stdout, skillAgents) {
+// Entry presence is the whole verdict: `agents` names the harnesses `skills` detects,
+// so an install for a harness with no config dir yet lists none (PF-3680).
+function skillListed(stdout) {
     const parsed = skillListSchema.safeParse(parseJson(stdout));
-    if (!parsed.success)
-        return false;
-    const agents = parsed.data
-        .filter((skill) => skill.name === TINYFISH_WEB_SKILL)
-        .flatMap((skill) => skill.agents);
-    return skillAgents.every((agent) => agents.includes(SKILL_AGENT_DISPLAY_NAMES[agent]));
+    return parsed.success && parsed.data.some((skill) => skill.name === TINYFISH_WEB_SKILL);
 }
 function parseJson(text) {
     try {
@@ -93,7 +80,7 @@ export function installWebSkill(client) {
         env: skillSpawnEnv(),
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
-    const failed = add.error || add.status !== 0 ? add : failedListVerdict([client.skillAgent]);
+    const failed = add.error || add.status !== 0 ? add : failedListVerdict();
     if (failed) {
         throw spawnStepError(`Could not install the TinyFish web skill in ${client.displayName}`, failed);
     }
@@ -162,7 +149,7 @@ function reinstallWebSkill(skillAgents, verbose) {
     const output = capturedOutput(result);
     // Quiet capture stays (#4434); the list verdict replaced prose matching.
     const addFailed = Boolean(result.error) || result.status !== 0;
-    const failedList = addFailed ? null : failedListVerdict(skillAgents);
+    const failedList = addFailed ? null : failedListVerdict();
     const failed = addFailed || failedList !== null;
     if (failed)
         throwIfInterrupted(failedList ?? result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.25.2-next.220",
+  "version": "0.25.2-next.222",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {