@somacheck/vibecheck 0.6.11 → 0.6.13

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,16 +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.11 link <CODE> --client <CLIENT>`
+**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.13 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 that can wake the same open session when
-the phone result arrives. 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
@@ -30,9 +34,10 @@ 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,
@@ -97,30 +102,62 @@ before the pairing code is redeemed.
 To configure or repair a client later:
 
 ```text
-npx -y @somacheck/vibecheck@0.6.11 setup codex
-npx -y @somacheck/vibecheck@0.6.11 setup claude
-npx -y @somacheck/vibecheck@0.6.11 doctor
+npx -y @somacheck/vibecheck@0.6.13 setup codex
+npx -y @somacheck/vibecheck@0.6.13 setup claude
+npx -y @somacheck/vibecheck@0.6.13 doctor
 ```
 
-Manual registration remains available:
+Manual Codex registration remains available. Its stdio runtime command is
+`npx -y @somacheck/vibecheck@0.6.13 serve --client codex`:
 
    ```json
    {
      "mcpServers": {
        "vibecheck": {
          "command": "npx",
-        "args": ["-y", "@somacheck/vibecheck@0.6.11", "serve", "--client", "codex"]
+        "args": ["-y", "@somacheck/vibecheck@0.6.13", "serve", "--client", "codex"]
        }
      }
    }
    ```
 
-   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.11 serve --client claude`
+   For Claude Code, install the public Channel plugin:
 
-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.
+   `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 --channels plugin:vibecheck@somacheck
+```
+
+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 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
@@ -179,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:
 
@@ -252,7 +289,7 @@ blocked until the capability and revocation probe in the safety review passes.
 | `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. |
 | `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` | Add one to three personalized statements without blocking; one may become the current Home vibe check and the rest wait under Vibe Checks without extra pushes. Returns a stable `request_id` for each. |
 | `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. |
 
@@ -275,14 +312,22 @@ cancellation stops result reads and preserves the backend request and
 idempotency key, but the cancelled MCP transport may suppress that pending
 response.
 
-Standard MCP cannot start a new agent turn after a tool call has ended. The
-Claude setup therefore installs a normal user-scoped plugin with an async
-`PostToolUse` hook. When `request_vibecheck` returns pending, that hook follows
-only the exact request and wakes the same open Claude Code session when the
-answer, expiry, or cancellation arrives. It passes the constrained result and
-opaque handle, never the statement or link token, and cannot create another
-phone request. No experimental launch flag is required. Restart Claude Code
-once after setup so it loads the plugin.
+Claude Code is the primary local experience. Its registered stdio server
+advertises Anthropic's experimental Channel capability. When
+`request_vibecheck` returns pending, the same local server follows only that
+exact request and emits one `notifications/claude/channel` event when the
+answer, expiry, or cancellation arrives. Claude receives the constrained
+result as conversation input and can continue without another user message.
+The event contains the binary reading, confidence, lifecycle, and opaque
+handle—never the statement, link token, raw motion, or an instruction that
+turns the result into authorization.
+
+The installed `PostToolUse` hook remains a compatibility fallback for an
+ordinary non-channel registration. A channel-armed response marks its
+continuation transport explicitly, and the hook abstains, so two watchers
+cannot wake the same turn. During Anthropic's research preview, the channel
+session must be launched with the command above; a closed or non-enabled
+session may silently drop the event.
 
 Other standard MCP hosts retain the bounded tool response and stable-handle
 fallback until they provide an equivalent supported wake mechanism. This
@@ -301,8 +346,10 @@ 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 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 agent maintains three distinct insights. SomaCheck presents one at a time;
 the other two remain cached. After a completed gesture, the next cached insight

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-hook.js

@@ -21,6 +21,10 @@ export function parsePendingClaudeAsk(input) {
     const structured = record(response.structuredContent ?? response.structured_content ?? response);
     if (structured.state !== "pending" || typeof structured.request_id !== "string")
         return null;
+    // The channel-enabled local server already owns this exact result watch.
+    // Abstaining prevents the PostToolUse fallback from waking Claude twice.
+    if (structured.continuation_transport === "claude_channel")
+        return null;
     if (structured.delivery_state === "failed" || structured.delivery_state === "skipped")
         return null;
     const requestId = parseHandle(structured.request_id);

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) {

package/dist/cli.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { createInterface } from "node:readline/promises";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SupabaseAgentApi } from "./api.js";
-import { clientDisplayName, detectInstalledClients, detectLegacyHostedRegistration, LocalCommandRunner, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, parseClientChoice, preflightClientPersistence, registerClient, singleNonInteractiveClientSelection, } from "./client-setup.js";
+import { claudeChannelLaunchCommand, clientDisplayName, detectInstalledClients, detectLegacyHostedRegistration, isClientInstalled, LocalCommandRunner, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, migrateClaudeDirectRegistration, parseClientChoice, preflightClientPersistence, registerClient, singleNonInteractiveClientSelection, } from "./client-setup.js";
 import { configureClaudeContinuationPlugin } from "./claude-plugin-setup.js";
 import { readConfig } from "./config.js";
 import { awaitClaudeVibecheckResult } from "./claude-hook.js";
