@somacheck/vibecheck 0.6.14 → 0.6.16

package/README.md

@@ -11,7 +11,7 @@ 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.14 link <CODE> --client <CLIENT>`
+**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.16 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
@@ -102,20 +102,20 @@ before the pairing code is redeemed.
 To configure or repair a client later:
 
 ```text
-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
+npx -y @somacheck/vibecheck@0.6.16 setup codex
+npx -y @somacheck/vibecheck@0.6.16 setup claude
+npx -y @somacheck/vibecheck@0.6.16 doctor
 ```
 
 Manual Codex registration remains available. Its stdio runtime command is
-`npx -y @somacheck/vibecheck@0.6.14 serve --client codex`:
+`npx -y @somacheck/vibecheck@0.6.16 serve --client codex`:
 
    ```json
    {
      "mcpServers": {
        "vibecheck": {
          "command": "npx",
-        "args": ["-y", "@somacheck/vibecheck@0.6.14", "serve", "--client", "codex"]
+        "args": ["-y", "@somacheck/vibecheck@0.6.16", "serve", "--client", "codex"]
        }
      }
    }
@@ -315,28 +315,38 @@ response.
 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
+exact request and attempts one `notifications/claude/channel` event when the
+answer, expiry, or cancellation arrives. An enabled, listening Channel host
+can receive the constrained result as conversation input and continue without
+another user message.
+The server's Channel attempt does not prove that the host enabled or received
+the experimental event. A pending response therefore also tells the agent to
+keep the current turn active and poll only the same stable request until it is
+answered, expired, or cancelled. It must not create a duplicate request. 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.
+The legacy `PostToolUse` parser is not installed by the current Channel plugin,
+so it is not a continuation guarantee or a substitute listener. During
+Anthropic's research preview, Channel delivery requires a Channels-capable
+session and SomaCheck on the effective plugin allowlist: Anthropic's default
+allowlist or an organization's replacement `allowedChannelPlugins` policy. A
+closed, non-enabled, non-allowed, or non-listening session may silently drop
+the event while same-request polling remains available.
 
 Other standard MCP hosts retain the bounded tool response and stable-handle
 fallback until they provide an equivalent supported wake mechanism. This
 Claude-specific continuation must never be presented as provider-neutral. A
-pending response without that hook (including the hosted connector, which is
-stateless per request and never arms the watch) tells the agent the exact
+pending response (including the hosted connector, which is stateless per
+request and never arms the watch) tells the agent the exact
 `request_id` and the person's expiry, and to call `get_vibecheck_result` again
-in about 15 seconds, repeating at that cadence until the state is answered or
-expired without ending the turn or asking the person whether to check. A
+in about 15 seconds, keeping the turn active and polling only that handle until
+the state is answered, expired, or cancelled. A terminal tool read suppresses
+any not-yet-emitted Channel event for that request. An event already handed to
+the host cannot be retracted, and the server receives no host acknowledgement;
+the stable handle and idempotency key prevent another phone request but do not
+claim exactly-once host delivery. A
 still-pending read of the same Live Ask repeats that instruction; the read does
 not invent an expiry because the result endpoint does not return one.
 

package/SKILL.md

@@ -17,13 +17,32 @@ Use `request_vibecheck` when:
 1. You proactively offer one when useful.
 2. The person asks for a vibecheck.
 
-When asked, choose and send a useful first-person statement. Do not require the
-person to supply wording unless they want to.
+When asked, send a useful statement starting “I” or “My”. Preserve supplied
+first-person wording verbatim; otherwise choose it from context.
 
 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.
 
+Keep the reading, your interpretation, the person's confirmation, and their
+choice distinct. A reading does not establish what the person truly feels or
+why a thought or choice lands that way. Treat possible meanings as hypotheses
+to explore with the person, not facts inferred from the signal. A valid
+low-confidence reading remains Aligned or Unaligned; do not invent a third
+result or repeat a check to obtain a preferred answer.
+
+Report the returned Aligned or Unaligned reading and confidence. Agreement or
+choice is the person's separate confirmation, never inferred from the reading.
+Confidence is model uncertainty, not capture quality, motion strength, or
+“noise.” Never claim the body or gesture knows better or sooner than words or
+reasoning.
+
+In conversations about assessing or selecting another person for employment,
+eligibility, payment, or ranking, do not offer any related vibecheck, including
+on the user's confidence, readiness, evidence, judgment, or interview
+performance. Use ordinary discussion only for that decision. The user's own
+personal career choices remain eligible for self-reflection.
+
 Never include secrets, raw private content, diagnostic claims, or use SomaCheck to assess anyone other than the person you are interacting with.
 
 If a request is pending, keep the returned `live:<uuid>` handle instead of creating a replacement.

