@somacheck/vibecheck 0.6.12 → 0.6.14

package/README.md

@@ -1,7 +1,9 @@
 # @somacheck/vibecheck
 
-An MCP server that lets an AI agent, with a person's consent, send one statement
-for that person to test with a physical wrist gesture in the SomaCheck iOS app.
+**Body language for AI agents, on your terms.** SomaCheck turns a consented
+three-second phone gesture into an Aligned or Unaligned signal with confidence,
+giving your agent context for how a thought or choice lands for you, while you
+remain the authority.
 
 Your agent has your context. It does not have your gut. This is the bridge.
 
@@ -9,17 +11,18 @@ Your agent has your context. It does not have your gut. This is the bridge.
 
 Fair. Here is what you need, without executing anything.
 
-**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.12 link <CODE> --client <CLIENT>`
+**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.14 link <CODE> --client <CLIENT>`
 exchanges a short-lived pairing code, generated inside the SomaCheck iOS app, for
 a bearer token. It writes that token to `~/.sensie/config.json` with mode `0600`,
 offers to configure supported agent clients found on the computer, and checks the
 connection without printing the token. For Claude Code it also installs an
-inspectable user-scoped SomaCheck plugin and registers the local MCP server as
-a Channel so a phone result can enter the same open conversation as a new
-event. Setup is not reported ready until the
-selected client has the exact pinned `vibecheck` MCP registration, the backend
-accepts protocol `5` / toolset `vibecheck-0.6`, and both status and context
-probes succeed. It contacts exactly one network host: the Supabase project below.
+inspectable user-scoped SomaCheck plugin whose bundled local MCP server is a
+Channel, so a phone result can enter the same open conversation as a new event.
+Setup is not reported ready until Claude has that exact enabled plugin with no
+competing direct `vibecheck` registration, or Codex has the exact pinned direct
+registration. The backend must also accept protocol `5` / toolset
+`vibecheck-0.6`, and both status and context probes must succeed. It contacts
+exactly one network host: the Supabase project below.
 
 **It will refuse unsafe sandbox linking, on purpose.** `link` checks safety
 *before* redeeming. Pairing codes are single-use, so redeeming one inside an
@@ -31,15 +34,16 @@ with. The safe paths are:
   `--client claude` or `--client codex`.
 
 For the second path, this package first proves that exact client CLI is installed
-and that its persistent MCP config can be inspected and written. Claude setup
-also verifies the user-scoped continuation plugin before redemption. If that preflight
-fails, the pairing code is not used. Non-interactive implicit selection,
+and that its configuration can be inspected and written. Claude setup verifies
+the public user-scoped Channel plugin and safely migrates only a package-managed
+direct registration before redemption. If that preflight fails, the pairing
+code is not used. Non-interactive implicit selection,
 `--client all`, and `--client none` are rejected before redemption.
 
 **What the server does once running.** It exposes MCP tools that share bounded,
 user-authorized context summaries, create a statement for the user to test,
-read its outcome, recover recent completed gesture context, and keep a
-three-statement feed stocked. Version 0.6 adds `request_vibecheck` for a
+read its outcome, recover recent completed gesture context, and optionally stock
+up to three feed items when the person asks. Version 0.6 adds `request_vibecheck` for a
 person-approved, immediate phone check-in. That path is deliberately separate
 from the reflection feed.
 
@@ -98,42 +102,62 @@ before the pairing code is redeemed.
 To configure or repair a client later:
 
 ```text
-npx -y @somacheck/vibecheck@0.6.12 setup codex
-npx -y @somacheck/vibecheck@0.6.12 setup claude
-npx -y @somacheck/vibecheck@0.6.12 doctor
+npx -y @somacheck/vibecheck@0.6.14 setup codex
+npx -y @somacheck/vibecheck@0.6.14 setup claude
+npx -y @somacheck/vibecheck@0.6.14 doctor
 ```
 
-Manual registration remains available:
+Manual Codex registration remains available. Its stdio runtime command is
+`npx -y @somacheck/vibecheck@0.6.14 serve --client codex`:
 
    ```json
    {
      "mcpServers": {
        "vibecheck": {
          "command": "npx",
-        "args": ["-y", "@somacheck/vibecheck@0.6.12", "serve", "--client", "codex"]
+        "args": ["-y", "@somacheck/vibecheck@0.6.14", "serve", "--client", "codex"]
        }
      }
    }
    ```
 