@@ -11,6 +11,7 @@ import { PACKAGE_SPEC, SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from "./constant
 import { LinkPersistenceError, NonInteractiveLinkError, linkAgent } from "./link.js";
 import { checkReadiness } from "./readiness.js";
 import { formatRecipeDetail, formatRecipeList, formatRecipePrompt, getRecipeExperience } from "./recipes.js";
+import { parseRuntimeMode } from "./runtime-mode.js";
 import { createVibecheckServer } from "./server.js";
 const api = new SupabaseAgentApi(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY);
 const runner = new LocalCommandRunner();
@@ -30,6 +31,7 @@ function usage() {
         "  npx -y @somacheck/vibecheck recipes",
         "  npx -y @somacheck/vibecheck recipes --id <id> --format prompt",
         "  npx -y @somacheck/vibecheck recipe <id>",
+        "  npx -y @somacheck/vibecheck serve --client claude --channel",
     ].join("\n");
 }
 function parseLinkClient(args) {
@@ -46,11 +48,6 @@ function parseLinkClient(args) {
         return [];
     throw new Error(usage());
 }
-function parseServeClient(args) {
-    if (args.length !== 3 || args[0] !== "serve" || args[1] !== "--client")
-        return null;
-    return args[2] === "codex" || args[2] === "claude" ? args[2] : null;
-}
 async function promptForClients(installed) {
     if (installed.length === 0)
         return [];
@@ -79,6 +76,32 @@ async function promptForClients(installed) {
 }
 async function configureClients(clients) {
     for (const client of clients) {
+        if (client === "claude") {
+            if (!(await isClientInstalled(client, runner))) {
+                output(`○ ${clientDisplayName(client)} is not installed; skipped.`);
+                continue;
+            }
+            const plugin = await configureClaudeContinuationPlugin(homedir(), runner);
+            if (plugin.status === "failed") {
+                throw new ClientPreflightError("Could not configure the SomaCheck Channel plugin for Claude Code.");
+            }
+            const migration = await migrateClaudeDirectRegistration(runner);
+            if (migration === "needs_update") {
+                throw new ClientPreflightError([
+                    'Claude Code has a user-owned MCP server named "vibecheck"; it was not changed.',
+                    `Remove it only if it is obsolete: ${manualRemoveCommand(client)}`,
+                ].join("\n"));
+            }
+            if (migration === "failed" || migration === "not_installed") {
+                throw new ClientPreflightError("Could not remove the superseded direct SomaCheck MCP registration.");
+            }
+            output(`✓ SomaCheck Channel plugin ${plugin.status === "installed" ? "was configured" : "is current"} for Claude Code.`);
+            output("✓ Automatic SomaCheck marketplace updates are enabled for future reviewed releases.");
+            if (migration === "removed")
+                output("✓ Removed the superseded direct MCP registration.");
+            output(`  Start Claude Code with SomaCheck Channels: ${claudeChannelLaunchCommand()}`);
+            continue;
+        }
         const result = await registerClient(client, runner);
         if (result.status === "registered") {
             output(`✓ Configured ${clientDisplayName(client)}.`);
@@ -99,13 +122,6 @@ async function configureClients(clients) {
         else {
             output(`✗ Could not configure ${clientDisplayName(client)} automatically.`);
         }
-        if (client === "claude" && ["registered", "upgraded", "already_registered"].includes(result.status)) {
-            const plugin = await configureClaudeContinuationPlugin(homedir(), runner);
-            if (plugin.status === "failed") {
-                throw new ClientPreflightError("Could not configure automatic SomaCheck results for Claude Code. No pairing code was used.");
-            }
-            output(`✓ Automatic Claude result continuation ${plugin.status === "installed" ? "was configured" : "is ready"}.`);
-        }
     }
 }
 async function preflightLinkClients(clients, interactive) {
@@ -146,6 +162,42 @@ async function preflightLinkClients(clients, interactive) {
             ].join("\n"));
         }
         output(`Checking ${clientDisplayName(client)} before redeeming the pairing code...`);
+        if (client === "claude") {
+            if (!(await isClientInstalled(client, runner))) {
+                throw new ClientPreflightError([
+                    "Not linking here: Claude Code is not installed or its CLI is unavailable.",
+                    "The pairing code has NOT been used.",
+                ].join("\n"));
+            }
+            const plugin = await configureClaudeContinuationPlugin(homedir(), runner);
+            if (plugin.status === "failed") {
+                throw new ClientPreflightError([
+                    "Not linking here: the SomaCheck Channel plugin could not be installed and verified for Claude Code.",
+                    "The pairing code has NOT been used. Repair Claude's plugin setup, then run the link command again.",
+                ].join("\n"));
+            }
+            const migration = await migrateClaudeDirectRegistration(runner);
+            if (migration === "needs_update") {
+                throw new ClientPreflightError([
+                    'Not linking here: Claude Code has a user-owned MCP entry named "vibecheck".',
+                    "It was not changed because its command does not match a SomaCheck-managed registration.",
+                    `Remove it only if it is obsolete: ${manualRemoveCommand(client)}`,
+                    "The pairing code has NOT been used.",
+                ].join("\n"));
+            }
+            if (migration === "failed" || migration === "not_installed") {
+                throw new ClientPreflightError([
+                    "Not linking here: the superseded direct SomaCheck MCP registration could not be removed safely.",
+                    "The pairing code has NOT been used.",
+                ].join("\n"));
+            }
+            output("✓ Claude Code has one exact, plugin-scoped SomaCheck Channel server.");
+            output("✓ Automatic SomaCheck marketplace updates are enabled for future reviewed releases.");
+            if (migration === "removed")
+                output("✓ Removed the superseded direct MCP registration before redeeming the pairing code.");
+            output(`  Start Claude Code with SomaCheck Channels: ${claudeChannelLaunchCommand()}`);
+            continue;
+        }
         const preflight = await preflightClientPersistence(client, runner);
         if (preflight.status === "ready") {
             output(`✓ ${clientDisplayName(client)} already has the exact SomaCheck MCP registration.`);
@@ -171,16 +223,6 @@ async function preflightLinkClients(clients, interactive) {
                 "run the link command again.",
             ].join("\n"));
         }
-        if (client === "claude") {
-            const plugin = await configureClaudeContinuationPlugin(homedir(), runner);
-            if (plugin.status === "failed") {
-                throw new ClientPreflightError([
-                    "Not linking here: automatic SomaCheck result continuation could not be configured for Claude Code.",
-                    "The pairing code has NOT been used. Repair Claude's plugin setup, then run the link command again.",
-                ].join("\n"));
-            }
-            output("✓ Automatic Claude result continuation is ready before redeeming the pairing code.");
-        }
     }
     return selectedClients;
 }