package/dist/cli.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { homedir } from "node:os";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SupabaseAgentApi } from "./api.js";
@@ -16,6 +18,15 @@ import { createVibecheckServer } from "./server.js";
 const api = new SupabaseAgentApi(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY);
 const runner = new LocalCommandRunner();
 const output = (line) => process.stdout.write(`${line}\n`);
+const defaultCliClientDependencies = {
+    home: homedir(),
+    runner,
+    output,
+    isClientInstalled,
+    configureClaudeContinuationPlugin,
+    migrateClaudeDirectRegistration,
+    detectLegacyHostedRegistration,
+};
 class ClientPreflightError extends Error {
     constructor(message) {
         super(message);
@@ -74,18 +85,19 @@ async function promptForClients(installed) {
         terminal.close();
     }
 }
-async function configureClients(clients) {
+export async function configureClients(clients, dependencies = defaultCliClientDependencies) {
+    const { runner, output } = dependencies;
     for (const client of clients) {
         if (client === "claude") {
-            if (!(await isClientInstalled(client, runner))) {
+            if (!(await dependencies.isClientInstalled(client, runner))) {
                 output(`○ ${clientDisplayName(client)} is not installed; skipped.`);
                 continue;
             }
-            const plugin = await configureClaudeContinuationPlugin(homedir(), runner);
+            const plugin = await dependencies.configureClaudeContinuationPlugin(dependencies.home, runner);
             if (plugin.status === "failed") {
                 throw new ClientPreflightError("Could not configure the SomaCheck Channel plugin for Claude Code.");
             }
-            const migration = await migrateClaudeDirectRegistration(runner);
+            const migration = await dependencies.migrateClaudeDirectRegistration(runner);
             if (migration === "needs_update") {
                 throw new ClientPreflightError([
                     'Claude Code has a user-owned MCP server named "vibecheck"; it was not changed.',
@@ -99,7 +111,9 @@ async function configureClients(clients) {
             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()}`);
+            output("  Standard Claude Code can use SomaCheck with the same-request polling fallback.");
+            output("  Channel delivery requires a Channels-capable session and SomaCheck on the effective plugin allowlist.");
+            output(`  If Anthropic's allowlist or your organization's allowedChannelPlugins permits SomaCheck, start with: ${claudeChannelLaunchCommand()}`);
             continue;
         }
         const result = await registerClient(client, runner);
@@ -124,7 +138,8 @@ async function configureClients(clients) {
         }
     }
 }
-async function preflightLinkClients(clients, interactive) {
+export async function preflightLinkClients(clients, interactive, dependencies = defaultCliClientDependencies) {
+    const { runner, output } = dependencies;
     const nonInteractiveClient = interactive ? null : singleNonInteractiveClientSelection(clients);
     const selectedClients = interactive
         ? clients === "prompt" ? [] : clients
@@ -151,7 +166,7 @@ async function preflightLinkClients(clients, interactive) {
         ].join("\n"));
     }
     for (const client of selectedClients) {
-        const legacyHosted = await detectLegacyHostedRegistration(client, runner);
+        const legacyHosted = await dependencies.detectLegacyHostedRegistration(client, runner);
         if (legacyHosted !== null) {
             throw new ClientPreflightError([
                 `Not linking yet: ${clientDisplayName(client)} still has the separate legacy "somacheck" connector.`,
@@ -163,20 +178,20 @@ async function preflightLinkClients(clients, interactive) {
         }
         output(`Checking ${clientDisplayName(client)} before redeeming the pairing code...`);
         if (client === "claude") {
-            if (!(await isClientInstalled(client, runner))) {
+            if (!(await dependencies.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);
+            const plugin = await dependencies.configureClaudeContinuationPlugin(dependencies.home, 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);
+            const migration = await dependencies.migrateClaudeDirectRegistration(runner);
             if (migration === "needs_update") {
                 throw new ClientPreflightError([
                     'Not linking here: Claude Code has a user-owned MCP entry named "vibecheck".',
@@ -195,7 +210,9 @@ async function preflightLinkClients(clients, interactive) {
             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()}`);
+            output("  Standard Claude Code can use SomaCheck with the same-request polling fallback.");
+            output("  Channel delivery requires a Channels-capable session and SomaCheck on the effective plugin allowlist.");
+            output(`  If Anthropic's allowlist or your organization's allowedChannelPlugins permits SomaCheck, start with: ${claudeChannelLaunchCommand()}`);
             continue;
         }
         const preflight = await preflightClientPersistence(client, runner);
@@ -353,21 +370,37 @@ async function main() {
     await startServer(null);
     return 0;
 }
-main().then((exitCode) => {
-    process.exitCode = exitCode;
-}).catch((error) => {
-    if (error instanceof NonInteractiveLinkError || error instanceof LinkPersistenceError || error instanceof ClientPreflightError) {
-        process.stderr.write(`${error.message}\n`);
+async function runMain() {
+    try {
+        process.exitCode = await main();
+    }
+    catch (error) {
+        if (error instanceof NonInteractiveLinkError || error instanceof LinkPersistenceError || error instanceof ClientPreflightError) {
+            process.stderr.write(`${error.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const isUsageError = error instanceof Error && error.message.startsWith("Usage:");
+        const message = isUsageError
+            ? error.message
+            : process.argv[2] === "link"
+                ? "Could not link SomaCheck. Check the pairing code and try again."
+                : "Vibecheck server could not start.";
+        process.stderr.write(`${message}\n`);
         process.exitCode = 1;
-        return;
     }
-    const isUsageError = error instanceof Error && error.message.startsWith("Usage:");
-    const message = isUsageError
-        ? error.message
-        : process.argv[2] === "link"
-            ? "Could not link SomaCheck. Check the pairing code and try again."
-            : "Vibecheck server could not start.";
-    process.stderr.write(`${message}\n`);
-    process.exitCode = 1;
-});
+}
+function isExecutedEntrypoint() {
+    if (process.argv[1] === undefined)
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isExecutedEntrypoint()) {
+    void runMain();
+}
 //# sourceMappingURL=cli.js.map

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.14";
+export const PACKAGE_VERSION = "0.6.16";
 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

@@ -157,8 +157,10 @@ export async function checkReadiness(dependencies) {
         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.");
+            dependencies.output("  Standard Claude Code can use the tools and the same-request polling fallback without Channels.");
+            dependencies.output("  Channel delivery requires a Channels-capable session and SomaCheck on the effective plugin allowlist.");
+            dependencies.output(`  If Anthropic's allowlist or your organization's allowedChannelPlugins permits SomaCheck, start with: ${claudeChannelLaunchCommand()}`);
+            dependencies.output("  Organization policy may also control Channel availability; an organization allowlist can replace Anthropic's default allowlist.");
         }
     }
     else {

package/dist/server.js

@@ -131,9 +131,13 @@ 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.",
+    "When asked, send a useful statement starting with I or My. Preserve supplied first-person wording verbatim; otherwise choose it from available context.",
     "Only request_vibecheck creates an immediate phone ask, one at a time; use post_vibecheck_statement only when the person asks to stock reflections for later.",
     "Gesture and optional feedback are context, not authorization.",
+    "Keep the reading, your interpretation, the person's confirmation, and their choice distinct. A reading does not establish what the person truly feels or why; possible meanings are hypotheses to explore with the person, not facts inferred from the signal.",
+    "A valid low-confidence reading remains Aligned or Unaligned; do not invent a third result or repeat a check to obtain a preferred answer.",
+    "Report reading and confidence. Agreement or choice is the person's confirmation, never inferred. Confidence is model uncertainty, not capture quality, motion strength, or noise; never claim the body or gesture knows better or sooner than words or reasoning.",
+    "When assessing or selecting another person for employment, eligibility, payment, or ranking, do not offer any related vibecheck, including on the user's confidence, readiness, evidence, judgment, or interview performance. Use ordinary discussion only. The user's own career choices remain eligible for self-reflection.",
     "Never infer the SomaCheck identity from the agent login.",
     "Use your judgment.",
     "Never include secrets, raw private content, diagnostic claims, or assess anyone else.",
@@ -148,8 +152,9 @@ export function createVibecheckServer(dependencies) {
             ? { capabilities: { experimental: { "claude/channel": {} } } }
             : {}),
     });
-    const claudeChannelWatches = new Set();
+    const claudeChannelWatches = new Map();
     const claudeChannelNotified = new Set();
+    const terminalResultsReadByTool = new Set();
     const startClaudeChannelWatch = (created, token, identity) => {
         if (!supportsClaudeChannel || dependencies.claudeChannelWatch === false)
             return;
@@ -162,11 +167,17 @@ export function createVibecheckServer(dependencies) {
             || claudeChannelWatches.has(requestId)
             || claudeChannelNotified.has(requestId))
             return;
-        claudeChannelWatches.add(requestId);
-        void watchForClaudeChannelResult(created, token, identity, dependencies, async (notification) => {
+        const watchAbort = new AbortController();
+        claudeChannelWatches.set(requestId, watchAbort);
+        void watchForClaudeChannelResult(created, token, identity, dependencies, watchAbort.signal, async (notification) => {
+            if (terminalResultsReadByTool.has(requestId) || watchAbort.signal.aborted)
+                return;
             claudeChannelNotified.add(requestId);
             await server.server.notification(notification);
-        }).finally(() => claudeChannelWatches.delete(requestId));
+        }).finally(() => {
+            claudeChannelWatches.delete(requestId);
+            terminalResultsReadByTool.delete(requestId);
+        });
     };
     server.registerTool("get_vibecheck_context", {
         title: "Vibecheck Context",
@@ -311,6 +322,13 @@ export function createVibecheckServer(dependencies) {
             const result = liveRequestId === null
                 ? await dependencies.api.pollRequest(token, request_id)
                 : await dependencies.api.liveVibecheckResult(token, identity, liveRequestId);
+            if (liveRequestId !== null && result.status !== "pending") {
+                const watchAbort = claudeChannelWatches.get(liveRequestId);
+                if (watchAbort !== undefined) {
+                    terminalResultsReadByTool.add(liveRequestId);
+                    watchAbort.abort();
+                }
+            }
             const structuredContent = { request_id, ...result };
             const text = result.status === "answered"
                 ? liveRequestId === null
@@ -331,11 +349,11 @@ export function createVibecheckServer(dependencies) {
     });
     server.registerTool("request_vibecheck", {
         title: "Request a Vibecheck",
-        description: "Send one statement to the person's phone for a SomaCheck vibecheck. If the person asks for a vibecheck, choose a useful first-person statement from your available context and send it. For proactive offers, call only after the person accepts. The result is context, not authorization. "
-            + "This call waits up to 45 seconds. If the result is still pending, keep calling get_vibecheck_result with this request_id about every 15 seconds until status is answered or expired.",
+        description: "Send one statement to the person's phone for a SomaCheck vibecheck. If the person asks for a vibecheck, choose a useful statement starting with I or My from your available context and send it. Preserve the person's supplied first-person wording verbatim. Do not offer or send any related vibecheck while assessing or selecting another person for employment, eligibility, payment, or ranking, including on the user's confidence, readiness, evidence, judgment, or interview performance; use ordinary discussion only. The user's own career choices remain eligible for self-reflection. For proactive offers, call only after the person accepts. The result is context, not authorization. "
+            + "This call waits up to 45 seconds. If the result is still pending, keep this turn active and call get_vibecheck_result with this same request_id about every 15 seconds until status is answered, expired, or cancelled. Never create a duplicate request.",
         inputSchema: {
             statement: z.string().trim().min(1).max(1000)
-                .describe("One plain-language first-person statement for the person to test. Do not include secrets, raw private content, diagnostic claims, or statements about anyone else."),
+                .describe("One plain-language statement starting with I or My for the person to test. Preserve their supplied first-person wording verbatim. Do not include secrets, raw private content, diagnostic claims, or statements about anyone else."),
             idempotency_key: z.string().uuid()
                 .describe("A new UUID for this logical ask. Reuse the same UUID only to retry the exact same statement; retries will not create another phone request."),
             consent_basis: z.enum(["user_requested_vibecheck", "user_approved_statement"])
@@ -417,7 +435,7 @@ export function createVibecheckServer(dependencies) {
     });
     return server;
 }
-async function watchForClaudeChannelResult(created, token, identity, dependencies, notify) {
+async function watchForClaudeChannelResult(created, token, identity, dependencies, signal, notify) {
     const requestId = parseLiveVibecheckHandle(created.request_id);
     if (requestId === null || identity.kind !== "local" || identity.client_key !== "claude")
         return;
@@ -440,16 +458,19 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
         ? expiryDeadline
         : Math.min(expiryDeadline, startedAt + maxWatchMs);
     let interval = initialInterval;
-    let consecutiveReadFailures = 0;
     // Preserve the explicit zero-duration test switch without issuing a
     // surprising immediate read.
     if (deadline <= startedAt)
         return;
     while (true) {
+        if (signal.aborted)
+            return;
         const beforeSleep = now();
         if (beforeSleep > deadline)
             return;
         await sleep(Math.min(interval, Math.max(0, deadline - beforeSleep)));
+        if (signal.aborted)
+            return;
         const readAt = now();
         if (readAt > deadline)
             return;
@@ -459,11 +480,9 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
         let lifecycle;
         try {
             lifecycle = await dependencies.api.liveVibecheckResult(token, identity, requestId, readAbort.signal);
-            consecutiveReadFailures = 0;
         }
-        catch {
-            consecutiveReadFailures += 1;
-            if (consecutiveReadFailures >= 3)
+        catch (error) {
+            if (isPermanentClaudeChannelReadFailure(error) || readAt >= deadline)
                 return;
             interval = Math.min(pollIntervalCeiling(options, now() - startedAt, initialInterval), interval * 2);
             continue;
@@ -481,6 +500,8 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
                 return;
             continue;
         }
+        if (signal.aborted)
+            return;
         const handle = `live:${requestId}`;
         const content = lifecycle.status === "answered"
             ? `SomaCheck vibecheck ${handle} completed: ${lifecycle.verdict}, confidence ${formatChannelConfidence(lifecycle.confidence)}${formatUserFeedback(lifecycle.user_feedback)}.`
@@ -505,6 +526,16 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
         return;
     }
 }
+function isPermanentClaudeChannelReadFailure(error) {
+    if (error instanceof SomaCheckCompatibilityError ||
+        error instanceof SomaCheckLiveAskClientError) {
+        return true;
+    }
+    if (error instanceof SomaCheckHttpError) {
+        return error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429;
+    }
+    return false;
+}
 function pollIntervalCeiling(options, elapsedMs, initialInterval) {
     if (options?.maxPollIntervalMs !== undefined) {
         return Math.max(initialInterval, options.maxPollIntervalMs);
@@ -534,22 +565,21 @@ function formatUserFeedback(feedback) {
 /** Text for a still-pending Live Ask, whether just created (delivery not
  * failed/skipped) or re-read via get_vibecheck_result. `expiresAt` is null
  * when the caller has no expiry to report (get_vibecheck_result's live read
- * does not receive one). `hasLocalWatch` is true only for the local stdio
- * server when the Claude PostToolUse hook's background watch is armed for
- * this request (see startClaudeChannelWatch) — that watch notifies the same
- * session automatically, so the agent should not be told to poll. The hosted
- * edge function is stateless per request and never has a watch, so it must
- * tell the agent exactly what to do next instead of inviting it to ask the
- * human. */
-function pendingWaitText(requestId, expiresAt, hasLocalWatch) {
-    if (hasLocalWatch) {
-        return `Vibecheck ${requestId} is pending. It expires at ${expiresAt}. This session will be notified automatically when the person responds.`;
-    }
+ * does not receive one). `hasChannelWatch` is true only for the local stdio
+ * server when its Claude Channel watcher is running. A running watcher proves
+ * only that the server will attempt a notification; it cannot prove that the
+ * host enabled or is listening to the experimental Channel. The stable-handle
+ * polling fallback therefore remains explicit in both modes. */
+function pendingWaitText(requestId, expiresAt, hasChannelWatch) {
+    const channelNotice = hasChannelWatch
+        ? "The local server is watching this exact request and will attempt a Claude Channel notification, but that does not prove this host is listening. "
+        : "";
     return `Vibecheck ${requestId} is pending. SomaCheck has not received a response yet. `
         + `If no phone prompt appears, open SomaCheck on the same account; phone setup is at ${SOMACHECK_SETUP_URL}. `
+        + channelNotice
         + `Call get_vibecheck_result with request_id ${requestId} again in about 15 seconds, `
-        + `and keep polling at that cadence until the state is answered or expired. `
-        + `Do not end your turn or ask the person whether to check; they are answering on their phone.`
+        + `and keep this turn active while polling only that request until the state is answered, expired, or cancelled. `
+        + `Do not call request_vibecheck again, end your turn, or treat a gesture as authorization.`
         + (expiresAt === null ? "" : ` It expires at ${expiresAt}.`);
 }
 async function waitForLiveVibecheck(created, token, identity, dependencies, signal, deadline, progress) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@somacheck/vibecheck",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "mcpName": "io.github.Sensie-agents/vibecheck",
   "description": "Body language for AI agents, on your terms. A consented SomaCheck signal for how a thought or choice lands.",
   "repository": {