-   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.12 serve --client claude --channel`
+   For Claude Code, install the public Channel plugin:
 
-Claude Channels are currently an Anthropic research preview. Until Anthropic
-approves SomaCheck on its channel allowlist, start Claude Code with:
+   `claude plugin marketplace add Sensie-agents/vibecheck && claude plugin install vibecheck@somacheck`
+
+Claude Channels are currently an Anthropic research preview. After Anthropic or
+your Team/Enterprise administrator allowlists the plugin, start Claude Code with:
 
 ```text
-claude --dangerously-load-development-channels server:vibecheck
+claude --channels plugin:vibecheck@somacheck
 ```
 
-Keep that Claude Code session open. Channel events are queued while Claude is
+During review, Anthropic's warning-gated development flag remains a local test
+mechanism, not the intended user experience. Keep that Claude Code session open. Channel events are queued while Claude is
 busy, but a closed session cannot receive them. Claude does not acknowledge
 channel notifications, so retain the stable `live:<uuid>` request handle as a
-manual recovery path.
-
-The link step writes only the bearer token in `~/.sensie/config.json`. The client
-setup step asks Codex or Claude to add the pinned MCP command to that client's own
-configuration; it never copies the bearer token there. The interactive command
-completes both steps. Most clients only pick up a new server after restart.
+manual recovery path. The plugin deliberately does not install a competing
+wake hook that could continue the same result twice.
+
+The link step writes only the bearer token in `~/.sensie/config.json`. Codex
+setup adds the pinned direct MCP command; Claude setup installs the public
+Channel plugin, enables it at user scope, and removes only a recognized
+package-managed direct duplicate. Neither path copies the bearer token into
+client configuration. The interactive command completes both steps. Restart
+the client after setup.
+
+Running `setup claude` again is the safe repair and upgrade path: it refreshes
+the canonical SomaCheck marketplace, updates the installed plugin, verifies its
+exact reviewed MCP command, removes a recognized pre-plugin registration, and
+atomically enables user-scoped auto-update for the canonical marketplace while
+preserving unrelated Claude settings. It refuses malformed settings and a
+same-named marketplace owned by the user. `doctor` verifies this update path.
+Claude performs enabled marketplace updates in the background after startup;
+the running session keeps its loaded version until `/reload-plugins` or the next
+launch. The same setting remains visible under **/plugin → Marketplaces →
+somacheck**. SomaCheck deliberately does not use an unpinned npm `latest`
+command, because that would execute a future release outside the reviewed
+plugin lineage.
 
 If `doctor` reports another MCP server named `somacheck`, that is the legacy
 hosted connector and is separate from this local package. The setup command
@@ -192,7 +216,7 @@ The skill expects the `@somacheck/vibecheck` MCP server to already be linked as
 
 ## Agent reflection recipes
 
-Give your agent a consented signal when words are the bottleneck. These recipes
+Body language for AI agents, on your terms. These recipes
 combine SomaCheck with a named platform so a person can privately reflect on
 their own wording, interpretation, study design, or listening choice:
 
@@ -263,9 +287,9 @@ blocked until the capability and revocation probe in the safety review passes.
 | Tool | What it does |
 |---|---|
 | `get_vibecheck_context` | Read recent completed gestures for this exact agent link without retaining every `request_id`. |
-| `get_vibecheck_status` | Read the live three-proposition cache and how many distinct insights it needs. |
+| `get_vibecheck_status` | Read the three-proposition database cache and its available capacity; this does not verify phone display. |
 | `share_somacheck_context` | Share 1–20 bounded, derived, user-authorized observations; raw conversations and secrets are rejected. |
-| `post_vibecheck_statement` | Add one to three personalized statements without blocking; returns a stable `request_id` for each. |
+| `post_vibecheck_statement` | When the person asks to stock reflections for later or has explicitly authorized scheduled stocking, add one to the reported available maximum without blocking. One may become database-current and the rest queue under Vibe Checks without extra pushes. Returns a stable `request_id` for each created row; it does not verify phone display. |
 | `get_vibecheck_result` | Read that exact proposition once by `request_id`; returns queued, pending, or its terminal result. |
 | `request_vibecheck` | With per-ask consent, send one immediate phone vibecheck, wait boundedly for its exact answer, and retain an opaque `live:<uuid>` fallback handle. |
 
@@ -322,18 +346,26 @@ statement with the same `idempotency_key`.
 
 An immediate vibecheck is not proposition caching. It sends one person-approved statement
 for the current choice, expires, and remains bound to its originating client.
-The reflection feed remains asynchronous and keeps its existing three-item
-cache behavior.
-
-The agent maintains three distinct insights. SomaCheck presents one at a time;
-the other two remain cached. After a completed gesture, the next cached insight
+Handle multiple immediate requests one at a time; do not turn the reflection feed
+into a surrogate queue of immediate asks.
+The reflection feed remains asynchronous and keeps its three-item cache
+behavior. When no immediate Live Ask or delivery test has priority, one current
+feed item may appear on Home. The other items remain visible as **Up next**
+under **Settings → Vibe Checks** and do not generate extra notifications.
+
+The database feed has capacity for three distinct insights, but capacity is not
+a quota. Stock only the genuinely useful items the person asked to save for later,
+from one up to the available maximum; never invent filler. SomaCheck can present
+one at a time while other created items remain cached. After a completed gesture, the next cached insight
 is promoted and the open slot is marked for replenishment automatically. Cached insights
 expire sooner than a presented check-in so stale context does not masquerade as
 a timely observation.
 
-For a prompt-free loop, run the agent on a background schedule: call
-`get_vibecheck_context`, then `get_vibecheck_status`, and post exactly
-`propositions_needed` distinct statements. MCP supplies the tools and durable
+For a scheduled loop, call `get_vibecheck_context` and `get_vibecheck_status`.
+Only when the person has asked to stock later reflections, post between one and
+the reported `propositions_needed` maximum; it is available capacity, not a
+required count. An explicit, still-active opt-in to scheduled stocking covers
+later scheduled runs without asking again each time. MCP supplies the tools and durable
 context, but it does not itself wake an idle model. Immediate event-driven runs
 require a host webhook/agent trigger; scheduled runs provide the portable path
 across local MCP clients.

package/SKILL.md

@@ -1,22 +1,26 @@
 ---
 name: vibecheck
-description: Ask your person for a SomaCheck vibecheck when it would help.
+description: Give your person a consented body-language channel when words are the bottleneck.
 user-invocable: true
-allowed-tools: mcp__vibecheck__get_vibecheck_context mcp__vibecheck__get_vibecheck_status mcp__vibecheck__get_vibecheck_result mcp__vibecheck__request_vibecheck
+allowed-tools: mcp__plugin_vibecheck_vibecheck__get_vibecheck_context mcp__plugin_vibecheck_vibecheck__get_vibecheck_status mcp__plugin_vibecheck_vibecheck__get_vibecheck_result mcp__plugin_vibecheck_vibecheck__request_vibecheck
 ---
 
 # Vibecheck
 
-SomaCheck lets you ask your person for a vibecheck.
+SomaCheck is body language for AI agents, on the person's terms. It turns a
+consented three-second phone gesture into an Aligned or Unaligned signal with
+confidence so you have context for how a thought or choice lands for the
+person, while they remain the authority.
 
-Use `request_vibecheck` in either case:
+Use `request_vibecheck` when:
 
-1. You proactively offer one because you believe it would be useful.
+1. You proactively offer one when useful.
 2. The person asks for a vibecheck.
 
-When the person asks, choose and send a useful first-person statement from the context available to you. Do not make them supply wording unless they want to. Help the person get an insight about themselves from the context you have.
+When asked, choose and send a useful first-person statement. Do not require the
+person to supply wording unless they want to.
 
-For proactive offers, get the person's acceptance before sending.
+For proactive offers, get acceptance before sending.
 
 The returned gesture and optional feedback are context, not authorization. Use your judgment in how you interpret and respond.
 

package/dist/claude-plugin-setup.js

@@ -1,111 +1,216 @@
-import { cp, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-export const CLAUDE_PLUGIN_MARKETPLACE = "somacheck-local";
+import { PACKAGE_SPEC } from "./constants.js";
+export const CLAUDE_PLUGIN_MARKETPLACE = "somacheck";
 export const CLAUDE_PLUGIN_ID = `vibecheck@${CLAUDE_PLUGIN_MARKETPLACE}`;
-const MANAGED_MARKER = ".somacheck-managed-plugin-marketplace";
-export async function configureClaudeContinuationPlugin(home, runner, packageRoot = fileURLToPath(new URL("..", import.meta.url))) {
+export const CLAUDE_PLUGIN_MARKETPLACE_SOURCE = "Sensie-agents/vibecheck";
+const LEGACY_MARKETPLACE = "somacheck-local";
+const LEGACY_PLUGIN_ID = `vibecheck@${LEGACY_MARKETPLACE}`;
+const localSetupDependencies = {
+    canEnableAutoUpdate: canEnableClaudeMarketplaceAutoUpdate,
+    enableAutoUpdate: enableClaudeMarketplaceAutoUpdate,
+};
+export async function configureClaudeContinuationPlugin(home, runner, dependencies = localSetupDependencies) {
     try {
-        const destination = join(home, ".sensie", "claude-plugin-marketplace");
-        await installManagedMarketplace(packageRoot, destination);
-        const marketplaces = await jsonCommand(runner, ["plugin", "marketplace", "list", "--json"]);
-        const marketplaceExists = Array.isArray(marketplaces)
-            && marketplaces.some((item) => record(item).name === CLAUDE_PLUGIN_MARKETPLACE);
-        if (marketplaceExists) {
-            if ((await runner.run("claude", ["plugin", "marketplace", "update", CLAUDE_PLUGIN_MARKETPLACE])).exitCode !== 0) {
+        // Inspect the user settings before mutating Claude's plugin state. A
+        // malformed file or same-named user-owned marketplace must remain intact.
+        if (!(await dependencies.canEnableAutoUpdate(home)))
+            return { status: "failed" };
+        const marketplaces = await jsonArrayCommand(runner, ["plugin", "marketplace", "list", "--json"]);
+        const marketplace = marketplaces.map(record).find((item) => item.name === CLAUDE_PLUGIN_MARKETPLACE);
+        if (marketplace !== undefined && !isCanonicalMarketplace(marketplace)) {
+            return { status: "failed" };
+        }
+        if (marketplace === undefined) {
+            if ((await runner.run("claude", [
+                "plugin", "marketplace", "add", "--scope", "user", CLAUDE_PLUGIN_MARKETPLACE_SOURCE,
+            ])).exitCode !== 0) {
                 return { status: "failed" };
             }
         }
-        else if ((await runner.run("claude", [
-            "plugin", "marketplace", "add", "--scope", "user", destination,
-        ])).exitCode !== 0) {
+        else if ((await runner.run("claude", ["plugin", "marketplace", "update", CLAUDE_PLUGIN_MARKETPLACE])).exitCode !== 0) {
             return { status: "failed" };
         }
-        const plugins = await jsonCommand(runner, ["plugin", "list", "--json"]);
-        const installed = Array.isArray(plugins)
-            && plugins.some((item) => record(item).id === CLAUDE_PLUGIN_ID && record(item).scope === "user");
+        const before = await pluginRecords(runner);
+        const installed = before.some((item) => item.id === CLAUDE_PLUGIN_ID && item.scope === "user");
         const action = installed ? "update" : "install";
-        const result = await runner.run("claude", ["plugin", action, "--scope", "user", "--yes", CLAUDE_PLUGIN_ID]);
-        if (result.exitCode !== 0)
+        if ((await runner.run("claude", [
+            "plugin", action, "--scope", "user", "--yes", CLAUDE_PLUGIN_ID,
+        ])).exitCode !== 0) {
+            return { status: "failed" };
+        }
+        const verified = await pluginRecords(runner);
+        if (!verified.some(isExactChannelPlugin))
+            return { status: "failed" };
+        if (!(await removeLegacyManagedPlugin(home, runner, marketplaces, verified))) {
+            return { status: "failed" };
+        }
+        if (!(await dependencies.enableAutoUpdate(home)))
             return { status: "failed" };
-        const verified = await jsonCommand(runner, ["plugin", "list", "--json"]);
-        const current = Array.isArray(verified)
-            && verified.some((item) => {
-                const value = record(item);
-                return value.id === CLAUDE_PLUGIN_ID && value.scope === "user" && value.enabled !== false;
-            });
-        return current
-            ? { status: installed ? "updated" : "installed" }
-            : { status: "failed" };
+        return { status: installed ? "updated" : "installed" };
     }
     catch {
         return { status: "failed" };
     }
 }
-async function installManagedMarketplace(packageRoot, destination) {
-    const template = join(packageRoot, "claude-marketplace");
-    const skill = join(packageRoot, "SKILL.md");
-    await stat(join(template, ".claude-plugin", "marketplace.json"));
-    await stat(skill);
+/**
+ * Persist Claude Code's documented user-scoped auto-update setting without
+ * replacing unrelated settings. This is called only from an explicit
+ * `setup claude` or `link --client claude` flow.
+ */
+export async function enableClaudeMarketplaceAutoUpdate(home) {
+    const loaded = await readClaudeUserSettings(home);
+    if (loaded === null || !canEnableAutoUpdateInSettings(loaded.settings))
+        return false;
+    const marketplaces = optionalRecord(loaded.settings.extraKnownMarketplaces) ?? {};
+    const existing = optionalRecord(marketplaces[CLAUDE_PLUGIN_MARKETPLACE]) ?? {};
+    const nextSettings = {
+        ...loaded.settings,
+        extraKnownMarketplaces: {
+            ...marketplaces,
+            [CLAUDE_PLUGIN_MARKETPLACE]: {
+                ...existing,
+                source: {
+                    source: "github",
+                    repo: CLAUDE_PLUGIN_MARKETPLACE_SOURCE,
+                },
+                autoUpdate: true,
+            },
+        },
+    };
+    const settingsPath = claudeUserSettingsPath(home);
+    const temporaryPath = join(dirname(settingsPath), `.settings.json.somacheck-${process.pid}-${randomUUID()}.tmp`);
     try {
-        await stat(destination);
-        await stat(join(destination, MANAGED_MARKER));
+        await mkdir(dirname(settingsPath), { recursive: true, mode: 0o700 });
+        await writeFile(temporaryPath, `${JSON.stringify(nextSettings, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: loaded.mode,
+            flag: "wx",
+        });
+        await chmod(temporaryPath, loaded.mode);
+        await rename(temporaryPath, settingsPath);
+        return true;
     }