@@ -201,13 +243,15 @@ async function refreshRuntimeHealth(client) {
         context_probe_ok: true,
     });
 }
-async function startServer(runtimeClient) {
+async function startServer(runtime) {
+    const runtimeClient = runtime?.client ?? null;
     const server = createVibecheckServer({
         api,
         loadToken: async () => (await readConfig(homedir(), runtimeClient ?? undefined)).token,
         identity: runtimeClient === null
             ? { kind: "legacy" }
             : { kind: "local", client_key: runtimeClient },
+        ...(runtime?.claudeChannel ? { claudeChannelWatch: {} } : {}),
     });
     await server.connect(new StdioServerTransport());
     if (runtimeClient !== null) {
@@ -299,9 +343,9 @@ async function main() {
             throw new Error(usage());
         return (await runDoctor()) ? 0 : 2;
     }
-    const runtimeClient = parseServeClient(args);
-    if (runtimeClient !== null) {
-        await startServer(runtimeClient);
+    const runtime = parseRuntimeMode(args);
+    if (runtime !== null) {
+        await startServer(runtime);
         return 0;
     }
     if (args.length !== 0)

package/dist/client-setup.js

@@ -26,13 +26,17 @@ export function clientDisplayName(client) {
     return client === "codex" ? "Codex / ChatGPT desktop" : "Claude Code";
 }
 function mcpServerArgs(client) {
-    return ["-y", PACKAGE_SPEC, "serve", "--client", client];
+    const args = ["-y", PACKAGE_SPEC, "serve", "--client", client];
+    return client === "claude" ? [...args, "--channel"] : args;
+}
+export function claudeChannelLaunchCommand() {
+    return "claude --channels plugin:vibecheck@somacheck";
 }
 export function manualSetupCommand(client) {
     if (client === "codex") {
         return `codex mcp add ${MCP_SERVER_NAME} -- npx ${mcpServerArgs(client).join(" ")}`;
     }
-    return `claude mcp add --scope user ${MCP_SERVER_NAME} -- npx ${mcpServerArgs(client).join(" ")}`;
+    return `npx -y ${PACKAGE_SPEC} setup claude`;
 }
 export function manualRemoveCommand(client) {
     return client === "codex"
@@ -139,28 +143,46 @@ function isManagedSomaCheckRegistration(client, stdout) {
     // earlier exact 0.6 patch release. Custom wrappers, extra arguments,
     // disabled entries, later versions, and registrations naming the other
     // client remain user-owned.
-    const previousExactClient = (/^@somacheck\/vibecheck@0\.5\.\d+$/.test(packageArg)
-        || packageArg === "@somacheck/vibecheck@0.6.0"
-        || packageArg === "@somacheck/vibecheck@0.6.1"
-        || packageArg === "@somacheck/vibecheck@0.6.2"
-        || packageArg === "@somacheck/vibecheck@0.6.3"
-        || packageArg === "@somacheck/vibecheck@0.6.4"
-        || packageArg === "@somacheck/vibecheck@0.6.5"
-        || packageArg === "@somacheck/vibecheck@0.6.6"
-        || packageArg === "@somacheck/vibecheck@0.6.7"
-        || packageArg === "@somacheck/vibecheck@0.6.8"
-        || packageArg === "@somacheck/vibecheck@0.6.9")
-        && args.length === 5
-        && args[0] === "-y"
-        && args[1] === packageArg
-        && args[2] === "serve"
-        && args[3] === "--client"
-        && args[4] === client;
-    return previousExactClient;
+    const version = parseExactSemver(packageArg.slice("@somacheck/vibecheck@".length));
+    const currentVersion = parseExactSemver(PACKAGE_SPEC.slice("@somacheck/vibecheck@".length));
+    if (version === null || currentVersion === null
+        || compareSemver(version, [0, 5, 0]) < 0
+        || compareSemver(version, currentVersion) >= 0)
+        return false;
+    const expected = ["-y", packageArg, "serve", "--client", client];
+    if (client === "claude" && compareSemver(version, [0, 6, 12]) >= 0) {
+        expected.push("--channel");
+    }
+    return args.length === expected.length
+        && args.every((arg, index) => arg === expected[index]);
+}
+function parseExactSemver(value) {
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(value);
+    return match === null ? null : [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return 0;
 }
 export async function isClientRegistered(client, runner) {
     return (await clientRegistrationState(client, runner)) === "current";
 }
+export async function migrateClaudeDirectRegistration(runner) {
+    if (!(await isClientInstalled("claude", runner)))
+        return "not_installed";
+    const state = await clientRegistrationState("claude", runner);
+    if (state === "missing")
+        return "absent";
+    if (state === "needs_update")
+        return "needs_update";
+    const removed = await runner.run("claude", ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]);
+    if (removed.exitCode !== 0)
+        return "failed";
+    return (await clientRegistrationState("claude", runner)) === "missing" ? "removed" : "failed";
+}
 export async function detectInstalledClients(runner) {
     const clients = ["codex", "claude"];
     const installed = await Promise.all(clients.map(async (client) => ({

package/dist/constants.js

@@ -2,7 +2,7 @@
 export const SUPABASE_URL = "https://pbldcmniommltbdwuykk.supabase.co";
 export const SUPABASE_PUBLISHABLE_KEY = "sb_publishable_af-lUNI2FqEcb-oGy-4uxQ_cnm6kY85";
 export const PACKAGE_NAME = "@somacheck/vibecheck";
-export const PACKAGE_VERSION = "0.6.11";
+export const PACKAGE_VERSION = "0.6.13";
 export const PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
 export const SOMACHECK_SETUP_URL = "https://testflight.apple.com/join/C4mAH3zz";
 export const MCP_SERVER_NAME = "vibecheck";

package/dist/readiness.js

@@ -1,29 +1,8 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { readConfig } from "./config.js";
+import { isClaudeChannelPluginConfigured, isClaudeMarketplaceAutoUpdateConfigured, } from "./claude-plugin-setup.js";
 import { SomaCheckCompatibilityError, SomaCheckHttpError } from "./api.js";
-import { clientDisplayName, clientRegistrationState, detectLegacyHostedRegistration, isClientInstalled, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, } from "./client-setup.js";
+import { claudeChannelLaunchCommand, clientDisplayName, clientRegistrationState, detectLegacyHostedRegistration, isClientInstalled, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, } from "./client-setup.js";
 import { BACKEND_PROTOCOL_VERSION, PACKAGE_VERSION, SOMACHECK_SETUP_URL } from "./constants.js";
-function vibecheckRegistrationCount(value) {
-    if (!value || typeof value !== "object")
-        return 0;
-    let count = 0;
-    for (const [key, child] of Object.entries(value)) {
-        if (key === "mcpServers" && child && typeof child === "object" && !Array.isArray(child)) {
-            count += Object.keys(child).filter((name) => name.startsWith("vibecheck")).length;
-        }
-        count += vibecheckRegistrationCount(child);
-    }
-    return count;
-}
-async function claudeVibecheckRegistrationCount(home) {
-    try {
-        return vibecheckRegistrationCount(JSON.parse(await readFile(join(home, ".claude.json"), "utf8")));
-    }
-    catch {
-        return 0;
-    }
-}
 export async function checkReadiness(dependencies) {
     let token;
     try {
@@ -71,11 +50,6 @@ export async function checkReadiness(dependencies) {
         }
     }
     const backendReachable = statusProbeOk && contextProbeOk;
-    const claudeRegistrationCount = await claudeVibecheckRegistrationCount(dependencies.home);
-    if (claudeRegistrationCount > 1) {
-        dependencies.output(`○ Multiple Claude Code registrations whose names start with "vibecheck" were found (${claudeRegistrationCount}).`);
-        dependencies.output("  Remove stale entries from ~/.claude.json so only the current user-scope vibecheck registration remains.");
-    }
     const clients = ["codex", "claude"];
     let installedClientCount = 0;
     let hasLegacyHostedRegistration = false;
@@ -95,6 +69,29 @@ export async function checkReadiness(dependencies) {
             dependencies.output(`  Optional manual cleanup: ${manualLegacyHostedRemoveCommand(client)}`);
         }
         const registration = await clientRegistrationState(client, dependencies.runner);
+        if (client === "claude") {
+            const pluginConfigured = await isClaudeChannelPluginConfigured(dependencies.runner);
+            if (!pluginConfigured) {
+                dependencies.output("✗ Claude Code does not have the exact SomaCheck Channel plugin.");
+                dependencies.output(`  Run: ${manualSetupCommand(client)}`);
+                continue;
+            }
+            if (!(await isClaudeMarketplaceAutoUpdateConfigured(dependencies.home))) {
+                dependencies.output("✗ Automatic SomaCheck plugin updates are not enabled for Claude Code.");
+                dependencies.output(`  Run: ${manualSetupCommand(client)}`);
+                continue;
+            }
+            if (registration !== "missing") {
+                dependencies.output('✗ Claude Code also has a direct MCP server named "vibecheck".');
+                dependencies.output("  The plugin is installed, but the duplicate direct tool surface must be removed.");
+                dependencies.output(`  Run: ${manualRemoveCommand(client)}`);
+                continue;
+            }
+            registeredClients.push(client);
+            dependencies.output("✓ Claude Code has one exact, plugin-scoped SomaCheck Channel server.");
+            dependencies.output("✓ Automatic SomaCheck marketplace updates are enabled.");
+            continue;
+        }
         if (registration === "current") {
             registeredClients.push(client);
             dependencies.output(`✓ ${clientDisplayName(client)} is configured.`);
@@ -156,9 +153,17 @@ export async function checkReadiness(dependencies) {
         dependencies.output('✗ Remove the legacy "somacheck" connector before this setup can be Ready.');
     }
     const ready = readyClients.length > 0;
-    dependencies.output(ready
-        ? "Ready. Restart your agent client, then ask it to check your SomaCheck status."
-        : "Setup is not complete yet. Fix the items marked ✗, then run: vibecheck doctor");
+    if (ready) {
+        dependencies.output("Setup checks pass. Restart your agent client, then ask it to check your SomaCheck status.");
+        if (readyClients.includes("claude")) {
+            dependencies.output("○ Doctor verifies Claude's installed plugin and backend compatibility, not a running Channel session.");
+            dependencies.output(`  Start Claude with: ${claudeChannelLaunchCommand()}`);
+            dependencies.output("  Team/Enterprise use also requires the administrator to allowlist this plugin.");
+        }
+    }
+    else {
+        dependencies.output("Setup is not complete yet. Fix the items marked ✗, then run: vibecheck doctor");
+    }
     return { linked: true, backendReachable, backendCompatible, registeredClients, readyClients, ready };
 }
 //# sourceMappingURL=readiness.js.map

package/dist/runtime-mode.js

@@ -0,0 +1,14 @@
+/** Parse only the exact stdio runtime forms installed by this package.
+ * Claude Channels are local-only and must never be enabled for Codex. */
+export function parseRuntimeMode(args) {
+    if (args[0] !== "serve" || args[1] !== "--client")
+        return null;
+    if (args.length === 3 && (args[2] === "codex" || args[2] === "claude")) {
+        return { client: args[2], claudeChannel: false };
+    }
+    if (args.length === 4 && args[2] === "claude" && args[3] === "--channel") {
+        return { client: "claude", claudeChannel: true };
+    }
+    return null;
+}
+//# sourceMappingURL=runtime-mode.js.map

package/dist/server.js

@@ -20,6 +20,11 @@ const LIVE_ASK_POLL_DELAYS_MS = [
     4_000, 4_000, 4_000, 4_000, 4_000, 4_000, 4_000, 4_000, 4_000,
 ];
 const CLAUDE_CHANNEL_POLL_INTERVAL_MS = 2_000;
+const CLAUDE_CHANNEL_ACTIVE_POLL_WINDOW_MS = 30 * 60 * 1_000;
+const CLAUDE_CHANNEL_EXTENDED_POLL_WINDOW_MS = 2 * 60 * 60 * 1_000;
+const CLAUDE_CHANNEL_ACTIVE_MAX_POLL_INTERVAL_MS = 15 * 1_000;
+const CLAUDE_CHANNEL_EXTENDED_MAX_POLL_INTERVAL_MS = 30 * 1_000;
+const CLAUDE_CHANNEL_LONG_MAX_POLL_INTERVAL_MS = 60 * 1_000;
 const CLAUDE_CHANNEL_MAX_WATCH_MS = 15 * 60 * 1_000;
 const CLAUDE_CHANNEL_RESULT_TIMEOUT_MS = 10_000;
 function abortAwareSleep(milliseconds, signal) {
@@ -105,6 +110,7 @@ const liveAskSchema = {
     delivery_state: z.enum(["queued", "processing", "sent", "failed", "skipped"]).nullable(),
     cooldown_until: z.string().datetime({ offset: true }).nullable(),
     error_code: liveAskErrorCodeSchema.nullable(),
+    continuation_transport: z.enum(["poll", "claude_channel"]).nullable().optional(),
 };
 const agentContextTypeSchema = z.enum([
     "goal", "project", "decision", "commitment", "tension", "question",
@@ -125,11 +131,10 @@ const contextShareSchema = {
 const SERVER_INSTRUCTIONS = [
     "SomaCheck lets you ask your person for a vibecheck.",
     "Offer one when useful or when asked.",
-    "When asked, choose and send a useful first-person statement from available context; do not ask for wording unless they want to.",
-    "Only request_vibecheck creates an immediate phone ask; post_vibecheck_statement adds optional reflections under Settings → Vibe Checks, never Home.",
-    "Help them gain insight from the context you have.",
+    "When asked, choose and send a useful first-person statement from available context.",
+    "Only request_vibecheck creates an immediate phone ask; post_vibecheck_statement stocks Settings → Vibe Checks, with one current on Home and the rest Up next.",
     "Gesture and optional feedback are context, not authorization.",
-    "The SomaCheck account can differ from the host account; never infer its identity from the agent login.",
+    "Never infer the SomaCheck identity from the agent login.",
     "Use your judgment.",
     "Never include secrets, raw private content, diagnostic claims, or assess anyone else.",
 ].join(" ");
@@ -250,7 +255,7 @@ export function createVibecheckServer(dependencies) {
     });
     server.registerTool("post_vibecheck_statement", {
         title: "Post Vibecheck Statement",
-        description: "Fill Settings → Vibe Checks with one to three optional personalized reflections and return immediately. These are quiet feed inventory, never additional Home asks after request_vibecheck. Call get_vibecheck_status first and submit exactly propositions_needed statements.",
+        description: "Stock Settings → Vibe Checks with one to three optional personalized reflections and return immediately. One can become the current Home proposition; the rest stay Up next without extra pushes. Never call this to add follow-up asks after request_vibecheck. Call get_vibecheck_status first and submit exactly propositions_needed statements.",
         inputSchema: {
             statements: z.array(z.string().min(1)).min(1).max(3)
                 .describe("Distinct personalized statements for this person to test, ordered most useful first."),
@@ -271,7 +276,7 @@ export function createVibecheckServer(dependencies) {
             return {
                 content: [{
                         type: "text",
-                        text: `Added ${created.length} under Settings → Vibe Checks: ${presented} ready, ${queued} cached. No additional Home ask was created.`,
+                        text: `Added ${created.length} under Settings → Vibe Checks: ${presented} current, ${queued} Up next. This is asynchronous feed inventory, not an immediate request.`,
                     }],
                 structuredContent: { propositions: created },
             };
@@ -381,7 +386,15 @@ export function createVibecheckServer(dependencies) {
                 });
             });
             startClaudeChannelWatch(result, token, identity);
-            const structuredContent = { ...result, error_code: null };
+            const channelArmed = supportsClaudeChannel
+                && result.state === "pending"
+                && result.delivery_state !== "failed"
+                && result.delivery_state !== "skipped";
+            const structuredContent = {
+                ...result,
+                error_code: null,
+                ...(channelArmed ? { continuation_transport: "claude_channel" } : {}),
+            };
             const text = result.state === "completed"
                 ? `Vibecheck completed: ${result.verdict}, confidence ${formatChannelConfidence(result.confidence)}${formatUserFeedback(result.user_feedback)}.`
                 : result.state === "pending"
@@ -390,7 +403,7 @@ export function createVibecheckServer(dependencies) {
                             + `Open SomaCheck on your phone, signed into the same account, and check Home. `
                             + `If you do not have the app, install it at ${SOMACHECK_SETUP_URL} and finish phone setup. `
                             + `Keep this request ID; do not create a duplicate or claim the phone received it. It expires at ${result.expires_at}.`
-                        : pendingWaitText(result.request_id, result.expires_at, supportsClaudeChannel)
+                        : pendingWaitText(result.request_id, result.expires_at, channelArmed)
                     : `This vibecheck is ${result.state}.`;
             return { content: [{ type: "text", text }], structuredContent };
         }
@@ -411,14 +424,34 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
     const options = dependencies.claudeChannelWatch || undefined;
     const now = options?.now ?? Date.now;
     const sleep = options?.sleep ?? unrefSleep;
-    const interval = options?.pollIntervalMs ?? CLAUDE_CHANNEL_POLL_INTERVAL_MS;
+    const initialInterval = Math.max(1, options?.pollIntervalMs ?? CLAUDE_CHANNEL_POLL_INTERVAL_MS);
+    const startedAt = now();
     const maxWatchMs = options?.maxWatchMs ?? CLAUDE_CHANNEL_MAX_WATCH_MS;
     const parsedExpiry = created.expires_at === null ? Number.NaN : Date.parse(created.expires_at);
-    const deadline = Math.min(Number.isFinite(parsedExpiry) ? parsedExpiry : now() + maxWatchMs, now() + maxWatchMs);
+    const hasExpiry = Number.isFinite(parsedExpiry);
+    // A valid expiry is authoritative in production. The short grace window
+    // permits one result read after expiry, when the API transitions a still-
+    // pending request to its terminal state. maxWatchMs remains an explicit
+    // deterministic-test cap, but is never an implicit production cap.
+    const expiryDeadline = hasExpiry
+        ? Math.max(startedAt, parsedExpiry) + CLAUDE_CHANNEL_RESULT_TIMEOUT_MS
+        : startedAt + maxWatchMs;
+    const deadline = options?.maxWatchMs === undefined
+        ? expiryDeadline
+        : Math.min(expiryDeadline, startedAt + maxWatchMs);
+    let interval = initialInterval;
     let consecutiveReadFailures = 0;
-    while (now() < deadline) {
-        await sleep(Math.min(interval, Math.max(0, deadline - now())));
-        if (now() >= deadline)
+    // Preserve the explicit zero-duration test switch without issuing a
+    // surprising immediate read.
+    if (deadline <= startedAt)
+        return;
+    while (true) {
+        const beforeSleep = now();
+        if (beforeSleep > deadline)
+            return;
+        await sleep(Math.min(interval, Math.max(0, deadline - beforeSleep)));
+        const readAt = now();
+        if (readAt > deadline)
             return;
         const readAbort = new AbortController();
         const readTimeout = setTimeout(() => readAbort.abort(new Error("Claude channel result read timed out.")), CLAUDE_CHANNEL_RESULT_TIMEOUT_MS);
@@ -432,13 +465,22 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
             consecutiveReadFailures += 1;
             if (consecutiveReadFailures >= 3)
                 return;
+            interval = Math.min(pollIntervalCeiling(options, now() - startedAt, initialInterval), interval * 2);
             continue;
         }
         finally {
             clearTimeout(readTimeout);
         }
-        if (lifecycle.status === "pending")
+        if (lifecycle.status === "pending") {
+            // Keep a responsive first check, then avoid a long-lived hot poll while
+            // still checking often enough to deliver shortly after completion. The
+            // active window stays at <=15s so a result feels immediate in a normal
+            // gesture; only unusually long-lived requests relax their cadence.
+            interval = Math.min(pollIntervalCeiling(options, now() - startedAt, initialInterval), interval * 2);
+            if (readAt >= deadline)
+                return;
             continue;
+        }
         const handle = `live:${requestId}`;
         const content = lifecycle.status === "answered"
             ? `SomaCheck vibecheck ${handle} completed: ${lifecycle.verdict}, confidence ${formatChannelConfidence(lifecycle.confidence)}${formatUserFeedback(lifecycle.user_feedback)}.`
@@ -463,6 +505,18 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
         return;
     }
 }
+function pollIntervalCeiling(options, elapsedMs, initialInterval) {
+    if (options?.maxPollIntervalMs !== undefined) {
+        return Math.max(initialInterval, options.maxPollIntervalMs);
+    }
+    if (elapsedMs < CLAUDE_CHANNEL_ACTIVE_POLL_WINDOW_MS) {
+        return Math.max(initialInterval, CLAUDE_CHANNEL_ACTIVE_MAX_POLL_INTERVAL_MS);
+    }
+    if (elapsedMs < CLAUDE_CHANNEL_EXTENDED_POLL_WINDOW_MS) {
+        return Math.max(initialInterval, CLAUDE_CHANNEL_EXTENDED_MAX_POLL_INTERVAL_MS);
+    }
+    return Math.max(initialInterval, CLAUDE_CHANNEL_LONG_MAX_POLL_INTERVAL_MS);
+}
 function unrefSleep(milliseconds) {
     if (milliseconds <= 0)
         return Promise.resolve();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@somacheck/vibecheck",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "mcpName": "io.github.Sensie-agents/vibecheck",
-  "description": "Send a consented vibecheck to SomaCheck and use the result as a signal.",
+  "description": "Body language for AI agents, on your terms. A consented SomaCheck signal for how a thought or choice lands.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Sensie-agents/vibecheck.git"
@@ -17,8 +17,7 @@
   "files": [
     "dist/*.js",
     "SKILL.md",
-    "recipes/**",
-    "claude-marketplace/**"
+    "recipes/**"
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",

package/claude-marketplace/.claude-plugin/marketplace.json

@@ -1,22 +0,0 @@
-{
-  "name": "somacheck-local",
-  "owner": {
-    "name": "Sensie",
-    "email": "agents@joinsensie.com"
-  },
-  "description": "SomaCheck integration installed by the official vibecheck package.",
-  "plugins": [
-    {
-      "name": "vibecheck",
-      "source": "./plugins/vibecheck",
-      "description": "Let Claude offer a vibecheck and continue when the phone result arrives.",
-      "version": "0.6.11",
-      "author": {
-        "name": "Sensie",
-        "email": "agents@joinsensie.com"
-      },
-      "category": "productivity",
-      "tags": ["vibecheck", "somacheck", "decision-support", "mcp"]
-    }
-  ]
-}

package/claude-marketplace/plugins/vibecheck/.claude-plugin/plugin.json

@@ -1,13 +0,0 @@
-{
-  "name": "vibecheck",
-  "description": "Let Claude offer a SomaCheck vibecheck and continue when the phone result arrives.",
-  "version": "0.6.11",
-  "author": {
-    "name": "Sensie",
-    "email": "agents@joinsensie.com"
-  },
-  "homepage": "https://github.com/Sensie-agents/vibecheck",
-  "repository": "https://github.com/Sensie-agents/vibecheck",
-  "license": "MIT",
-  "keywords": ["vibecheck", "somacheck", "decision-support", "mcp"]
-}

package/claude-marketplace/plugins/vibecheck/hooks/hooks.json

@@ -1,18 +0,0 @@
-{
-  "description": "Continue an ordinary Claude Code session when a SomaCheck result arrives.",
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "mcp__vibecheck__request_vibecheck",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx -y @somacheck/vibecheck@0.6.11 claude-hook await-result",
-            "asyncRewake": true,
-            "timeout": 900
-          }
-        ]
-      }
-    ]
-  }
-}