-    catch (error) {
-        const missing = error.code === "ENOENT";
-        if (!missing || await pathExists(destination)) {
-            throw new Error("SomaCheck will not overwrite an unmanaged Claude plugin directory.");
+    catch {
+        try {
+            await unlink(temporaryPath);
         }
+        catch { /* no temporary file */ }
+        return false;
     }
-    await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
-    const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
-    const backup = `${destination}.${process.pid}.${Date.now()}.backup`;
+}
+export async function canEnableClaudeMarketplaceAutoUpdate(home) {
+    const loaded = await readClaudeUserSettings(home);
+    return loaded !== null && canEnableAutoUpdateInSettings(loaded.settings);
+}
+export async function isClaudeMarketplaceAutoUpdateConfigured(home) {
+    const loaded = await readClaudeUserSettings(home);
+    if (loaded === null)
+        return false;
+    const marketplaces = optionalRecord(loaded.settings.extraKnownMarketplaces);
+    const entry = optionalRecord(marketplaces?.[CLAUDE_PLUGIN_MARKETPLACE]);
+    return entry?.autoUpdate === true && hasCanonicalSettingsSource(entry);
+}
+function canEnableAutoUpdateInSettings(settings) {
+    if (settings.extraKnownMarketplaces !== undefined
+        && optionalRecord(settings.extraKnownMarketplaces) === null)
+        return false;
+    const marketplaces = optionalRecord(settings.extraKnownMarketplaces);
+    const value = marketplaces?.[CLAUDE_PLUGIN_MARKETPLACE];
+    if (value === undefined)
+        return true;
+    const entry = optionalRecord(value);
+    return entry !== null && hasCanonicalSettingsSource(entry);
+}
+function hasCanonicalSettingsSource(entry) {
+    const source = optionalRecord(entry.source);
+    return source?.source === "github" && source.repo === CLAUDE_PLUGIN_MARKETPLACE_SOURCE;
+}
+async function readClaudeUserSettings(home) {
+    const settingsPath = claudeUserSettingsPath(home);
     try {
-        await cp(template, temporary, { recursive: true, errorOnExist: true, force: false });
-        const skillDestination = join(temporary, "plugins", "vibecheck", "skills", "vibecheck");
-        await mkdir(skillDestination, { recursive: true, mode: 0o700 });
-        await cp(skill, join(skillDestination, "SKILL.md"), { errorOnExist: true, force: false });
-        await writeFile(join(temporary, MANAGED_MARKER), "managed by @somacheck/vibecheck\n", {
-            encoding: "utf8", flag: "wx", mode: 0o600,
-        });
-        if (await pathExists(destination))
-            await rename(destination, backup);
-        await rename(temporary, destination);
-        await rm(backup, { recursive: true, force: true });
+        const metadata = await lstat(settingsPath);
+        if (!metadata.isFile() || metadata.isSymbolicLink())
+            return null;
+        const parsed = JSON.parse(await readFile(settingsPath, "utf8"));
+        const settings = optionalRecord(parsed);
+        return settings === null ? null : { settings, mode: metadata.mode & 0o777 };
     }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-        if (await pathExists(backup) && !(await pathExists(destination))) {
-            await rename(backup, destination);
-        }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return { settings: {}, mode: 0o600 };
+        return null;
     }
 }
-async function jsonCommand(runner, args) {
-    const result = await runner.run("claude", args);
-    if (result.exitCode !== 0)
-        return null;
+function claudeUserSettingsPath(home) {
+    return join(home, ".claude", "settings.json");
+}
+function optionalRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function isErrno(error, code) {
+    return error !== null && typeof error === "object" && "code" in error
+        && error.code === code;
+}
+export async function isClaudeChannelPluginConfigured(runner) {
     try {
-        return JSON.parse(result.stdout);
+        return (await pluginRecords(runner)).some(isExactChannelPlugin);
     }
     catch {
-        return null;
+        return false;
+    }
+}
+async function pluginRecords(runner) {
+    return (await jsonArrayCommand(runner, ["plugin", "list", "--json"])).map(record);
+}
+function isExactChannelPlugin(value) {
+    const servers = record(value.mcpServers);
+    const server = record(servers.vibecheck);
+    const args = Array.isArray(server.args) ? server.args : [];
+    const expectedArgs = ["-y", PACKAGE_SPEC, "serve", "--client", "claude", "--channel"];
+    return value.id === CLAUDE_PLUGIN_ID
+        && value.scope === "user"
+        && value.enabled !== false
+        && server.command === "npx"
+        && args.length === expectedArgs.length
+        && args.every((arg, index) => arg === expectedArgs[index]);
+}
+function isCanonicalMarketplace(value) {
+    return value.source === "github" && value.repo === CLAUDE_PLUGIN_MARKETPLACE_SOURCE;
+}
+async function removeLegacyManagedPlugin(home, runner, marketplaces, plugins) {
+    const marketplace = Array.isArray(marketplaces)
+        ? marketplaces.map(record).find((item) => item.name === LEGACY_MARKETPLACE)
+        : undefined;
+    const expectedPath = join(home, ".sensie", "claude-plugin-marketplace");
+    const managedMarketplace = marketplace !== undefined
+        && marketplace.source === "directory"
+        && marketplace.path === expectedPath;
+    const legacyInstalled = plugins.some((item) => item.id === LEGACY_PLUGIN_ID && item.scope === "user");
+    if (!managedMarketplace)
+        return !legacyInstalled;
+    if (legacyInstalled && (await runner.run("claude", [
+        "plugin", "uninstall", "--scope", "user", "--yes", LEGACY_PLUGIN_ID,
+    ])).exitCode !== 0) {
+        return false;
     }
+    return (await runner.run("claude", ["plugin", "marketplace", "remove", LEGACY_MARKETPLACE])).exitCode === 0;
 }
-async function pathExists(path) {
+async function jsonArrayCommand(runner, args) {
+    const result = await runner.run("claude", args);
+    if (result.exitCode !== 0)
+        throw new Error(`Claude command failed: ${args.join(" ")}`);
     try {
-        await readFile(path);
-        return true;
+        const parsed = JSON.parse(result.stdout);
+        if (!Array.isArray(parsed))
+            throw new Error("Claude returned a non-array JSON payload.");
+        return parsed;
     }
-    catch (error) {
-        if (error.code === "EISDIR")
-            return true;
-        try {
-            await stat(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
+    catch {
+        throw new Error(`Claude returned invalid JSON: ${args.join(" ")}`);
     }
 }
 function record(value) {